Vetores em Algoritmos

Prévia do material em texto

1 
LINGUAGEM E TÉCNICA DE PROGRAMAÇÃO I 
 
Profa. Gisele Busichia Baioco 
gisele@ft.unicamp.br 
 
 
Algoritmos Estruturados e 
Linguagem de Programação Estruturada 
 
Vetores em Algoritmos 
1 Estruturas de Dados 
Os tipos de dados primitivos, ou seja, aqueles tipos de dados disponíveis nas 
linguagens de programação (numérico, caractere e lógico), podem não ser suficientes para 
representar toda e qualquer informação. 
Assim, novos tipos de dados podem ser construídos a partir da composição de tipos 
primitivos. O formato desses novos tipos de dados é denominado Estrutura de Dados, ou 
seja, as Estruturas de Dados definem como os tipos primitivos estão organizados para a 
construção (criação) de novos tipos de dados. 
A maioria das linguagens de programação já tem suporte para a criação de algumas 
estruturas de dados, classificadas como: 
• Variáveis Compostas Homogêneas: agrupam variáveis com o mesmo tipo de 
dado. 
• Variáveis Compostas Heterogêneas: agrupam variáveis de tipos de dados 
distintos. 
2 Variáveis Compostas Homogêneas em Algoritmos 
As Variáveis Compostas Homogêneas são estruturas de dados presentes na maioria 
das linguagens de programação que possibilitam agrupar variáveis de um mesmo tipo de dado 
primitivo. Essas estruturas de dados são divididas em dois grupos: 
• Variáveis Compostas Homogêneas Unidimensionais – Vetores. 
• Variáveis Compostas Homogêneas Multidimensionais, cuja dimensão mais 
utilizada é a Bidimensional – Matrizes. 
3 Variáveis Compostas Homogêneas Unidimensionais – Vetores em 
Algoritmos 
As Variáveis Compostas Homogêneas Unidimensionais ou Vetores correspondem 
a posições de memória (variáveis) identificadas por um mesmo nome, onde uma posição 
individual é acessada por um índice e cujo conteúdo é do mesmo tipo de dado. Em outras 
palavras, um vetor pode ser definido como um conjunto finito e ordenado de elementos 
homogêneos. Por finito entende-se que existe um número específico de elementos no vetor; 
por ordenado entende-se que os elementos do vetor são organizados de tal forma que exista 
um elemento 0, um elemento 1, elemento 2, um elemento 3 e assim por diante, onde 0, 1, 2, 
3,... são os índices; por homogêneo entende-se que todos os elementos do vetor precisam ser 
do mesmo tipo de dados. 
 2 
Sintaxe de declaração em algoritmos: 
 
declare nome[tamanho]: tipo-de-dado; 
 
onde: 
nome: é o nome do vetor; 
tamanho: é a quantidade máxima de elementos (posições) do vetor; 
tipo-de-dado: é um tipo de dado válido em algoritmos. 
 
 A referência ao conteúdo do n-ésimo elemento de um vetor tem a sintaxe: 
 
nome[n] 
 
onde: 
nome: é o nome do vetor; 
n é o índice que corresponde a um número inteiro ou uma variável do tipo inteiro. 
 
Observação: Considera-se que o primeiro elemento tem o índice 0. Entretanto, isso pode 
variar de uma linguagem de programação para outra. Algumas linguagens podem considerar 
que o primeiro elemento tem o índice 1, outras permitem que seja definido o valor do índice 
do primeiro elemento. 
 
 Exemplo de vetor: 
 
/* Declaração de um vetor de nome nota que pode conter até 10 
 elementos */ 
declare nota[10]: numérico real; 
 
Esquematicamente tem-se: 
 
nota 5.5 6.0 9.0 2.5 4.5 9.5 7.0 8.5 7.5 3.0 
 0 1 2 3 4 5 6 7 8 9 
 
 
 
 
