Introducao_a_Programacao_-_Capitulo_4

Prévia do material em texto

82
Introdução a Programação
Capítulo 4 – Estruturas de 
Dados Homogêneas
As estruturas de dados homogêneas correspondem a conjuntos 
de elementos de um mesmo tipo, representados por um único 
nome. E isso é muito útil! Quer ver? Imagine, por exemplo, como 
poderíamos construir um algoritmo, que lesse os nomes de 500 
pessoas e imprimisse um relatório destes mesmos nomes ordenados 
alfabeticamente. Com o que sabemos até agora, isso não seria uma 
tarefa simples! Isso porque teríamos que definir 500 variáveis do tipo 
caracter e ler essas 500 variáveis, como é mostrado abaixo:
algoritmo “Inviável”
var
 nome1, nome2, nome3, ..., nome499, nome500: caracter
inicio
 escreva(“Digite o nome 1: ”)
 leia(nome1)
 escreva(“Digite o nome 2: “)
 leia (nome2) 
 ...
 escreva(“Digite o nome 500: “)
 leia(nome500)
 ...
fimalgoritmo
Não seria possível nem usar um laço para facilitar a leitura, visto 
que o nome das variáveis muda (nom1, nome2, etc). Dessa forma, 
seria enorme o tamanho do algoritmo e o trabalho braçal necessário 
para construí-lo. 
Para resolver problemas como este e outros, existem as estruturas 
de dados. A declaração de uma estrutura de dados corresponde, na 
verdade, à declaração de várias posições de memória, cujo identificador 
difere apenas por um índice. Onde este índice corresponde a um valor 
numérico começando por 0. E cada posição do conjunto, representada 
por um índice, pode receber valores no decorrer do algoritmo, como 
se fosse uma variável comum. Por exemplo, para o algoritmo anterior, 
poderíamos ter uma estrutura de dados chamada Alunos e ela 
83
Introdução a Programação
referenciar um conjunto de posições de memória, referenciadas por 
um índice e em cada um dos índices, poderia ser armazenado um 
nome.
0 1 2 ... 498 499
Alunos Rosa Ana Pedro ...
As estruturas homogêneas podem variar de acordo com a 
quantidade de índices necessários para localizar um valor dentro do 
conjunto. A estrutura de dados homogênea unidimensional (Figura 
28, estrutura V), também conhecida como vetor, necessita apenas 
de um índice para localização dos elementos do conjunto. Já a 
estrutura de dados homogênea bidimensional (Figura 28 – estrutura 
M), também conhecida como matriz (aquela mesma matriz que você 
estudou na matemática!), necessita de dois índices (linha e coluna) 
para localização de um elemento dentro do conjunto. Existem ainda 
estruturas multidimensionais, onde é utilizado um índice para localizar 
o elemento em CADA uma das dimensões da estrutura. Por exemplo, 
uma estrutura tridimensional (Figura 28 – estrutura T), como tem 3 
dimensões, necessitaria de 3 índices para localizar um elemento 
dentro da estrutura.
Figura 28 - Exemplos de Estruturas Homogêneas
Cada elemento das estruturas (Figura 28) seria referenciado 
através de índices (que sempre iniciam no valor zero).
» Para localizar um elemento do vetor V, usa-se apenas um 
índice. Exemplos: V[1] = 4 e V[2] = 10. 
» Para localizar um elemento dentro da matriz M usam-se dois 
índices, o da linha e o da coluna. Por exemplo, M[1,1] = 55 , ou 
seja, o elemento da linha 1, coluna 1 da matriz. Outro exemplo, 
M[2,3] = 47.
84
Introdução a Programação
» Para localizar um elemento dentro da estrutura tridimensional 
T, seriam usados 3 índices. Um para localizar a “cartela” de 
elementos, depois, um índice para a linha e outro para a coluna. 
Por exemplo, T[0,3,1] = 88, seria pegar a “cartela” 0, a da frente 
e, nela, a linha 3 e a coluna 1. Outro exemplo, T[2,0,1] = 6
Exploraremos nas seções a seguir apenas as estruturas 
unidimensionais e bidimensionais, apesar de ainda dar um exemplo 
de estrutura multidimensional.
Estruturas Homogêneas Unidimensionais 
(Vetores)
Estruturas de dados homogêneas unidimensionais, também 
conhecidas como vetores, são referenciadas por um único índice.
Estrutura de Dados Unidimensional = Conjunto de Dados
onde cada elemento é identificado por um único índice.
Por exemplo, se definíssemos um conjunto de nomes de alunos de 
uma turma chamado Alunos, cada aluno gravado dentro da estrutura 
seria referenciado por um índice. Essa estrutura está representada na 
Figura 29. Se desejássemos pegar o aluno da posição 4, usaríamos 
o nome do vetor e, entre colchetes, o índice desejado: Alunos[4], daí 
conseguiríamos pegar o valor “José”.
Figura 29 - Exemplo de Estrutura Unidimensional
O vetor é declarado na área de declaração de variáveis e a sintaxe 
para declaração é:
nomeVetor : vetor [VI..VF] de Tipo
85
Introdução a Programação
onde:
» nomeVetor é o nome que você quer dar a variável vetor na 
memória. 
» vetor é palavra reservada para indicar a criação da estrutura 
homogênea
» [VI..VF] Vi é o valor inicial do índice do vetor e VF o valor final. 
Eles devem ser SEMPRE números inteiros positivos. 
» Tipo = é o tipo de elemento que você quer gravar dentro do 
vetor. Lembrando que todas as posições do vetor terão esse 
mesmo tipo (inteiro, real, caracter ou lógico).
Exemplo: o vetor alunos que apresentamos na Figura 29 poderia 
ser definido como:
var alunos: vetor [0..6] de caracter
Isso seria equivalente a ter 7 variáveis de mesmo nome, só 
distinguíveis pelos seus índices (alunos[0], alunos[1], alunos[2], 
alunos[3], alunos[4], alunos[5] e alunos[6]). Outros exemplos de 
declarações de vetores são:
// um vetor de 21 posições de números inteiros
idades: vetor [0..20] de inteiro 
//dois vetores de 10 posições de números reais
receitas, despesas: vetor [0..9] de real 
Para se atribuir um valor a um elemento do vetor devemos utilizar 
o seguinte padrão:
nomeVetor[índice] <- valor
onde o índice deve ser uma posição válida, existente dentro do 
vetor. Por exemplo:
alunos[1] <- “João da Silva”
idades[0] <- 35
idades[3] <- idades[0] //as posições ficam com o mesmo valor
i <- 5
idades[i] <- 45
Todos esses exemplos fizeram uso de posições válidas. Se eu 
tentasse acessar uma posição que não existe em um vetor, isso 
acarretaria um erro sintático e seria indicado na compilação do 
86
Introdução a Programação
algoritmo. Ex: alunos[10] <- “Maria Aparecida”. O vetor aluno, 
anteriormente definido, só tem sete posições, acessar a posição 10 
causaria um erro.
Para percorrer todas as posições de um vetor, deve-se usar 
alguma estrutura de repetição. Geralmente, utiliza-se a estrutura 
para..faça, porque sabemos o valor inicial e final dos índices do vetor. 
Por exemplo, para percorrer o vetor alunos, imprimindo o valor de 
cada posição, faríamos o seguinte:
para indice de 0 até 6 faça
 escreva (alunos[indice])
