06.Vetores

Prévia do material em texto

Vetores Numéricos
DCC 119 – Algoritmos
2
� Em diversas situações os tipos básicos de dados 
(inteiro, real, caracter, ....) não são suficientes para 
representar a informação que se deseja armazenar. 
� Exemplo, uma palavra: “AULA”.
� Valor de 50 produtos em uma loja
� Existe a possibilidade de construção de novos tipos 
de dados a partir da composição (ou abstração) de 
tipos de dados primitivos.
� Esses novos tipos têm um formato denominado 
ESTRUTURA DE DADOS, que define como os tipos 
primitivos estão organizados.
Estruturas de Dados
3
� Problema 1: Como poderíamos fazer um 
algoritmo para ler 50 notas de uma turma e 
calcular sua média?
Motivação
principal
{ 
inteiro i; //variável de controle
real nota, media, soma = 0;
para (i ���� 1; i <= N; i����i+1) faça
{
imprima("Digite uma nota:");
leia(nota);
soma ���� soma + nota;
}
media ���� soma/N;
imprima("Media = ", media);
}
Problema: Qual o 
valor da 1a ou 5a
ou 40a nota?
4
� Problema 2: Fazer um programa para ler 50 notas de uma 
turma e calcular a sua média. Imprimir as notas lidas juntamente 
com a média da turma como na tabela. 
Motivação
Nota Media
8.0 7.75
4.6 7.75
2.3 7.75
3.7 7.75
7.8 7.75
9.0 7.75
.... ...
� Como fazê-lo? No exemplo 
anterior, uma nota é
sobreposta por outra em 
cada iteração do para.
� A solução é armazenar 
todas as 50 notas lidas...
Mas como?!?
5
� Quando uma determinada estrutura de dados 
for composta de variáveis com o mesmo tipo 
primitivo, temos um conjunto homogêneo de 
dados.
� Essas variáveis são chamadas de variáveis 
compostas homogêneas.
Variáveis Compostas Homogêneas
6
� As variáveis compostas homogêneas 
unidimensionais são utilizadas para 
representar arranjos unidimensionais de 
elementos de um mesmo tipo, em outras 
palavras, são utilizadas para representar 
vetores.
Variáveis Compostas Homogêneas 
Unidimensionais (Vetores)
7
� A sintaxe para declaração de uma variável deste tipo, tanto na 
pseudolinguagem quanto em C é a seguinte:
tipo identificador [qtd de elementos];
Exemplo:
// vetor com 5 elementos do tipo inteiro
inteiro dados[5] ; // em C seria ficaria int dados[5];
Vetores: Declaração
0 1 2 3 4
dados
5 elementos quaisquer do tipo inteiro
Índices do vetor
8
� Cada um dos elementos de um vetor é referenciado individualmente por meio de 
um número inteiro entre colchetes após o nome do vetor.
Exemplos:
� Considerando o vetor dados, quais valores serão atribuídos a X e Y nos exemplos 
abaixo???
A instrução abaixo atribui um valor ao elemento 0 (zero) do vetor dados:
Vetores: Referência (Manipulação)
0 1 2 3 4
dados 3 2 74 1
PseudoLinguagem
X ���� dados[1]; 
Y ���� dados[4];
Linguagem c
dados[0] = 6; ou
I = 0;
dados[i] = 6; 
PseudoLinguagem
dados[0] ���� 6; ou
I ���� 0;
dados[i] ���� 6; 
Linguagem c
X = dados[1]; 
Y = dados[4];
9
O programa a seguir, usa o comando para para inicializar com zeros 
os elementos de um array inteiro n de 10 elementos e o imprime sob 
a forma de uma tabela. 
Vetores: Exemplos
principal
{
inteiro n[10], i;
para (i����0; i <= 9; i����i+1) faça
{
n[i] ���� 0;
}
imprima("Elemento Valor");
para (i����0; i <= 9; i����i+1) faça
{
imprima(i," ", n[i]);
}
}
Elemento Valor
0 0
1 0
2 0
3 0
4 0
5 0
6 0
7 0
8 0
9 0
10
Exemplo anterior em C:
Vetores: Exemplos
//inicializando um vetor (array)
#include <stdio.h>
int main()
{
int n[10], i;
for (i=0; i<= 9; i++)
{
n[i] = 0;
}
printf("%s%13s\n","Elemento", "Valor");
for (i=0; i<= 9; i++)
{
printf("%7d%13d\n",i,n[i]);
}
return 0;
}
Elemento Valor
0 0
1 0
2 0
3 0
4 0
5 0
6 0
7 0
8 0
9 0
11
O programa abaixo inicializa os dez elementos de um array s com os 
valores: 2, 4, 6, ..., 20 e imprime o array em um formato de tabela. 
Vetores: Exemplos
Elemento Valor
0 2
1 4
2 6
3 8
4 10
5 12
6 14
7 16
8 18
9 20
principal
{
constante inteiro TAMANHO ���� 10;
inteiro s[TAMANHO], j;
para (j ���� 0; j <= TAMANHO - 1; j ���� j+1) faça
{
s[j] ���� 2 + 2*j;
}
imprima("Elemento Valor"); 
para (j ���� 0; j <= TAMANHO - 1; j ���� j+1) faça
{
imprima (j, " ",s[j]);
}
}
12
Vetores: Exemplos
#include <stdio.h>
#define TAMANHO 10
int main()
{
int s[TAMANHO], j;
for (j=0; j<= TAMANHO - 1; j++)
{
s[j] = 2 + 2*j;
}
printf("%s%13s\n","Elemento", "Valor");
for (j=0; j<= TAMANHO - 1; j++)
{
printf("%8d%13d\n",j,s[j]);
}
return 0;
}
Elemento Valor
0 2
1 4
2 6
3 8
4 10
5 12
6 14
7 16
8 18
9 20
Exemplo anterior em C:
13
Vetores e Subrotinas
� Em pseudolinguagem, a passagem de parâmetros 
em procedimentos e funções é feita por cópia. Para 
realizar a passagem por referência, utilize a palavra 
ref antes do tipo de vetor.
� Em C, vetores são passados sempre por referência.
� Tanto em C, quanto em pseudolinguagem, o 
tamanho do vetor pode ser omitido.
14
Vetores e Subrotinas
No exemplo abaixo é apresentado um procedimento imprimeVetor
que imprime um vetor de tamanho tam.
imprimeVetor (inteiro vet[], inteiro tam)
{
inteiro i;
para (i ���� 0; i <= tam - 1; i ���� i+1) faça
{
imprima (vet[i]);
}
}
principal
{
constante inteiro TAMANHO ���� 10;
inteiro s[TAMANHO], j;
para (j ���� 0; j <= TAMANHO - 1; j ���� j+1)
{
imprima ("Informe o valor do vetor na posição ", j);
leia (s[j]);
}
imprimeVetor(s, TAMANHO);
}
15
Vetores e Subrotinas
Exemplo anterior em C:
#include <stdio.h>
#define TAMANHO 10
void imprimeVetor (int vet[], int tam)
{
int i;
for (i = 0; i <= tam - 1; i++)
{
printf("%d\n", vet[i]);
}
}
int main()
{
int s[TAMANHO], i;
for (i = 0; i <= TAMANHO- 1; i++)
{
printf ("Informe o valor do vetor na posição %d: ", i);
scanf (“%d", &s[i]);
}
imprimeVetor(s, TAMANHO);
return 0;
}
16
Exercício Resolvido 1
� Vamos ver agora o teste de mesa para o 
seguinte problema:
� Criar uma função que receba um vetor de 
números reais e seu tamanho e retorne o índice 
do maior valor contido no vetor. Se houver mais 
de uma ocorrência do maior valor, retornar o 
índice do primeiro. Faça um programa principal 
para testar a função.
17
Exercício 1 - Solução Proposta
inteiro encontraMaior (real vet[], inteiro tam)
{
inteiro indice, i;
real maior ���� vet[0];
indice ���� 0;
para (i ���� 1; i < tam; i ���� i+1) faça
{
se( vet[i] > maior)
{
maior ���� vet[i];
indice ���� i;
}
}
retorne indice;
}
principal
{
real vetor[6] = {3.0, 4.3, 5.6, 2.8, 7.9, 3.4};
inteiro posicao;
posicao ���� encontraMaior( vetor, 6)
imprima("Maior valor esta na posicao ", posicao);
}
18
Exercício 1 - Teste de Mesa
inteiro encontraMaior (real vet[], inteiro tam)
{
inteiro indice, i;
real maior ���� vet[0];
indice ���� 0;
para (i ���� 1; i < tam; i ���� i+1) faça
{
se( vet[i] > maior)
{
maior ���� vet[i];
indice ���� i;
}
}
retorne indice;
}
principal
{
real vetor[6] = {3.0, 4.3, 5.6, 2.8, 7.9, 3.4};
inteiro posicao;
posicao ���� encontraMaior( vetor, 6)
imprima("Maior valor esta na posicao ", posicao);
}
Inicialmente são 
criadas as variáveis
19
Exercício 1 - Teste de Mesa
inteiro encontraMaior (real vet[], inteiro tam)
{
inteiro indice, i;
real maior ���� vet[0];
indice ���� 0;
para (i ���� 1; i < tam; i ���� i+1) faça
{
se( vet[i] > maior)
{
maior ���� vet[i];
indice ���� i;
}
}
retorne indice;}
principal
{
real vetor[6] = {3.0, 4.3, 5.6, 2.8, 7.9, 3.4};
inteiro posicao;
posicao ���� encontraMaior( vetor, 6)
imprima("Maior valor esta na posicao ", posicao);
}
Chama a função 
encontraMaior
20
Exercício 1 - Teste de Mesa
inteiro encontraMaior (real vet[], inteiro tam)
{
inteiro indice, i;
real maior ���� vet[0];
indice ���� 0;
para (i ���� 1; i < tam; i ���� i+1) faça
{
se( vet[i] > maior)
{
maior ���� vet[i];
indice ���� i;
}
}
retorne indice;
}
principal
{
real vetor[6] = {3.0, 4.3, 5.6, 2.8, 7.9, 3.4};
inteiro posicao;
posicao ���� encontraMaior( vetor, 6)
imprima("Maior valor esta na posicao ", posicao);
}
Vetor e seu 
tamanho são 
passados como 
parâmetro
21
Exercício 1 - Teste de Mesa
inteiro encontraMaior (real vet[], inteiro tam)
{
inteiro indice, i;
real maior ���� vet[0];
indice ���� 0;
para (i ���� 1; i < tam; i ���� i+1) faça
{
se( vet[i] > maior)
{
maior ���� vet[i];
indice ���� i;
}
}
retorne indice;
}
principal
{
real vetor[6] = {3.0, 4.3, 5.6, 2.8, 7.9, 3.4};
inteiro posicao;
posicao ���� encontraMaior( vetor, 6)
imprima("Maior valor esta na posicao ", posicao);
}
Variáveis
maior = 3.0
indice = 0
Variávies locais da 
função são inicializadas
22
Exercício 1 - Teste de Mesa
inteiro encontraMaior (real vet[], inteiro tam)
{
inteiro indice, i;
real maior ���� vet[0];
indice ���� 0;
para (i ���� 1; i < tam; i ���� i+1) faça
{
se( vet[i] > maior)
{
maior ���� vet[i];
indice ���� i;
}
}
retorne indice;
}
principal
{
real vetor[6] = {3.0, 4.3, 5.6, 2.8, 7.9, 3.4};
inteiro posicao;
posicao ���� encontraMaior( vetor, 6)
imprima("Maior valor esta na posicao ", posicao);
}
Variáveis
maior = 3.0
indice = 0
i = 1
Começa a busca pelo 
índice 1, uma vez que o 
índice zero já foi utilizada 
para inicializar a variável 
indice
23
Exercício 1 - Teste de Mesa
inteiro encontraMaior (real vet[], inteiro tam)
{
inteiro indice, i;
real maior ���� vet[0];
indice ���� 0;
para (i ���� 1; i < tam; i ���� i+1) faça
{
se( 4.3 > 3.0 )
{
maior ���� vet[i];
indice ���� i;
}
}
retorne indice;
}
principal
{
real vetor[6] = {3.0, 4.3, 5.6, 2.8, 7.9, 3.4};
inteiro posicao;
posicao ���� encontraMaior( vetor, 6)
imprima("Maior valor esta na posicao ", posicao);
}
Variáveis
maior = 3.0
indice = 0
i = 1
Executa o primeiro teste
24
Exercício 1 - Teste de Mesa
inteiro encontraMaior (real vet[], inteiro tam)
{
inteiro indice, i;
real maior ���� vet[0];
indice ���� 0;
para (i ���� 1; i < tam; i ���� i+1) faça
{
se( 4.3 > 3.0 )
{
maior ���� vet[i];
indice ���� i;
}
}
retorne indice;
}
principal
{
real vetor[6] = {3.0, 4.3, 5.6, 2.8, 7.9, 3.4};
inteiro posicao;
posicao ���� encontraMaior( vetor, 6)
imprima("Maior valor esta na posicao ", posicao);
}
Variáveis
maior = 4.3
indice = 1
i = 1
Sendo o teste verdadeiro, 
atualiza variáveis maior e 
indice.
25
Exercício 1 - Teste de Mesa
inteiro encontraMaior (real vet[], inteiro tam)
{
inteiro indice, i;
real maior ���� vet[0];
indice ���� 0;
para (i ���� 1; i < tam; i ���� i+1) faça
{
se( vet[i] > maior )
{
maior ���� vet[i];
indice ���� i;
}
}
retorne indice;
}
principal
{
real vetor[6] = {3.0, 4.3, 5.6, 2.8, 7.9, 3.4};
inteiro posicao;
posicao ���� encontraMaior( vetor, 6)
imprima("Maior valor esta na posicao ", posicao);
}
Variáveis
maior = 4.3
indice = 1
i = 2
Passa para a próxima 
iteração do loop.
26
Exercício 1 - Teste de Mesa
inteiro encontraMaior (real vet[], inteiro tam)
{
inteiro indice, i;
real maior ���� vet[0];
indice ���� 0;
para (i ���� 1; i < tam; i ���� i+1) faça
{
se( 5.6 > 4.3 )
{
maior ���� vet[i];
indice ���� i;
}
}
retorne indice;
}
principal
{
real vetor[6] = {3.0, 4.3, 5.6, 2.8, 7.9, 3.4};
inteiro posicao;
posicao ���� encontraMaior( vetor, 6)
imprima("Maior valor esta na posicao ", posicao);
}
Variáveis
maior = 4.3
indice = 1
i = 2
Mais um teste verdadeiro.
27
Exercício 1 - Teste de Mesa
inteiro encontraMaior (real vet[], inteiro tam)
{
inteiro indice, i;
real maior ���� vet[0];
indice ���� 0;
para (i ���� 1; i < tam; i ���� i+1) faça
{
se( 5.6 > 4.3 )
{
maior ���� vet[i];
indice ���� i;
}
}
retorne indice;
}
principal
{
real vetor[6] = {3.0, 4.3, 5.6, 2.8, 7.9, 3.4};
inteiro posicao;
posicao ���� encontraMaior( vetor, 6)
imprima("Maior valor esta na posicao ", posicao);
}
Variáveis
maior = 5.6
indice = 2
i = 2
Sendo o teste verdadeiro, 
atualiza variáveis maior e 
indice.
28
Exercício 1 - Teste de Mesa
inteiro encontraMaior (real vet[], inteiro tam)
{
inteiro indice, i;
real maior ���� vet[0];
indice ���� 0;
para (i ���� 1; i < tam; i ���� i+1) faça
{
se( vet[i] > maior )
{
maior ���� vet[i];
indice ���� i;
}
}
retorne indice;
}
principal
{
real vetor[6] = {3.0, 4.3, 5.6, 2.8, 7.9, 3.4};
inteiro posicao;
posicao ���� encontraMaior( vetor, 6)
imprima("Maior valor esta na posicao ", posicao);
}
Variáveis
maior = 5.6
indice = 2
i = 3
Passa para a próxima 
iteração do loop.
29
Exercício 1 - Teste de Mesa
inteiro encontraMaior (real vet[], inteiro tam)
{
inteiro indice, i;
real maior ���� vet[0];
indice ���� 0;
para (i ���� 1; i < tam; i ���� i+1) faça
{
se( 2.8 > 5.6 )
{
maior ���� vet[i];
indice ���� i;
}
}
retorne indice;
}
principal
{
real vetor[6] = {3.0, 4.3, 5.6, 2.8, 7.9, 3.4};
inteiro posicao;
posicao ���� encontraMaior( vetor, 6)
imprima("Maior valor esta na posicao ", posicao);
}
Variáveis
maior = 5.6
indice = 2
i = 3
Valor do vetor é menor, 
não entra na condição.
30
Exercício 1 - Teste de Mesa
inteiro encontraMaior (real vet[], inteiro tam)
{
inteiro indice, i;
real maior ���� vet[0];
indice ���� 0;
para (i ���� 1; i < tam; i ���� i+1) faça
{
se( vet[i] > maior )
{
maior ���� vet[i];
indice ���� i;
}
}
retorne indice;
}
principal
{
real vetor[6] = {3.0, 4.3, 5.6, 2.8, 7.9, 3.4};
inteiro posicao;
posicao ���� encontraMaior( vetor, 6)
imprima("Maior valor esta na posicao ", posicao);
}
Variáveis
maior = 5.6
indice = 2
i = 4
Passa para a próxima 
iteração do loop.
31
Exercício 1 - Teste de Mesa
inteiro encontraMaior (real vet[], inteiro tam)
{
inteiro indice, i;
real maior ���� vet[0];
indice ���� 0;
para (i ���� 1; i < tam; i ���� i+1) faça
{
se( 7.9 > 5.6 )
{
maior ���� vet[i];
indice ���� i;
}
}
retorne indice;
}
principal
{
real vetor[6] = {3.0, 4.3, 5.6, 2.8, 7.9, 3.4};
inteiro posicao;
posicao ���� encontraMaior( vetor, 6)
imprima("Maior valor esta na posicao ", posicao);
}
Variáveis
maior = 5.6
indice = 2
i = 4
Mais um teste verdadeiro.
32
Exercício 1 - Teste de Mesa
inteiro encontraMaior (real vet[], inteiro tam)
{
inteiro indice, i;
real maior ���� vet[0];
indice ���� 0;
para (i ���� 1; i < tam; i ���� i+1) faça
{
se( 7.9 > 5.6 )
{
maior ���� vet[i];
indice ���� i;
}
}
retorne indice;
}
principal
{
real vetor[6] = {3.0, 4.3, 5.6, 2.8, 7.9, 3.4};
inteiro posicao;
posicao ���� encontraMaior( vetor, 6)
imprima("Maior valor esta na posicao ", posicao);
}
Variáveis
maior = 7.9
indice = 4
i = 4
Sendo o teste verdadeiro, 
atualiza variáveis maior e 
indice.
33
Exercício 1 - Teste de Mesa
inteiro encontraMaior(real vet[], inteiro tam)
{
inteiro indice, i;
real maior ���� vet[0];
indice ���� 0;
para (i ���� 1; i < tam; i ���� i+1) faça
{
se( vet[i] > maior )
{
maior ���� vet[i];
indice ���� i;
}
}
retorne indice;
}
principal
{
real vetor[6] = {3.0, 4.3, 5.6, 2.8, 7.9, 3.4};
inteiro posicao;
posicao ���� encontraMaior( vetor, 6)
imprima("Maior valor esta na posicao ", posicao);
}
Variáveis
maior = 7.9
indice = 4
i = 4
Passa para a penúltima 
iteração do loop.
34
Exercício 1 - Teste de Mesa
inteiro encontraMaior (real vet[], inteiro tam)
{
inteiro indice, i;
real maior ���� vet[0];
indice ���� 0;
para (i ���� 1; i < tam; i ���� i+1) faça
{
se( 3.4 > 7.9 )
{
maior ���� vet[i];
indice ���� i;
}
}
retorne indice;
}
principal
{
real vetor[6] = {3.0, 4.3, 5.6, 2.8, 7.9, 3.4};
inteiro posicao;
posicao ���� encontraMaior( vetor, 6)
imprima("Maior valor esta na posicao ", posicao);
}
Variáveis
maior = 7.9
indice = 4
i = 4
Valor do vetor é menor, 
não entra na condição.
35
Exercício 1 - Teste de Mesa
inteiro encontraMaior (real vet[], inteiro tam)
{
inteiro indice, i;
real maior ���� vet[0];
indice ���� 0;
para (i ���� 1; i < tam; i ���� i+1) faça
{
se( vet[i] > maior )
{
maior ���� vet[i];
indice ���� i;
}
}
retorne indice;
}
principal
{
real vetor[6] = {3.0, 4.3, 5.6, 2.8, 7.9, 3.4};
inteiro posicao;
posicao ���� encontraMaior( vetor, 6)
imprima("Maior valor esta na posicao ", posicao);
}
Variáveis
maior = 7.9
indice = 4
i = 5
Passa para a última 
iteração do loop (nesse 
caso, não entra)
36
Exercício 1 - Teste de Mesa
inteiro encontraMaior (real vet[], inteiro tam)
{
inteiro indice, i;
real maior ���� vet[0];
indice ���� 0;
para (i ���� 1; i < tam; i ���� i+1) faça
{
se( vet[i] > maior )
{
maior ���� vet[i];
indice ���� i;
}
}
retorne 4;
}
principal
{
real vetor[6] = {3.0, 4.3, 5.6, 2.8, 7.9, 3.4};
inteiro posicao;
posicao ���� encontraMaior( vetor, 6)
imprima("Maior valor esta na posicao ", posicao);
}
Variáveis
maior = 7.9
indice = 4
i = 5
Retorna o valor do maior 
valor
37
Exercício 1 - Teste de Mesa
inteiro encontraMaior (real vet[], inteiro tam)
{
inteiro indice, i;
real maior ���� vet[0];
indice ���� 0;
para (i ���� 1; i < tam; i ���� i+1) faça
{
se( vet[i] > maior )
{
maior ���� vet[i];
indice ���� i;
}
}
retorne indice;
}
principal
{
real vetor[6] = {3.0, 4.3, 5.6, 2.8, 7.9, 3.4};
inteiro posicao;
posicao ���� encontraMaior( vetor, 6)
imprima("Maior valor esta na posicao ", posicao);
}
Variáveis
maior = 7.9
indice = 4
i = 5
posicao = 4
Volta para a função principal, 
pegando o retorno do índice 
do maior valor
38
Exercício 1 - Teste de Mesa
inteiro encontraMaior (real vet[], inteiro tam)
{
inteiro indice, i;
real maior ���� vet[0];
indice ���� 0;
para (i ���� 1; i < tam; i ���� i+1) faça
{
se( vet[i] > maior )
{
maior ���� vet[i];
indice ���� i;
}
}
retorne indice;
}
principal
{
real vetor[6] = {3.0, 4.3, 5.6, 2.8, 7.9, 3.4};
inteiro posicao;
posicao ���� encontraMaior( vetor, 6)
imprima("Maior valor esta na posicao ", posicao);
}
Variáveis
maior = 7.9
indice = 4
i = 5
posicao = 4
Maior valor esta na posicao 4
Imprime o índice do 
maior valor
39
Exercício Resolvido 2
� Criar uma função em C que receba um vetor 
de números reais e um valor inteiro 
representando o seu tamanho. Essa função 
deverá ordenar o vetor em ordem crescente.
40
Exercício 2 - Solução Proposta
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( vet[j] < vet[j-1] )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
41
Exercício 2 – Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( vet[j] < vet[j-1] )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
Vamos supor para esse 
exercício que o vetor de 
entrada tenha 5 posições e 
os seguintes valores
11.0, 22.0, 3.0, 44.0, 5.0
42
Exercício 2 – Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( vet[j] < vet[j-1] )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
Inicialmente função é
chamada passando-se 
os valores propostos
5.044.03.022.011.0
0 1 2 3 4 
Variáveis:
tam = 5
43
Exercício 2 – Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( vet[j] < vet[j-1] )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
A seguir são criadas as 
variáveis auxiliares
5.044.03.022.011.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 
j = 
aux = 
44
Exercício 2 – Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( vet[j] < vet[j-1] )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
A idéia central é ir “puxando”
os menores valores através de 
trocas para o início do vetor
5.044.03.022.011.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 0 
j = 
aux = 
45
Exercício 2 – Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( vet[j] < vet[j-1] )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
É no loop interno que iremos iterar 
sobre o vetor efetuando essas trocas, 
conforme os menores valores forem 
sendo identificados.
Repare que iremos iterar do último 
elemento até o elemento i+1.
5.044.03.022.011.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 0 
j = 4
aux = 
46
Exercício 2 – Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( 5.0 < 44.0 )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
Os testes são feitos sempre entre os 
valores i e o seu antecessor (i-1)
5.044.03.022.011.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 0 
j = 4
aux = 
47
Exercício 2 – Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( 5.0 < 44.0 )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
Como é menor, efetua a troca
5.044.03.022.011.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 0 
j = 4
aux = 5.0
48
Exercício 2 – Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( 5.0 < 44.0 )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
44.044.03.022.011.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 0 
j = 4
aux = 5.0
49
Exercício 2 – Testede Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( 5.0 < 44.0 )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
44.05.03.022.011.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 0 
j = 4
aux = 5.0
50
Exercício 2 – Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( vet[j] < vet[j-1] )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
44.05.03.022.011.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 0 
j = 3
aux = 5.0
51
Exercício 2 – Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( 5.0 < 3.0 )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
44.05.03.022.011.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 0 
j = 3
aux = 5.0
Aqui o teste falha. Vai para a próxima 
iteração do loop interno.
52
Exercício 2 – Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( vet[j] < vet[j-1] )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
44.05.03.022.011.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 0 
j = 2
aux = 5.0
53
Exercício 2 – Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( 3.0 < 22.0 )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
44.05.03.022.011.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 0 
j = 2
aux = 5.0
54
Exercício 2 – Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( 3.0 < 22.0 )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
44.05.022.03.011.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 0 
j = 2
aux = 3.0
Como valor é menor, efetua a troca 
como visto anteriormente.
55
Exercício 2 – Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( vet[j] < vet[j-1] )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
44.05.022.03.011.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 0 
j = 1
aux = 3.0
56
Exercício 2 – Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( 3.0 < 11.0 )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
44.05.022.03.011.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 0 
j = 1
aux = 3.0
57
Exercício 2 – Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( 3.0 < 11.0 )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
44.05.022.011.03.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 0 
j = 1
aux = 3.0
Como valor é menor, efetua a troca 
como visto anteriormente.
58
Exercício 2 – Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( vet[j] < vet[j-1] )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
44.05.022.011.03.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 0 
j = 0
aux = 3.0
Nesse ponto, como j = 0, saiu do laço 
interno e volta para o externo.
59
Exercício 2 – Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( vet[j] < vet[j-1] )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
44.05.022.011.03.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 1 
j = 0
aux = 3.0
Como o i é incrementado, a posição 
0 do vetor não será mais modificada
60
Exercício 2 – Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( vet[j] < vet[j-1] )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
44.05.022.011.03.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 1 
j = 4
aux = 3.0
61
Exercício 2 – Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( 44.0 < 5.0 )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
44.05.022.011.03.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 1 
j = 4
aux = 3.0
62
Exercício 2 – Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( vet[j] < vet[j-1] )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
44.05.022.011.03.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 1 
j = 3
aux = 3.0
63
Exercício 2 – Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( 5.0 < 22.0 )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
44.05.022.011.03.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 1 
j = 3
aux = 3.0
64
Exercício 2 – Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( 5.0 < 22.0 )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
44.022.05.011.03.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 1 
j = 3
aux = 5.0
Como valor é menor, efetua a troca 
como visto anteriormente.
65
Exercício 2 – Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if (vet[j] < vet[j-1] )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
44.022.05.011.03.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 1 
j = 2
aux = 5.0
66
Exercício 2 – Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if (5.0 < 11.0 )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
44.022.05.011.03.0
0 1 2 3 4 
Variáveis:tam = 5
i = 1 
j = 2
aux = 5.0
67
Exercício 2 – Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if (5.0 < 11.0 )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
44.022.011.05.03.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 1 
j = 2
aux = 5.0
Como valor é menor, efetua a troca 
como visto anteriormente.
68
Exercício 2 – Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if (vet[j] < vet[j-1] )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
44.022.011.05.03.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 1 
j = 1
aux = 5.0
Nesse ponto, como j = 1, saiu do laço 
interno e volta para o externo.
69
Exercício 2 – Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if (vet[j] < vet[j-1] )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
44.022.011.05.03.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 2 
j = 1
aux = 5.0
Como o i é incrementado, a posição 
1 do vetor não será mais modificada
70
Exercício 2 – Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( 44.0 < 22.0 )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
44.022.011.05.03.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 2 
j = 4
aux = 5.0
71
Exercício 2 – Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( 22.0 < 11.0 )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
44.022.011.05.03.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 2 
j = 3
aux = 5.0
72
Exercício 2 – Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( vet[j] < vet[j-1] )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
44.022.011.05.03.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 2 
j = 2
aux = 5.0
Como j = 2, saiu do laço interno e 
volta para o externo.
73
Exercício 2 – Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( vet[j] < vet[j-1] )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
44.022.011.05.03.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 3 
j = 2
aux = 5.0
Como o i é incrementado, a posição 
2 do vetor não será mais modificada
74
Exercício 2 – Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( 44.0 < 22.0 )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
44.022.011.05.03.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 3 
j = 4
aux = 5.0
75
Exercício 2 – Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( 44.0 < 22.0 )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
44.022.011.05.03.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 3 
j = 3
aux = 5.0
Como j = 3, saiu do laço interno e 
volta para o externo.
76
Exercício 2 – Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( 44.0 < 22.0 )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
44.022.011.05.03.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 4 
j = 3
aux = 5.0
Como o i é incrementado, e sai do laço 
externo, finalizando a procedimento.
77
#include <stdio.h>
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( vet[j] < vet[j-1] )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
int main()
{
int i;
float vet[5]={11.0,22.0,3.0,44.0,5.0}; 
ordena(vet, 5);
for (i=0; i < 5; i++)
printf("%.2f\n",vet[i]);
return 0;
}
Programa Completo
78
Exercícios
1) Quais são os elementos do vetor referenciados pelas 
expressões abaixo ?
vet
a) vet[3] b) vet[0] c) vet[13]
2) Qual é a diferença entre os números “3” das duas 
instruções abaixo ?
inteiro vet[3];
vet[3] ���� 5;
1 2 4 7 4 2 8 9 0 6 5 4 3
79
Exercícios
3) Dada um tabela contendo a idade de 10 
alunos, faça um algoritmo que calcule o número 
de alunos com idade superior a média.
4) Faça um algoritmo para ler e somar dois 
vetores de 10 elementos inteiros. Imprima ao 
final os valores dessa soma, elemento a 
elemento.
5) Refaça o exercício anterior criando um 
procedimento para efetuar a leitura dos vetores e 
um segundo procedimento que imprimirá a soma 
dos vetores.
80
Exercícios
6) Refaça o exercício anterior criando uma função 
que receba o vetor com a idade dos alunos e retorne 
a quantidade de alunos com idade superior a média.
7) Faça um algoritmo que leia, via teclado, 20 
valores do tipo inteiro e determine qual o menor 
valor existente no vetor e imprima valor e seu índice 
no vetor.
8) Refaça o exercício anterior criando um 
procedimento que receba como parâmetro o vetor e 
imprima o menor valor e seu índice no vetor.
81
Vetores Numéricos
DCC 120
82
� O vetor é uma estrutura: 
�Homogênea 
�Estática
� Todas as componentes são de um mesmo tipo 
e seu tamanho permanece o mesmo durante 
toda a execução do programa.
Vetores
83
� A sintaxe em C para declaração de variável do tipo 
vetor é a seguinte
tipo_primitivo identificador[qtde_elementos];
Exemplo:
// vetor com 5 (0 a 4) elementos do tipo int
int dados[5];
Vetores: Declaração
0 1 2 3 4
dados
5 elementos quaisquer do tipo int
Índices do vetor
84
� Cada um dos elementos de um vetor é referenciado individualmente por meio de 
um número inteiro entre colchetes após o nome do vetor.
Exemplos:
� X = valores[1]; //atribui a x o valor da posição 1 do vetor valores
� Y = valores[4]; //atribui a x o valor da posição 4 do vetor valores
� valores[0] = 3.2; // a posição zero do vetor valores recebe o valor 3.2
Vetores: Referência 
(Manipulação)
0 1 2 3 4
valores 3.6 2.7 7.94.2 1.2
85
É possível fornecer valores a cada elemento de 
um vetor no momento da sua declaração. 
Exemplo:
float valores[5] = {3.6, 2.7, 4.2, 7.9, 1.2};
float nros[5] = {0.0}; // como fica o vetor????
Vetores: Inicialização
0 1 2 3 4
valores 3.6 2.7 7.94.2 1.2
86
Observações:
� Os vetores NÃO são automaticamente inicializados!!! 
� Se houver menos valores do que o número de elementos do vetor , 
os elementos restantes são inicializadosautomaticamente com o valor 
zero.
int n[5] = {32, 64, 27};
� A seguinte declaração causa um erro de sintaxe:
int n[5] = {32, 64, 27, 18, 95, 14};
� O tamanho do vetores pode ser omitido:
int n[ ] = {1, 2, 3, 4, 5};
Vetores: Inicialização
87
Vetores: Exemplo
� Leia um vetor de 10 posições (inteiros) e imprima-o na ordem 
invertida (da última para a primeira posição).
#include <stdio.h>
#include <stdlib.h>
int main()
{
int numeros[10],i;
for (i=0; i<10;i++){
printf("Digite valor %d: ",i);
scanf("%d", &numeros[i]);
}
printf("Vetor na ordem invertida:\n");
for (i=9; i>=0; i--)
printf("%d\n",numeros[i]);
return 0;
}
88
Vetores e Subrotinas
� Em C, vetores são passados sempre por 
referência.
� Ou seja, as modificações feitas na subrotina
refletem nos dados do vetor passado como 
parâmetro pela função chamadora. 
89
Vetores e Subrotinas: Exemplo
� O exemplo a seguir apresenta subrotinas
para leitura e impressão do vetor e cálculos 
do maior, menor e média dos elementos. 
90
Vetores e Subrotinas: Exemplo (1/3)
#include <stdio.h>
#define TAMANHO 10
void leVetor(int vet[], int tam)
{
int i;
for(i = 0; i < tam; i++)
{
printf("Informe o valor do vetor na posição %d: ", i);
scanf("%d", &vet[i]);
}
}
void imprimeVetor(int vet[], int tam)
{
int i;
printf("Vetor: ");
for(i = 0; i < tam; i++)
{
printf("%d ", vet[i]);
}
}
91
Vetores e Subrotinas: Exemplo (2/3)
int maiorElemento(int vet[], int tam)
{
int i, maior = vet[0];
for(i = 1; i < tam; i++)
{
if(vet[i] > maior)
maior = vet[i];
}
return maior;
}
int menorElemento(int vet[], int tam)
{
int i, menor = vet[0];
for(i = 1; i < tam; i++)
{
if(vet[i] < menor)
menor = vet[i];
}
return menor;
}
92
Vetores e Subrotinas: Exemplo (3/3)
float mediaVetor(int vet[], int tam)
{
int i, soma = 0;
for(i = 0; i < tam; i++)
{
soma = soma + vet[i];
}
return soma / (float)tam;
}
int main()
{
int v[TAMANHO];
leVetor(v, TAMANHO);
imprimeVetor(v, TAMANHO);
printf("\nO maior elemento do vetor é %d.", maiorElemento(v, TAMANHO));
printf("\nO menor elemento do vetor é %d.", menorElemento(v, TAMANHO));
printf("\nA média dos valores do vetor é %.2f.",mediaVetor(v, TAMANHO));
return 0;
} 
93
Exercícios
1) Desenvolva um programa que leia um vetor de números 
reais, um escalar e imprima o resultado da multiplicação do 
vetor pelo escalar.
2) Faça um procedimento que faça a leitura um vetor de 10 
elementos inteiros e imprima somente os valores 
armazenados nos índices pares. 
3) Faça um programa que leia um vetor com 15 valores reais. 
A seguir, encontre o menor elemento do vetor e a sua 
posição dentro do vetor, mostrando: “O menor elemento do 
vetor esta na posição XXXX e tem o valor YYYYY.”
4) Faça um programa que leia um vetor de 15 posições 
(reais) e depois um valor a ser procurado no vetor. Imprima 
se o valor foi ou não encontrado e a quantidade de vezes que 
o valor está presente no vetor.
94
Exercícios
5) Faça uma função que receba um vetor de números 
inteiros e um valor inteiro. A função deverá procurar este 
segundo valor neste vetor e retornar seu índice se for 
encontrado. Se o elemento não for encontrado, retornar -1.
6) Dada uma tabela com as notas de uma turma de 20 
alunos, faça funções que retornem:
a) A média da turma.
b) a quantidade de alunos aprovados (>=60)
c) a quantidade de alunso reprovados.(< 60)
7) Faça um programa que leia um conjunto de 20 valores e 
armazene-os num vetor V. Particione-o em dois outros 
vetores, P e I, conforme os valores de V forem pares ou 
ímpares. No final, imprima os valores dos 3 vetores.
95
Exercícios
8) Faça um programa que leia um vetor G[13] que é o 
gabarito de um teste da loteria esportiva, contendo os valores 
1 quando for coluna 1, 0 quando for coluna do meio e 2 
quando for coluna 2. 
Ler a seguir, para 5 apostadores, seu cartão de apostas 
(R[13]) e depois da leitura imprimir quantos acertos o 
apostador teve.
Faça o teste através de funções.
9) Com relação ao exercício anterior, calcule e mostre o 
percentual dos apostadores que fizeram de 10 a 13 pontos e 
o percentual dos apostadores que fizeram menos do que 10 
pontos.
10) Faça um programa que leia um vetor de valores inteiros e 
imprima-o na ordem crescente. O vetor deve ter tamanho N 
(utilize a diretiva #define).