Vetores com lógica de programação
Na aula anterior, aprendemos a declarar, preencher e percorrer
um vetor utilizando a estrutura de repetição PARA.
Agora vamos avançar: aprenderemos a utilizar os valores
armazenados no vetor para resolver problemas.
Para isso, vamos trabalhar com quatro conceitos importantes:
contador, acumulador, estruturas de decisão SE...FIMSE
e repetição REPITA...ATE.
O objetivo é entender como um algoritmo pode analisar vários
valores armazenados, contar quantos atendem a uma condição,
somar resultados e tomar decisões.
1. Entendendo a diferença entre contador e acumulador
Embora sejam utilizados frequentemente juntos, contador e
acumulador possuem funções diferentes.
CONTADOR: utilizado para contar quantas vezes
determinada situação acontece.
ACUMULADOR: utilizado para somar ou acumular
valores ao longo da execução do algoritmo.
Imagine uma turma com cinco alunos. Queremos saber quantos
foram aprovados e qual foi a soma de todas as notas.
Precisaremos de duas variáveis diferentes.
contador <- 0
soma <- 0
contador <- 0: inicia a contagem em zero.
soma <- 0: inicia o acumulador em zero.
Atenção: contador e acumulador precisam ser inicializados
antes de começarmos a utilizá-los.
2. Exemplo 1 – Contando valores dentro de um vetor
ENUNCIADO:
Uma escola deseja armazenar as notas de cinco alunos em um
vetor. Após o preenchimento, o algoritmo deverá verificar
quantos alunos obtiveram nota maior ou igual a 6.
Ao final, deverá apresentar a quantidade de alunos aprovados.
Vamos analisar a lógica antes de escrever o código.
Primeiro precisamos criar um vetor para armazenar as cinco
notas. Depois, precisamos percorrer esse vetor e verificar
cada nota.
Quando uma nota for maior ou igual a 6, aumentaremos o
contador em uma unidade.
algoritmo "ContarAprovados"
var
notas: vetor[1..5] de real
i, contador: inteiro
inicio
contador <- 0
para i de 1 ate 5 faca
escreva("Digite a nota: ")
leia(notas[i])
fimpara
para i de 1 ate 5 faca
se notas[i] >= 6 entao
contador <- contador + 1
fimse
fimpara
escreval("Quantidade de aprovados: ", contador)
fimalgoritmo
Explicando cada trecho:
1. Declaração do vetor:
notas: vetor[1..5] de real
Criamos um vetor com cinco posições para armazenar as notas.
Utilizamos REAL porque uma nota pode possuir casas decimais.
2. Inicialização:
contador <- 0
Começamos a contagem em zero porque ainda não analisamos
nenhum aluno.
3. Preenchimento:
O primeiro PARA solicita as cinco notas e armazena cada
valor na posição correspondente do vetor.
4. Análise:
O segundo PARA percorre todas as posições do vetor.
5. Decisão:
se notas[i] >= 6 entao
Verificamos se a nota da posição atual é maior ou igual a 6.
6. Contagem:
contador <- contador + 1
Se a condição for verdadeira, acrescentamos uma unidade
ao contador.
7. Resultado:
Ao terminar a repetição, o contador informa quantos alunos
foram aprovados.
3. Entendendo o funcionamento do contador
Considere que o vetor recebeu os seguintes valores:
notas[1] = 8
notas[2] = 4
notas[3] = 7
notas[4] = 5
notas[5] = 9
Observe o que acontece durante a análise:
Aluno 1: nota 8 -> aprovado -> contador = 1
Aluno 2: nota 4 -> reprovado -> contador = 1
Aluno 3: nota 7 -> aprovado -> contador = 2
Aluno 4: nota 5 -> reprovado -> contador = 2
Aluno 5: nota 9 -> aprovado -> contador = 3
Resultado final: 3 alunos aprovados.
Perceba que o contador só aumenta quando a condição do SE
é verdadeira. Ele não aumenta simplesmente porque o PARA
executou uma repetição.
4. Exemplo 2 – Utilizando um acumulador
ENUNCIADO:
Uma escola deseja armazenar as notas de cinco alunos em
um vetor. Após o preenchimento, deverá calcular a soma
de todas as notas e apresentar a média da turma.
Nesse problema, precisamos utilizar um acumulador.
Diferentemente do contador, que aumenta uma unidade,
o acumulador recebe os valores que desejamos somar.
algoritmo "MediaDaTurma"
var
notas: vetor[1..5] de real
i: inteiro
soma, media: real
inicio
soma <- 0
para i de 1 ate 5 faca
escreva("Digite a nota: ")
leia(notas[i])
fimpara
para i de 1 ate 5 faca
soma <- soma + notas[i]
fimpara
media <- soma / 5
escreval("Soma das notas: ", soma)
escreval("Media da turma: ", media)
fimalgoritmo
Explicando cada trecho:
1. Inicialização:
soma <- 0
O acumulador começa em zero. Assim, não carregamos nenhum
valor anterior para a soma.
2. Preenchimento:
O primeiro PARA armazena as cinco notas no vetor.
3. Acumulação:
soma <- soma + notas[i]
Essa é a instrução mais importante do exemplo.
Ela significa: pegue o valor que já está armazenado em soma,
acrescente a nota da posição atual e guarde o novo resultado
novamente em soma.
4. Cálculo da média:
media <- soma / 5
Depois de somar todas as notas, dividimos o resultado pela
quantidade de alunos.
5. Exibição:
Apresentamos a soma e a média calculada.
5. Contador e acumulador trabalhando juntos
Agora vamos combinar os dois conceitos em um único problema.
ENUNCIADO:
Uma turma possui cinco alunos. O algoritmo deverá armazenar
suas notas em um vetor e calcular:
• A quantidade de alunos aprovados.
• A soma das notas dos aprovados.
• A média das notas dos aprovados.
Considere aprovado o aluno que obtiver nota maior ou igual
a 6.
algoritmo "AprovadosComMedia"
var
notas: vetor[1..5] de real
i, contador: inteiro
soma, media: real
inicio
contador <- 0
soma <- 0
para i de 1 ate 5 faca
escreva("Digite a nota do aluno: ")
leia(notas[i])
fimpara
para i de 1 ate 5 faca
se notas[i] >= 6 entao
contador <- contador + 1
soma <- soma + notas[i]
fimse
fimpara
se contador > 0 entao
media <- soma / contador
escreval("Aprovados: ", contador)
escreval("Soma das notas: ", soma)
escreval("Media dos aprovados: ", media)
senao
escreval("Nenhum aluno foi aprovado.")
fimse
fimalgoritmo
O que acontece nesse algoritmo?
Quando uma nota é maior ou igual a 6, duas operações
acontecem:
contador <- contador + 1
Contabiliza mais um aluno aprovado.
soma <- soma + notas[i]
Acrescenta a nota desse aluno ao acumulador.
Observe que as duas instruções estão dentro do SE.
Isso significa que somente as notas dos aprovados serão
contabilizadas e somadas.
Por que existe outro SE depois do PARA?
Porque precisamos verificar se contador é maior que zero
antes de dividir a soma pela quantidade de aprovados.
Se ninguém for aprovado, não podemos realizar uma divisão
por zero.
6. Utilizando REPITA...ATE com vetores
Até agora, utilizamos principalmente a estrutura PARA.
Entretanto, existe outra estrutura de repetição que permite
controlar melhor quando uma repetição deve terminar:
REPITA...ATE.
O REPITA executa os comandos primeiro e verifica a condição
de encerramento depois.
Isso significa que os comandos dentro do REPITA são
executados pelo menos uma vez.
Observe a estrutura:
repita
comandos
ate condicao
A repetição continua enquanto a condição do ATE for falsa.
Quando a condição se torna verdadeira, o algoritmo sai
da repetição.
Atenção: no REPITA...ATE, a condição representa a situação
em que devemos PARAR, e não continuar.
7. Exemplo 3 – Preenchendo um vetor com REPITA...ATE
ENUNCIADO:
Uma escola deseja armazenar cinco notas em um vetor.
Utilize a estrutura REPITA...ATE para preencher todas
as posições.
Depois de preencher o vetor, exiba todas as notas
armazenadas.
algoritmo "VetorComRepita"
var
notas: vetor[1..5] de real
i: inteiro
inicio
i <- 1
repita
escreva("Digite a nota: ")
leia(notas[i])
i <- i + 1
ate i > 5
escreval("Notas cadastradas:")
para i de 1 ate 5 faca
escreval(notas[i])
fimpara
fimalgoritmo
Explicando cada trecho:
1. Inicialização do índice:
i <- 1
Começamos na primeira posição do vetor.
2. Início da repetição:
repita
O algoritmo começa a executar os comandos.
3. Leitura:
leia(notas[i])
O valor digitado será armazenado na posição indicada
pela variável i.
4. Avanço do índice:
i <- i + 1
Depois de armazenar uma nota, avançamos para a próxima
posição.
5. Condição de encerramento:
ate i > 5
Quando i se torna 6, significa que as cinco posições
já foram preenchidas e a repetição termina.
6. Exibição:
Depois do preenchimento, utilizamos um PARA para percorrer
e exibir os cinco valores.
8. Exemplo 4 – REPITA, SE e contador juntos
ENUNCIADO:
Uma escola deseja registrar as notas de cinco alunos.
O algoritmo deverá utilizar REPITA...ATE para preencher
o vetor e, depois, percorrer suas posições para contar
quantos alunos foram aprovados.
A aprovação acontece quando a nota é maior ou igual a 6.
algoritmo "ContagemComRepita"
var
notas: vetor[1..5] de real
i, aprovados: inteiro
inicio
i <- 1
aprovados <- 0
repita
escreva("Digite a nota do aluno: ")
leia(notas[i])
i <- i + 1
ate i > 5
i <- 1
repita
se notas[i] >= 6 entao
aprovados <- aprovados + 1
fimse
i <- i + 1
ate i > 5
escreval("Quantidade de aprovados: ", aprovados)
fimalgoritmo
Um detalhe muito importante:
Observe que utilizamos REPITA duas vezes.
O primeiro REPITA é responsável por preencher o vetor.
Depois, reiniciamos a variável i:
i <- 1
Isso é necessário porque o primeiro REPITA terminou com
i igual a 6. Se não reiniciarmos o índice, não conseguiremos
percorrer novamente as cinco posições.
O segundo REPITA percorre o vetor e utiliza o SE para
identificar os aprovados.
Esse exemplo demonstra que podemos utilizar uma mesma
estrutura de repetição em diferentes etapas do algoritmo.
9. Erros comuns ao trabalhar com vetores
Um algoritmo pode apresentar erros mesmo quando sua
estrutura parece correta. Vamos analisar alguns problemas
frequentes e entender como evitá-los.
ERRO 1 – Não inicializar o contador ou acumulador.
Código incorreto:
para i de 1 ate 5 faca
se notas[i] >= 6 entao
contador <- contador + 1
fimse
fimpara
Por que está errado?
A variável contador não recebeu um valor inicial.
O resultado pode ser incorreto porque não sabemos
com qual valor a contagem começou.
Correção:
contador <- 0
para i de 1 ate 5 faca
se notas[i] >= 6 entao
contador <- contador + 1
fimse
fimpara
ERRO 2 – Esquecer de avançar o índice no REPITA.
Código incorreto:
i <- 1
repita
leia(notas[i])
ate i > 5
Por que está errado?
A variável i nunca aumenta. O algoritmo continuará
armazenando valores na primeira posição e a condição
i > 5 nunca será verdadeira.
Correção:
i <- 1
repita
leia(notas[i])
i <- i + 1
ate i > 5
ERRO 3 – Ultrapassar o limite do vetor.
Código incorreto:
notas: vetor[1..5] de real
para i de 1 ate 6 faca
leia(notas[i])
fimpara
Por que está errado?
O vetor possui somente cinco posições. Quando i chegar
a 6, estaremos tentando acessar uma posição inexistente.
Correção:
para i de 1 ate 5 faca
leia(notas[i])
fimpara
ERRO 4 – Somar os valores fora da condição.
Código incorreto para somar somente as notas dos aprovados:
se notas[i] >= 6 entao
contador <- contador + 1
fimse
soma <- soma + notas[i]
Por que está errado?
A soma está fora do SE. Portanto, todas as notas serão
acumuladas, inclusive as dos alunos reprovados.
Correção:
se notas[i] >= 6 entao
contador <- contador + 1
soma <- soma + notas[i]
fimse
ERRO 5 – Utilizar a condição errada no ATE.
Código incorreto:
i <- 1
repita
leia(notas[i])
i <- i + 1
ate i < 5
Por que está errado?
No REPITA...ATE, a repetição termina quando a condição
do ATE se torna verdadeira.
Como i começa em 1 e aumenta, a condição i < 5 já será
verdadeira depois da primeira leitura. O algoritmo
terminará antes de preencher o vetor.
Correção:
ate i > 5
Assim, a repetição continuará enquanto ainda houver
posições para preencher.
10. Resumo: o que aprendemos?
Ao trabalhar com vetores, podemos utilizar diferentes
recursos da lógica de programação.
CONTADOR
Utilizado para contar ocorrências.
contador <- contador + 1
ACUMULADOR
Utilizado para somar valores.
soma <- soma + vetor[i]
SE...FIMSE
Utilizado para verificar condições e tomar decisões.
se vetor[i] >= 6 entao
escreval("Aprovado")
fimse
REPITA...ATE
Utilizado para repetir comandos até que determinada
condição seja verdadeira.
repita
i <- i + 1
ate i > 5
CONCLUSÃO:
Um vetor não serve apenas para guardar informações.
Seu verdadeiro potencial aparece quando utilizamos
estruturas de repetição, decisões, contadores e
acumuladores para processar os dados armazenados.
Aprender a combinar esses recursos é um passo importante
para desenvolver algoritmos capazes de resolver problemas
reais.
11. Desafio para praticar
Agora é sua vez de desenvolver um algoritmo!
ENUNCIADO:
Uma escola deseja cadastrar as notas de dez alunos
utilizando um vetor.
Desenvolva um algoritmo no VisualG que:
1. Declare um vetor capaz de armazenar dez notas.
2. Utilize REPITA...ATE para preencher todas as posições.
3. Percorra o vetor para identificar os alunos aprovados,
considerando nota maior ou igual a 6.
4. Utilize um contador para informar quantos alunos
foram aprovados.
5. Utilize um acumulador para somar as notas dos alunos
aprovados.
6. Calcule a média das notas dos aprovados.
7. Caso ninguém seja aprovado, apresente uma mensagem
informando que não existem notas para calcular a média.
ATENÇÃO: utilize corretamente o SE...FIMSE,
o contador, o acumulador e o REPITA...ATE.
Não esqueça de inicializar as variáveis e verificar os
limites do vetor.
Objetivo do desafio: demonstrar que você
consegue combinar os conceitos estudados em um único
algoritmo.