fimpara
escreva(alunos[0]) 
escreva(alunos[1]) 
... 
escreva(alunos[6])
Com isso, a cada vez que o laço fosse executado, uma posição 
diferente do vetor seria impressa, porque o valor do índice estaria 
mudando. Vamos agora juntar tudo? Que tal criar um algoritmo 
completo que faça uso de vetor? Isso é importante para você tentar 
entender como manipular um vetor.
Exemplo Completo: Faça um algoritmo para ler valores para 
preencher um vetor de 6 posições de números inteiros, imprimir os 
valores lidos e, depois, imprimir quantos números entre os lidos são 
números positivos.
Algoritmo “vetores”
var
 numeros: vetor [0..5] de inteiro // declaro o vetor 
 // declaro um índice para caminhar no vetor 
 // e um contador para os números positivos
 indice, numerosPos: inteiro 
inicio
 numerosPos <- 0 // para poder contar os números positivos
 // um laço para ler os valores que vão preencher o vetor
 para indice de 0 ate 5 faca
 escreva(“Digite o número da posição “, indice)
 leia (numeros[indice])
 // testa se número é positivose (numeros[indice] > 0) entao
 //se for positivo, incrementa o contador numerosPos
 numerosPos <- numerosPos + 1
87
Introdução a Programação
 fimse
 fimpara