Para atribuir um valor a n-ésima posição de um vetor, usa-se a seguinte sintaxe: 
 
 nome[n] ← valor; 
 
onde: 
nome: é o nome do vetor; 
n é o índice que corresponde a um número inteiro ou uma variável do tipo inteiro; 
valor é uma variável ou um valor do mesmo tipo de dado do vetor. 
 
 Considerando o vetor do exemplo anterior, para atribuir o valor 9.5 para a posição 5, 
faz-se: 
 nota[5] ← 9.5; 
nota[5] 
 3 
4 Usando Vetores 
Um vetor é usado para manter uma grande quantidade de elementos de dados na 
memória e para referenciar todos os elementos de maneira uniforme. 
Supor a necessidade de ler 100 notas, calcular sua média aritmética e determinar o 
quanto cada nota se desvia dessa média. Nesse caso é necessário que as 100 notas lidas sejam 
armazenadas em variáveis para que o desvio seja calculado após o cálculo da média 
aritmética. Utilizar 100 variáveis para armazenar as 100 notas seria uma solução, mas o 
código do programa ficaria um tanto extenso, pois além de declarar 100 variáveis, seria 
necessário escrever código para 100 leituras de variáveis e 100 cálculos de desvios. Então, a 
solução é agrupar as 100 notas em uma única variável composta homogênea, ou seja, em um 
vetor. 
Algoritmo 
 início 
 declare soma, media, desvio, 
 nota[100] /* vetor de notas */: numérico real; 
 i /* conterá os índices do vetor */: numérico inteiro; 
 soma ← 0; /* valor inicial para a sumarização das notas */ 
 para i ← 0 até 99 passo 1 faça 
 início 
 escreva(“Digite uma nota”); 
 leia(nota[i]); 
 soma ← soma + nota[i]; 
 fim 
 media ← soma/100; 
 escreva(“Media = ”, media); 
 /* Cálculo dos devios */ 
 para i ← 0 até 99 passo 1 faça 
 início 
desvio ← nota[i] – media; 
escreva(“Desvio da nota ”, nota[i], desvio); 
 fim 
fim 
 
É possível escrever o algoritmo anterior, solicitando do usuário a quantidade de notas 
ao invés de fixar em 100. O problema é que um vetor tem que ter um tamanho máximo e, 
nesse caso, é necessário garantir que o usuário entre com a quantidade de notas menor ou 
igual ao tamanho máximo. Ou seja, não há necessidade de utilizar todas as posições de um 
vetor, mas nunca se deve utilizar posições além de seu tamanho máximo. O tamanho mínimo 
também deve ser garantido – maior que 0. 
 
Algoritmo 
 início 
 declare soma, media, desvio, 
 nota[100] /* vetor de notas */: numérico real; 
 tam, i /* índices do vetor */: numérico inteiro; 
 /* Entrada da quantidade de notas e verificação dos limites 
 do vetor */ 
repita 
 escreva(“Digite a quantidade de notas – mínimo 1 e máximo 
100: ”); 
 leia(tam); 
 se (tam > 100 ou tam ≤ 0) 
 então escreva(“Quantidade de notas inválida”); 
 até (tam > 0 e tam ≤ 100); 
 4 
 soma ← 0; /* valor inicial para a sumarização das notas */ 
 para i ← 0 até tam-1 passo 1 faça 
 início 
 escreva(“Digite uma nota”); 
 leia(nota[i]); 
 soma ← soma + nota[i]; 
 fim 
 media ← soma/tam; 
 escreva(“Media = ”, media); 
 /* Cálculo dos devios */ 
 para i ← 0 até tam-1 passo 1 faça 
 início 
desvio ← nota[i] – media; 
escreva(“Desvio da nota ”, nota[i], desvio); 
 fim 
