7_vetor

Prévia do material em texto

Vetores e Constantes 
Imagine uma situação na qual fosse necessário armazenar 100 valores para 
processamento. Por exemplo, pode ser necessário armazenar as notas de 100 
provas de uma turma de alunos. Uma solução é declarar 100 variáveis, uma para 
cada nota de prova a ser armazenada. Essa solução é bem trabalhosa, 
especialmente se posteriormente for necessário armazenar um número diferente 
de notas. 
Existe uma solução mais simples para armazenar um grande número de valores. 
Essa solução é conhecida como vetor. Os vetores são estruturas capazes de 
armazenar diversos valores do mesmo tipo. Na linguagem algorítmica, os vetores 
são declarados da seguinte forma: 
<identificador>[<tamanho>]: <tipo>; 
No qual: 
• identificador: identificador (ou nome) do vetor; 
• tamanho: tamanho (número de elementos) do vetor; 
• tipo: tipo de cada elemento do vetor. 
Por exemplo: 
v[10]: inteiro; 
declara uma variável vetor de nome v. Essa variável terá "dentro" dela outras 10 
variáveis inteiras, a cada uma dessas variáveis damos o nome de elemento do 
vetor. Essa variável possui uma estrutura interna que pode ser representada da 
seguinte forma: 
 
A variável v é composta por outras 10 variáveis inteiras representadas através dos 
10 quadrados da figura acima. Cada quadrado representa um elemento do vetor. 
Os 10 elementos são numerados de 0 a 9, e esses números são chamados de 
índices do vetor. É importante saber que na liguagem algorítmica todo vetor inicia 
com o índice 0 e termina com o índice que representa o seu tamanho menos 1. 
Dessa forma, o tamanho mínimo aceitável para um vetor é 1, entretanto, um vetor 
de tamanho 1 é similar a uma variável do seu tipo base, uma vez que esse vetor 
somente seria capaz de armazenar um único valor. 
Para ler ou escrever variáveis do tipo vetor através dos comandos leia e escreva 
NÃO podemos simplesmente fazer: 
leia(v); 
escreva(v); 
Para ler ou escrever em um vetor é necessário ler ou escrever em cada um de 
seus elementos individualmente. Para acessar um elemento de um vetor basta 
utilizar o identificador do vetor e a sua posição (índice), na seguinte sintaxe: 
<identificador>[<posição>]; 
Como por exemplo: 
v[5]; 
No nosso exemplo, v[5] é o sexto elemento do vetor v, lembre-se que o primeiro 
elemento está no índice 0. Esse elemento é uma variável do tipo inteiro, porque 
declaramos, em nosso exemplo, o vetor v de tipo inteiro. Assim como é possível 
atribuir valores, ler e escrever no conteúdo de variável inteira, também é possível 
atribuir, ler e escrever no conteúdo de v[5]. Por exemplo, se executarmos a 
seguinte atribuição: 
v[5] 10; 
então o valor 10 é atribuído ao elemento de índice 5 do vetor v. Dessa forma, o 
vetor v é modificado e pode ser representado da seguinte forma: 
 