// outro laço para imprimir os números armazenados no vetor
 para indice de 0 ate 5 faca
 escreval (numeros[indice])
 fimpara
 // imprime o total de números positivos contados
 escreva (“Total de números positivos: “, numerosPos)
fimalgoritmo
Para Refletir...
E se agora, eu quisesse que o algoritmo lesse 100 números e não apenas 
6? O que mudaria no algoritmo acima?
Algoritmo “vetores”
var
 numeros: vetor [0..99] de inteiro // declaro o vetor 
 // declaro um índice para caminhar no vetor 
 // e um contador para os números positivos
 indice, numerosPos: inteiro 
inicio
 numerosPos <- 0 // para poder contar os números positivos
 // um laço para ler os valores que vão preencher o vetor
 para indice de 0 ate 99 faca
 escreva(“Digite o número da posição “, indice)
 leia (numeros[indice])
 // testa se número é positivo
 se (numeros[indice] > 0) entao
 //se for positivo, incrementa o contador numerosPos
 numerosPos <- numerosPos + 1 
 fimse
 fimpara
// outro laço para imprimir os números armazenados no vetor
 para indice de 0 ate 99 faca
 escreval (numeros[indice])
88
Introdução a Programação
 fimpara
 // imprime o total de números positivos contados
 escreva (“Total de números positivos: “, numerosPos)