fim 
5 Exemplos de Algoritmos 
1) Faça um algoritmo que: 
• leia dois vetores, contendo 5 números inteiros cada um; 
• intercale os elementos dos dois vetores, formando um novo vetor de 10 elementos; 
• escreva o vetor resultante da intercalação. 
Solução: 
Entrada: dois vetores de 5 números inteiros; 
Processo: intercalação dos dois vetores gerando um vetor de 10 elementos; 
Saída: vetor de 10 elementos resultante. 
Algoritmo 
início 
 /* Declaração de variáveis */ 
 declare v1[5], v2[5], vr[10], i: numérico inteiro; 
 /* Entrada de dados */ 
 escreva(“Carregando o primeiro vetor:”); 
 para i ← 0 até 4 passo 1 faça 
 início 
 escreva(“Digite um número inteiro: ”); 
 leia(v1[i]); 
 fim 
 escreva(“Carregando o segundo vetor:”); 
 para i ← 0 até 4 passo 1 faça 
 início 
 escreva(“Digite um número inteiro: ”); 
 leia(v2[i]); 
 fim 
 /* Processo – Intercalação dos vetores */ 
para i ← 0 até 4 passo 1 faça 
 início 
 vr[2*i] = v1[i]; 
 vr[2*i+1] = v2[i]; 
 fim 
/* Saída de dados */ 
escreva(“Vetor resultante:”); 
para i ← 0 até 9 passo 1 faça 
 escreva(vr[i]); 
fim 
 
 5 
2) Um vetor X de 150 posições contém o número de matrícula de N alunos (N ≤ 150) de 
uma Universidade. Um outro vetor Y de 150 posições contém as notas dos N alunos 
(N ≤ 150), sendo que as posições de ambos os vetores se relacionam, por exemplo, a 
nota do aluno de matrícula X[i] é dada por Y[i]. Faça um algoritmo que: 
• leia a quantidade N de alunos; 
• leia as informaçõesdos N alunos carregando os vetores X e Y; 
• leia um determinado número de matrícula e determine a nota do aluno correspondente, 
repetindo o processo até que o usuário deseje parar. 
Solução: 
Entrada: número N de alunos e informações sobre os alunos a serem carregadas nos 
vetores X e Y; 
Processo e Saída: consulta a notas de alunos a partir do número da matrícula. 
Algoritmo 
início 
 /* Declaração de variáveis */ 
 declare N, X[150], i, mat, achou: numérico inteiro; 
 Y[150]: numérico real; 
 resp: caractere; 
 /* Entrada de dados */ 
repita 
escreva(“Digite a quantidade de alunos (entre 1 e 150): ”); 
 leia(N); 
 se (N > 150 ou N ≤ 0) 
 então escreva(“Quantidade de alunos inválida”); 
 até (N > 0 e N ≤ 150); 
para i ← 0 até N-1 passo 1 faça 
 início 
 escreva(“Digite o número da matrícula do aluno: ”); 
 leia(X[i]); 
 escreva(“Digite a nota do aluno: ”); 
 leia(Y[i]); 
 fim 
 /* Processo e Saída */ 
 repita 
 /* Lê a matrícula do aluno para consulta */ 
 escreva(“Entre com a matrícula do aluno para consulta: ”); 
 leia(mat); 
 /* Percorre o vetor X, procurando pela matricula */ 
 achou ← 0; /* não achou */ 
 i ← 0; 
 enquanto (i < N e achou = 0) faça 
 início 
 se (X[i] = mat) 
 então início 
 achou ← 1; /* achou */ 
 escreva(“Nota = ”, Y[i]); 
fim 
 i ← i + 1; 
 fim 
 /* Verifica se a matrícula não foi encontrada */ 
 se (achou = 0) /* não achou */ 
 então escreva(“Matricula não encontrada”); 
 /* Permite que o usuário faça mais uma consulta se desejar */ 
 escreva(“Deseja consultar mais um aluno? (S/N)”); 
 leia(resp); 
 até (resp = ‘N’); 