Para ler valores do teclado e armazenar esses valores em um vetor é necessário 
fazê-lo elemento a elemento do vetor. Por exemplo, para ler 10 valores do teclado 
e armazená-los no vetor v, pode-se fazer: 
para (i 0; i<10; i++) 
{ 
 leia(v[i]); 
} 
O trecho de algoritmo acima lê 10 valores do teclado e os armazena nas 10 
posições do vetor v. Ainda, é possível fazer o mesmo para escrever os 10 
elementos do vetor v na tela do computador. 
para (i 0; i<10; i++) 
{ 
 escreva(v[i]); 
} 
Exercício 1 
Faça um algoritmo que leia 100 notas de prova. Calcule a média da turma e 
escreva quais notas estão acima da média da turma. 
Para solucionar este exercício é necessário: 
• ler 100 valores (notas) do teclado; 
• calcular a média da turma; 
• escrever na tela do computador as notas que estão acima da média da 
turma. 
Para iniciar precisamos declarar um vetor para armazenar as notas, vamos 
chamar esse vetor de notas. 
notas[100]: real; 
Para ler 100 notas e armazená-las no vetor notas deve-se fazer: 
para (i 0; i<100; i++) 
{ 
 leia(notas[i]); 
} 
Para calcular a média das 100 notas é necessário somar os 100 valores e dividir a 
valor da soma por 100. Para isso: 
total 0; 
para (i 0; i<100; i++) 
{ 
 total total + notas[i]; 
} 
média total / 100; 
Por fim é necessário verificar quais notas armazenadas no vetor notas são 
maiores que a média da turma, armazenada na variável média. Para isso: 
para (i 0; i<100; i++) 
{ 
 se notas[i] > média então 
 { 
 escreva(notas[i]); 
 } 
} 
Juntando tudo, nós temos o seguinte algoritmo: 
01 | Algoritmo notas_acima_media; 
02 | { 
03 | notas[100]: real; 
04 | média, total: real; 
05 | i: inteiro; 
06 | 
07 | 
08 | /* Leitura das notas e armazenamento no vetor notas */ 
09 | para (i 0; i<100; i++) 
10 | { 
11 | leia(notas[i]); 
12 | } 
13 | 
14 | /* Cálculo da média das notas */ 
15 | total 0; 
16 | para (i 0; i<100; i++) 
17 | { 
18 | total total + notas[i]; 
19 | } 
20 | média total / 100; 
21 | 
22 | /* Escrita das notas acima da média da turma */ 
23 | para (i 0; i<100; i++) 
24 | { 
25 | se notas[i] > média então 
26 | { 
27 | escreva(notas[i]); 
28 | } 
29 | } 
30 | } 
Imagine que o programador queira modificar o algoritmo para trabalhar com 50 
notas de prova. O que seria necessário modificar no algoritmo acima para ele 
trabalhar com um número diferente de notas? 
Seria necessário trocar o valor 100 pelo valor 50 nas linhas 03, 09, 16, 20 e 23. 
Mas, existe um jeito mais simples de fazer isso, utilizando constantes. 
Constantes são componentes de um algoritmo que armazenam um valor, o qual 
não pode ser alterado durante a execução do algoritmo. 
Para declarar uma constante é necessário utilizar a palavra reservada 
constantes. Constantes indica o início de um bloco de declaração de constantes. 
Geralmente as constantes são declaradas antes das variáveis. A declaração de 
uma constante deve seguir a seguinte sintaxe: 
<identificador> = <valor>; 
Como por exemplo: 
PI = 3.14; 
É convencionado, mas não é obrigatório, que os identificadores das constantes 
sejam escritos em letras maiúsculas. Dessa forma, é simples distinguir as 
constantes das variáveis. 
Voltando ao nosso algoritmo das médias, é possível declarar uma constante, com 
um identificador como, por exemplo, MAX, que terá o número de notas a serem 
processadas. Dessa forma, o algoritmo ficaria da seguinte forma: 
01 | Algoritmo notas_acima_media; 
02 | constantes 
03 | MAX = 100; 
04 | 
05 | { 
06 | notas[MAX]: real; 
07 | média, total: real; 
08 | i: inteiro; 
09 | 
10 | 
11 | /* Leitura das notas e armazenamento no vetor notas */ 
12 | para (i 0; i<MAX; i++) 
13 | { 
14 | leia(notas[i]); 
15 | } 
16 | 
17 | /* Cálculo da média das notas */ 
18 | total 0; 
19 | para (i 0; i<MAX; i++) 
20 | { 
21 | total total + notas[i]; 
22 | } 
23 | média total / MAX; 
24 | 
25 | /* Escrita das notas acima da média da turma */ 
26 | para (i 0; i<MAX; i++) 
27 | { 
28 | se notas[i] > média então 
29 | { 
30 | escreva(notas[i]); 
31 | } 
32 | } 
33 | } 
Repare que, no algoritmo anterior, todas as referências ao valor 100 foram 
substituídas por referências à MAX. Dessa forma, basta modificar a declaração da 
constante para modificar o número de notas com que o algoritmo vai trabalhar. 
Vetores são estruturas estáticas 
Vamos modificar o exercício anterior para que o usuário entre com um número 
não previamente definido de notas. Por exemplo, o usuário pode fornecer as notas 
até que um valor especial, digamos -1, seja fornecido. O valor especial diz que o 
usuário deseja parar de fornecer as notas, e quer que o programa realize os 
cálculos. 
Nosso primeiro problema é definir qual deve ser o tamanho do vetor. Os vetores 
são chamados de estruturas estáticas, pois têm o seu tamanho definido durante a 
codificaçãodo programa. Durante a execução do programa, o tamanho do vetor 
não pode ser alterado, ou seja, não pode ser aumentado nem diminuído. Uma vez 
que nós não sabemos quantas notas serão fornecidas pelo usuário, é difícil 
estipular previamente um tamanho para o vetor. Tudo isso pode acarretar dois 
problemas para o programa: 
1. Durante a codificação, o programador especificou um tamanho para o vetor 
que é muito maior do que o necessário. Nesse caso, tem-se memória 
alocada para o vetor que está sendo desperdiçada. 
2. Também, o programador pode especificar um tamanaho para o vetor que é 
menor do que o necessário. Nesse caso, o vetor não será suficiente para 
armazenar todos os valores que o usuário deseja fornecer. 
O segundo caso é sempre pior do que o primeiro. Caso o programador não queira 
ter nenhum dos dois problemas, então ele terá que recorrer a uma estrutura que 
não seja um vetor. Por exemplo, listas encadeadas dinâmicas podem crescer 
conforme a necessidade do programa. Essas estruturas serão estudadas mais à 
frente e são muito mais complexas do que os vetores. 
Portanto, temos que utilizar um pouco de bom senso para escolher o tamanho do 
vetor. Vamos dizer que dificilmente uma classe tenha mais do que 250 alunos. 
Podemos utilizar o valor 250 como máximo do nosso vetor. 
Para começar precisamos ler um determinado número de notas até que seja 
fornecido o valor -1. É necessário utilizar um comando de repetição. Vamos 
escolher o comando faça-enquanto. 
O trecho de código para ler valores e armazená-los em um vetor notas até que 
um valor -1 seja fornecido é: 
num_notas 0; 
faça { 
 leia(notas[num_notas]); 
 num_notas num_notas + 1; 
} enquanto notas[num_notas] != -1; 
Repare que foi necessário utilizar uma variável contadora num_notas. Essa 
variável precisa ser incrementada pelo programador, uma vez que o comando 
faça-enquanto não faz essa tarefa. O laço faca-enquanto termina quando uma 
nota com valor -1 é fornecida. Note que ao sair do laço faça-enquanto a variável 
num_notas terá o número de notas fornecidas pelo usuário mais uma nota. Na 
realidade a última nota fornecida é a nota especial -1. Nós não queremos que 
essa nota entre nos cálculos da média. Por isso, é necessário decrementar a 
variável num_notas. 
Ainda sobre o laço, nós podemos fazer mais um melhoramento. O que ocorrerá se 
o usuário fornecer mais que 250 notas? Caso isso ocorra, então ao ler a nota 251, 
e tentar armazenar essa nota na posição 250 do vetor notas, ocorrerá um erro de 
execução, pois não existe a posição 250 no vetor notas. Para evitar que esse erro 
ocorra, o laço faça-enquanto pode ser interrompido sempre que num_notas 
atinja o valor 250. Portanto, o trecho de código referente a leitura dos dados ficaria 
assim: 
num_notas 0; 
faça { 
 leia(notas[num_notas]); 
 num_notas num_notas + 1; 
} enquanto (notas[num_notas] != -1) e (num_notas < 250); 
O laço acima será executado até que uma nota -1 seja fornecida, ou que o valor 
de num_notas atinja o valor 250, o qual é uma posição além do máximo permitido 
pelo vetor notas declarado. Note que a variável num_notas só será 
decrementada caso o usuário digite o valor -1. Se o usuário fornecer as 250 notas, 
então a variável num_notas não precisa ser decrementada, pois todas as notas 
fornecidas serão válidas. Para decrementar num_notas precisamos agora fazer 
um teste e verificar se foi digitado o valor -1. O trecho de código referente ao teste 
ficaria assim: 
se notas[num_notas] == -1 então 
{ 
 num_notas num_notas - 1; 
} 
Suponha que o usuário logo na primeira vez digite o valor -1. Se isto acontecer 
não teremos nenhuma nota para fazer a média e todo o resto do processamento. 
Precisamos portanto verificar se o usuário digitou alguma nota válida. Isto pode 
ser feito verificando se a variável num_notas é diferente de 0. Se a variável 
num_notas for diferente de 0 significa que existem notas e portanto podemos 
fazer a média e mostrar as notas acima da média. Caso contrário, ou seja, se 
num_notas for igual a 0, então não há notas e enviaremos uma mensagem ao 
usuário dizendo que nenhuma nota foi fornecida. 
O resto do programa ficará muito parecido. Somente é necessário lembrar que o 
número de notas fornecido pelo usuário está na variável num_notas. 
01 | algoritmo notas_acima_media; 
02 | constantes 
03 | MAX = 250; 
04 | 
05 | { 
06 | notas[MAX]: real; 
07 | media, total: real; 
08 | i, num_notas: inteiro; 
09 | 
10 | 
11 | /* Leitura das notas e armazenamento no vetor notas */ 
12 | num_notas 0; 
13 | faça { 
14 | leia(notas[num_notas]); 
15 | num_notas num_notas + 1; 
16 | } enquanto (notas[num_notas] != -1) e (num_notas < MAX); 
17 | 
18 | /* num_notas é decrementada, para descartar o valor -1 */ 
19 | se notas[num_notas] == -1 então 
20 | { 
21 | num_notas num_notas - 1; 
22 | } 
23 | 
24 | /* Cálculo da média das notas, se alguma nota foi fornecida */ 
25 | se num_notas > 0 então 
26 | { 
27 | total 0; 
28 | para (i 0; i < num_notas; i++) 
29 | { 
30 | total total + notas[i]; 
31 | } 
32 | media total / num_notas; 
33 | 
34 | /* Escrita das notas acima da média da turma */ 
35 | para (i 0; i < num_notas; i++) 
36 | { 
37 | se notas[i] > media então 
38 | { 
39 | escreva(notas[i]); 
40 | } 
41 | } 
42 | } senão 
43 | { 
44 | escreva("Nenhuma nota foi fornecida"); 
45 | } 
46 | } 
Exercícios 
1. Faça um algoritmo e um programa capaz de ler em um vetor A um número 
não previamente determinado de valores inteiros positivos. Esses valores 
devem ser fornecidos pelo usuário até que ele entre um valor especial. 
Depois de ler esses valores, copie-os para um outro vetor B. Essa cópia 
deve ser feita de forma que o valor armazenado no primeiro elemento do 
vetor A seja copiado para o último elemento do vetor B. O segundo 
elemento do vetor A seja copiado para o penúltimo elemento do vetor B. E 
assim por diante. 
2. Faça um algoritmo e um programa capaz de ler 100 valores e armazená-los 
em um vetor A. Depois ler mais outros 100 valores e armazená-los em um 
vetor B. Faça com que um vetor C armazene a soma dos vetores A e B. O 
primeiro elemento do vetor C deve armazenar a soma do primeiro elemento 
do vetor A com o primeiro elemento do vetor B. O segundo elemento do 
vetor C deve armazenar a soma do segundo elemento do vetor A com o 
segundo elemento do vetor B. E assim por diante. 
3. Faça um algoritmo e um programa que leia 500 números reais do teclado e 
armazene em um vetor. Encontre e imprima o menor e o maior valor do 
vetor.