fimalgoritmo
Já imaginou se tivesse de declarar um nome de variável para 
cada um dos valores a serem lidos? Pois é... resolver o problema 
anterior sem vetores implicaria no árduo trabalho de ter que declarar 
e manipular 100 variáveis! Mas usando vetores, você só vai mudar a 
quantidade de posições do vetor e os limites de valores dentro dos 
laços e pronto! Todo o restante do algoritmo continuaria igual.
Estruturas Homogêneas Bidimensionais 
(Matrizes)
Estruturas de dados homogêneas bidimensionais, também 
conhecidas como matrizes, são referenciadas por dois índices: um 
para indicar a linha da matriz e outro para indicar a coluna da matriz 
onde se encontra o dado.
Estrutura de Dados Multidimensional = Conjunto de Dados
onde cada elemento é identificado por MAIS de um índice.
Por exemplo, como definir um conjunto para armazenar as médias 
de 7 alunos obtidas em cada uma das 5 disciplinas que eles cursam? 
Poderíamos fazer cada linha de uma matriz representar um aluno e 
cada coluna representar uma disciplina (vide Figura 30). Dessa forma, 
a média do quinto aluno, na primeira disciplina seria representada 
por: notas[4,0] e seria igual ao valor 10.0, como pode ser visto na 
Figura 30. Isso porque a linha 0 representa o primeiro aluno, a linha 1 
o segundo aluno e assim por diante. A coluna 0 representa a primeira 
disciplina, a coluna 1 a segunda disciplina e assim por diante.
89
Introdução a Programação
Figura 30 - Exemplo de Estrutura Bidimensional
A matriz notas ocupa, ao todo, 35 posições de memória (notas de 
7 alunos X 5 disciplinas), o que seria equivalente a criar 35 variáveis 
isoladas no algoritmo, para poder resolver o mesmo problema. Mais 
complicado, não é?
Ressalta-se que a matriz notas não armazena o nome dos alunos 
ou o nome das disciplinas. Ela armazena somente Notas! (lembre: 
estruturas de dados homogêneas! Toda posição deve ter o mesmo 
tipo de dados, que, no caso, são valores reais que são as médias). E 
como declarar isso? A matriz é declarada na área de declaração de 
variáveis e a sintaxe para declaração é:
nomeMatriz : vetor [linhaI..linhaF, colunaI..colunaF] de Tipo
onde:
» nomeMatriz é o nome que você quer dar a variável matriz na 
memória. 
» vetor é palavra reservada para indicar a criação da estrutura 
homogênea
» [linhaI..linhaF, colunaI..colunaF] a matriz precisa da definição 
de quantas linhas e quantas colunas a estrutura vai ter. Dessa 
forma, linhaI é o valor inicial do índice de linhas e linhaF é o 
valor final do índice de linhas. Já colunaI é o valor inicial do 
índice de colunas e colunaF o valor final do índice de colunas.
90
Introdução a Programação
» Tipo = é o tipo de elemento que você quer gravar dentro da 
matriz. Lembrando que todas as posições terão esse mesmo 
tipo (inteiro, real, caracter ou lógico).
Sendo assim, a matriz apresentada na Figura 30 poderia ser 
definida como:
var notas: vetor [0..6, 0..4] de real
Isso seria equivalente a ter as 35 variáveis de mesmo nome, 
anteriormente mencionadas, que seriam distinguidas uma das outras 
pelos seus índices (notas[0,0], notas[0,1], notas[0,2], notas[0,3], 
notas[0,4], notas[1,0] e assim por diante). Outros exemplos de 
declarações de matrizes são:
// matriz de 3 linhas por 4 colunas de números inteiros
valores: vetor [0..2, 0..3] de inteiro
// matriz de 2 linhas por 4 colunas de nomes alfanuméricos
nomes: vetor [0..1, 0..3] de caracter
Cada posição dentro da matriz é identificada pelo valor do índice 
da linha e pelo valor do índice da coluna. Por exemplo, se fosse 
criada uma matriz M de 3 linhas por 3 colunas, cada posição seria 
acessada como ilustrado na Figura 31. A posição da linha 0, coluna 0 
é especificada por M
00
, a posição da linha 2, coluna 1, é especificada 
por M
21
 e assim por diante.
Figura 31 - Exemplo de valores das posições de uma matriz
Para se atribuir um valor a um elemento de uma matriz é necessário 
usar esses dois índices (afinal, é estrutura bidimensional), um para a 
linha e outro para a coluna:
nomeMatriz[no linha, no coluna] <- valor
O no da linha e o no da coluna devem ser posições válidas, existente 
dentro da matriz. Por exemplo:
notas[0,1] <- 8.5
valores[1,1] <- 5
nomes[0,3] <- “Maria”
91
Introdução a Programação
Para percorrer todas as posições de uma matriz, devem-se usar 
duas estruturas para..faça aninhadas, ou seja, uma dentro da outra. 
Uma para cada dimensão. Ou seja, uma para caminhar nas linhas e 
outra para caminhar nas colunas. Por exemplo, para percorrer a matriz 
notas, imprimindo o valor de cada posição, faríamos o seguinte:
// o primeiro para caminhar nas linhas
para linha de 0 até 6 faca
 // o segundo para caminhar nas colunas
 // de uma mesma linha
 para coluna de 0 ate 4 faca
 escreva (notas[linha, coluna])