fim 
 6 
3) Faça um algoritmo que carregue um vetor com 10 números inteiros, ordene o vetor em 
ordem crescente e mostre o vetor ordenado. 
Solução: 
Entrada: vetor de 10 número inteiros; 
Processo: ordenação do vetor em ordem crescente; 
Saída: vetor ordenado. 
Algoritmo 
início 
/* Declaração de variáveis */ 
declare v[10], i, j, aux: numérico inteiro; 
/* Entrada de Dados */ 
para i ← 0 até 9 passo 1 faça 
início 
 escreva(“Digite um número inteiro: ”); 
 leia(v[i]); 
fim 
/* Processo – Ordenação do vetor pelo método Bubble Sort */ 
para i ← 0 até 9 passo 1 faça 
 para j ← 0 até 8-i passo 1 faça 
 se (v[j] > v[j+1]) 
 então início 
 aux ← v[j]; 
 v[j] ← v[j+1]; 
 v[j+1] ← aux; 
 fim 
/* Saída */ 
para i ← 0 até 9 passo 1 faça 
 escreva(v[i]); 
fim 
 7 
6 Exercícios de Fixação 
1) Sendo o vetor V igual a: 
V 2 6 8 3 10 9 1 21 33 14 
 0 1 2 3 4 5 6 7 8 9 
e as variáveis X = 1 e Y = 3, escreva o valor correspondente a cada solicitação: 
a) V [X + 1] 
b) V [X * 1] 
c) V [X + Y] 
d) V [V[V[6]]] 
e) V [X + 2] 
f) V [X * 2] 
g) V [8 + V[0]] 
h) V [V[0] * V[3]] 
i) V [X + 3] 
j) V [X * 3] 
k) V [V[3]] 
l) V [X + 4] 
m) V [X * 4] 
n) V [V[X + Y]] 
 
2) Um número é primo se for divisível apenas por si próprio e por 1. Faça um algoritmo 
que carregue um vetor de 10 números inteiros, mostre apenas os números primos e 
suas respectivas posições. 
3) Faça um algoritmo que leia um vetor de N números inteiros (N ≤ 50), determine e 
escreva quantos desses números são pares e quantos são ímpares. 
4) Faça um algoritmo que leia um vetor de N números inteiros (N ≤ 50), calcule e mostre 
a soma dos números que estiverem nas posições pares do vetor. 
5) Faça um algoritmo para corrigir provas de múltipla escolha. Cada prova tem 10 
questões e cada questão vale 1 ponto. O primeiro conjunto de dados a ser lido é o 
gabarito da prova. Os outros dados serão os números dos alunos e suas respectivas 
respostas. Existem 15 alunos matriculados. Calcule e mostre: 
• para cada aluno, sua nota; 
• a percentagem de aprovação, sabendo-se que a nota mínima é 6.0. 
6) Está disponível para entrada de dados o estoque de mercadorias de uma loja. São 
dados os códigos das mercadorias e as respectivas quantidades existentes. A seguir, 
estão disponíveis os pedidos dos clientes. Fazer um algoritmo para atualização do 
estoque, tal que: 
• seja lido o estoque inicial: considerar um vetor contendo os códigos das 
mercadorias e outro contendo a quantidade em estoque, sendo que as posições de 
ambos os vetores se relacionam, por exemplo, a quantidade em estoque da 
mercadoria[i] é dada por estoque[i] (máximo de 100 mercadorias); 
• sejam lidos os pedidos dos clientes, constituídos, cada um, do número do cliente, 
código da mercadoria e quantidade desejada; 
• seja verificado, para cada pedido, se ele pode ser integralmente atendido. Em caso 
negativo, sejam impressos o número do cliente e a mensagem “NÃO TEMOS A 
MERCADORIA EM ESTOQUE SUFICIENTE”; 
• seja atualizado o estoque após cada operação; 
• seja listado o estoque final.