fimpara
escreva(notas[0,0]) 
escreva(notas[0,1]) 
escreva(notas[0,2]) 
escreva(notas[0,3]) 
escreva(notas[0,4]) 
escreva(notas[1,0]) 
escreva(notas[1,1]) 
escreva(notas[1,2]) 
escreva(notas[1,3]) 
escreva(notas[1,4]) 
... 
escreva(notas[6,4])
Veja que quando entra no primeiro laço, o contador linha recebe 
o valor 0 e para esse mesmo valor, o contador coluna varia de 0 até 
4. Depois volta-se para o contador linha que passar a ter o valor 1 e, 
novamente, o contador coluna varia de 0 até 4. 
Vamos agora juntar tudo? Para isso, faça um algoritmo para ler 
as médias de 7 alunos em cada uma das cinco 5 disciplinas que eles 
cursam (a matriz notas da Figura 30). E depois imprimir essas notas.
Algoritmo “matrizes”
 var
 notas: vetor [0..6, 0..4] de real // declaro a matriz
 // declaro um índice para linha e outro para coluna
 linha, coluna: inteiro 
 inicio
 // primeiro lê os valores das médias
 // faz um laço para andar nas linhas
 para linha de 0 ate 6 faca
 // depois faz um laço para andar nas colunas
 para coluna de 0 ate 4 faca
 escreva(“Digite a média do aluno ”, linha, “ da 
disciplina “, coluna)
 leia (notas[linha,coluna])
 fimpara
 fimpara
92
Introdução a Programação
 // um laço para imprimir os números armazenados na matriz
 para linha de 0 ate 6 faca
 para coluna de 0 ate 4 faca
 escreva(“Média“,linha, coluna, “é igual a“, 
notas[linha, coluna])
 fimpara
 fimpara
fimalgoritmo
Da mesma forma que no vetor, seria fácil aumentar a quantidade 
de alunos ou de disciplinas, apenas trocando o tamanho da matriz e 
os limites dos laços para..faça.
Agora, só para ilustrar, como ficaria se a gente acrescentasse uma 
nova dimensão à matriz anteriormente definida? Por exemplo, faça 
um algoritmo para ler as médias de 7 alunos, em 5 disciplinas, em 10 
cursos diferentes (estrutura tridimensional). 
Algoritmo “tridimensional”
var
 notas: vetor [0..6, 0..4, 0..9] de real
 // declaro um índice para cada dimensão
 aluno, disciplina, curso: inteiro 
inicio
 // primeiro lê os valores das médias
 // faz um laço para andar nos alunos
 para aluno de 0 ate 6 faca
 // depois faz um laço para andar nas disciplinas
 para disciplina de 0 ate 4 faca
 // e, por fim, um laço para andar nos cursos
 para curso de 0 ate 9 faca
 escreva(“Digite a média: ”)
 leia (notas[aluno, disciplina, curso])
 fimpara
 fimpara
 fimpara
fimalgoritmo
Cada dimensão da matriz é manipulada por um laço exclusivo. 
Por isso, ao se adicionar uma nova dimensão, deve-se criar uma 
93
Introdução a Programação
nova variável e um novo laço para manipulá-la. Ou seja, é criado um 
laço para..faca para cada dimensão a ser percorrida e a referência 
ao elemento da estrutura é feita pela quantidade de índices 
correspondente à quantidade de dimensões.
Aprenda Praticando
Problema 1: Sobre Vetores - Faça um algoritmo para ler a idade 
de 20 pessoas e, depois, imprimir apenas as idades que estiverem 
acima da média das idades lidas.
A partir da leitura do enunciado temos:
► Entrada: as idades de 20 pessoas.
► Processamento: calcular a média de idades.
► Saída: as idades que estiverem acima da média.
Logo, neste algoritmo há duas opções, ou declarar 20 variáveis 
idades ou usar vetores. Como apresentado neste capítulo, o uso 
de vetores seria mais vantajoso e mais simples de manipular. Mas 
não poderia ser usada uma simples variável um laço? Não, porque 
precisamos saber as idades lidas, visto que após calcular a média, 
temos de imprimir, entre as idades lidas, apenas aquelas que 
estiverem acima da média.
Algoritmo “ExemploVetor”
var idades: vetor[0..19] de inteiro // 20 elementos: de 0 a 19
//índice é a variável contadora para o laço para..faça
 soma, indice: inteiro
 media: real // servirá para armazenar a média calculada
 inicio
// para acumular a soma das idades, inicia soma com zero
 soma <-0
 para indice de 0 até 19 faça
 escreval(“informe a idade ”, indice) 
 leia(idades[indice])
 soma <- soma + idades[indice]
 fimpara
94
Introdução a Programação
 // ao sair do laço que soma as idades, calcula a média
 media <- soma / 20
 // percorre o vetor para imprimir as idades que estão
 // acima da média das idades calculadas
 para indice de 0 até 19 faça
 se (idades[índice] > media) entao 
 escreva(idades[indice])
 fimse
 fimpara
fimalgoritmo
Problema 2: Sobre Matrizes - Faça um algoritmo para ler uma 
matriz 4 x 4 contando números inteiros. Depois imprima a soma de 
cada linha da matriz e, ao final, a soma de todos os elementos da 
matriz. A partir da leitura do enunciado temos:
► Entrada: matriz 4 x 4 de números inteiros.
► Processamento: calcular a de cada linha da matriz e a soma 
de todos os elementos da matriz.
► Saída: o valor da soma de cada linha e o valor total da soma de 
todos os elementos da matriz.
Logo, vamos começar o algoritmo criando a matriz. Vamos 
precisar de duas variáveis, uma para acumular a soma das linhas e 
outra para acumular a soma total dos valores. Precisaremos também 
no algoritmo de dois laços, um para preencher a matriz e outro para 
calcular a soma das linhas e a soma total. 
==========================================================
Algoritmo “ExemploVetor”
var numeros: vetor[0..3, 0..3] de inteiro 
//as variáveis para acumular as somas
 somaLinha, somaTotal: inteiro
// índices para o laço para...faça para percorrer a matriz
 linha, coluna: inteiro
inicio
// para ler matrizes, você vai precisar de dois laços
// aninhados, um para andar nas linhas e outro para andar
// nas colunas.
95
Introdução a Programação
 para linha de 0 até 3 faça
 para coluna de 0 até 3 faça
 escreval(“Digite um número “) 
 leia(numeros[linha, coluna])
 fimpara
 fimpara
// zera, para acumular a soma total dos elementos da matriz
 somaTotal <-0
 // depois da matriz preenchida, vamos fazer um laço para
 // realizar as devidas somas
 para linha de 0 até 3 faça
 // a cada nova linha a variável que acumula a soma das
 // linhas deve ser zerada
 somaLinha <-0
 para coluna de 0 até 3 faça
 somaLinha <- somaLinha + numeros[linha,coluna]
 fimpara
 // quando sai do laço que anda nas colunas, terminou
 // a soma de uma linha toda. Por isso, imprimimos o
 // resultado da soma da linha e acumulamos este valor
 // na variável somaTotal
 escreval(“A soma da linha “, linha, “ é igual a “, 
somaLinha)
 somaTotal <- somaTotal + somaLinha
 fimpara
 // quando sair de todos os laços, imprime o resultado da
 // somaTotal
 escreva(“A soma de todos os valores é:“, somaTotal)
fimalgoritmo
Atividade de Estudo
Construa algoritmos em linguagem algorítmica para resolver os 
problemas abaixo. Lembre das boas práticas de programação! 
96
Introdução a Programação
Estrutura Unidimensional
1) Leia um vetor chamado NUMEROS de 10 números inteiros e 
exiba qual o maior e o menor número desse vetor.
2) Estenda a questão 1 para, a partir do vetor NUMEROS 
completamente preenchido, escrever os vetores VP (que será 
um vetor de números pares) e VI (que será um vetor de números 
ímpares). 
3) Estenda a questão 1 para, a partir do vetor NUMEROS, gerar 
o vetor OPOSTO, que corresponde ao vetor NUMEROS ao 
contrário. Por exemplo, se o vetor NUMEROS tiver os números 
2 4 e 6, o vetor OPOSTOS terá os números 6 4 e 2.
4) Leia um vetor LETRAS de 20 letras e, depois, escreva a 
quantidade de vogais que existem dentro do vetor e o percentual 
de consoantes.
5) Leia dois vetores A e B de tamanho 10. Depois gere, a partir 
deles, um vetor C, o qual corresponde à intercalação dos 
elementos dos vetores A e B. Ou seja, você deve colocar em C 
um elemento de A, depois um elemento de B, outro elemento 
de A, outro elemento de B e assim sucessivamente. Todos os 
elementos de A e B devem estar em C.
6) Estenda a questão anterior para, a partir dos vetores A e B, 
gerar o vetor INTERSECAO que corresponde aos elementos 
que estão no vetor A e também estão no vetor B. Ou seja, o 
vetor INTERSECAO será um vetor com os elementos em 
comum entre os vetores A e B.
Estrutura Bidimensional
7) Leia duas matrizes A e B (5 X 5) de números inteiros e, a partir 
delas, gere a matriz SOMA (correspondente a soma das duas 
matrizes: A + B) e a matriz SUBTRACAO (correspondente à 
subtração entre as duas matrizes: A - B).
8) Leia uma matriz N (2X3) de números inteiros e positivos e gere 
uma matriz C, do mesmo tamanho, de caracteres, onde cada 
posição C[linha, coluna] terá o valor “P” ou “I” dependendo de 
se o número da posição correspondente em N[linha, coluna] for 
PAR ou IMPAR, respectivamente. 
9) Leia uma matriz 4 x 4 de números inteiros e escreva os 
97
Introdução a Programação
elementos da diagonal principal desta matriz. Para facilitar, 
observe o desenho abaixo. Em destaque está a diagonal 
principal. Como podem ser identificadas as posições desses 
elementos?
10) Leia as 4 notas de cada um dos 25 alunosde uma disciplina e 
escreva as notas que estão abaixo da média geral da turma e a 
porcentagem de notas acima da média da turma.
11) Leia uma matriz contendo o preço de 5 fornecedores para 10 
produtos e calcule e imprima o preço médio de cada fornecedor 
para os 10 produtos.
12) Leia um vetor com os nomes dos 50 alunos de uma turma 
e uma matriz com as três notas desses alunos na mesma 
disciplina. Depois, calcule e escreva o nome dos alunos com 
média superior ou igual à média geral da turma.
Super Desafio
Leia um vetor com os nomes dos 500 candidatos de um concurso, 
outro vetor com o gabarito das respostas (“a”, “b”, “c”, “d” ou “e”) das 
60 questões da prova e uma matriz com as respostas dos candidatos 
para a prova. Ao final, escrever os nomes dos candidatos que 
obtiveram a maior quantidade de acertos.
Vamos Revisar?
Entre os conceitos avançados estudados neste capítulo estava o de 
estruturas homogêneas, que são conjuntos de dados de um único tipo 
agrupados sob um mesmo nome. Essas estruturas são classificadas 
conforme o número de dimensões do conjunto ou, em outras palavras, 
conforme a quantidade de índices necessários para localizar um 
98
Introdução a Programação
elemento dentro do conjunto (geralmente, um índice para cada 
dimensão). Dessa forma, as estruturas podem ser: unidimensionais, 
bidimensionais, tridimensionais ou multidimensionais. O foco do nosso 
estudo nesta disciplina está apenas nas estruturas unidimensionais 
(vetores) e bidimensionais (matrizes).
Vetores são estruturas de dados homogêneas unidimensionais 
que permitem agrupar diversas informações dentro de uma variável 
única. Estas correspondem a um grupo de posições contínuas na 
memória que possuem o mesmo nome e o mesmo tipo de dado e 
são acessadas por um ÚNICO índice. Seu tamanho é definido por 
constantes inteiras e positivas e a definição do seu nome segue as 
mesmas regras aplicadas para identificadores 
Matrizes são estruturas de dados homogêneas bidimensionais, ou 
seja, elas necessitam de dois índices para individualizar um elemento 
do conjunto: um índice para a linha e outro índice para a coluna. Por 
exemplo, declarar uma matriz M, de 4 linhas por 3 colunas (4 x 3), 
constituída de elementos numéricos inteiros fará com que passe a 
existir uma estrutura de dados agrupada na memória do computador, 
capaz de armazenar 4x3=12 elementos inteiros, endereçáveis por um 
par de índices, com o primeiro indicando a linha e o outro, a coluna.