Nos algoritmos que desenvolvemos até agora processamos um valor uma única vez, mas em alguns casos, temos que trabalhar com a mesma informação várias vezes, no mesmo algoritmo. Para resolver este problema utilizamos os comandos de repetição. Também chamado de laço ou loop.

É uma estrutura bem parecida com a decisão SE-ENTÃO. A diferença é que o código de loop é repetido com base em uma determinada condição. Uma expressão booleana – VERDADEIRA ou FALSA – por exemplo.
O ciclo é executado enquanto uma condição for verdadeira, se não, o código não será executado.

Todas as repetições têm como característica o fato de haver uma verificação de condição que pode ser representada por um valor lógico para determinar se a repetição prossegue ou não.

Comando enquanto.

O comando enquanto caracteriza-se por uma verificação de encerramento de atividades antes de se iniciar (ou reiniciar) a execução de seu bloco de instruções.

Exemplo:
Um aluno de castigo deve escrever no quadro 20 vezes que não mais irá fazer bagunça. Vamos exemplificar com um algoritmo – Da forma que estudamos até agora, faríamos desta forma:

Inicio
escreval (“Não vou mais fazer bagunça”)
escreval (“Não vou mais fazer bagunça”)
escreval (“Não vou mais fazer bagunça”)
escreval (“Não vou mais fazer bagunça”)
… (+ 16 vezes)
fimalgoritmo

Utilizando o comando de repetição, precisaremos verificar se o comando já foi executado 20 vezes.
Para criar este laço, precisamos que uma variável faça o papel de contador. Esta variável receberá o número de iterações realizadas, atualizando a cada nova iteração.


Então, para economizar linhas, o aluno bagunceiro escreveria o programa desta forma:
Var
contador:inteiro (o nome da variável sugere seu  objetivo, contar. Ela sempre será do tipo inteiro.)
Inicio
contador <- 0 (a contagem deve iniciar de um número, neste caso zero, um, dois…)
enquanto (contador < 20) faca (limite da contagem. Quando contador = 20, o algoritmo interrompe o loop)
escreval (“Não vou mais fazer bagunça”)
contador <- contador + 1 (O contador recebe o incremento de mais 1 toda vez que o loop é executado)
fimenquanto
fimalgoritmo

* Não é uma regra utilizar a palavra contador como nome de variável. Você pode utilizar outro nome. X, por exemplo. Funcionará da mesma forma.
Não será sempre que utilizaremos a palavra contador como nome de variável para os algoritmos que utilizam repetição. Se o objetivo não é realizar uma contagem, não é interessante este nome de variável. Veja:

Exemplo em vídeo – Faça um algoritmo que mostre na tela os números de 1 a 10 utilizando o comando enquanto.

Todos os algoritmos sequenciais que desenvolvemos no início, podem fazer parte das estruturas de repetição. Por exemplo, os algoritmos onde existe entrada de dados.

Crie um algoritmo que solicite o nome de um jogador de futebol e repita este nome 4 vezes.

algoritmo “Nome do jogador”
var
i: inteiro
nome:caracter
inicio
i <- 0
escreval (“Digite o nome do jogador:”)
leia (nome)
enquanto i < 4 faca
escreval (“Nome do jogador :”,nome)
i <- i + 1
fimenquanto
fimalgoritmo

  • Repare que desta vez não usei a palavra contador e sim a variável i.
  • Se a variável i recebe zero, o contador incrementa +1 a partir de zero:
    i <- 0 +1
    i passa a ser 1
    i <- 1 +1
    i passa a ser 2
    i <- 2 +1
    i passa a ser 3
    i <- 3 +1
    Quando i passa a ser 4, o comando enquanto é interrompido. O Algoritmo é encerrado.
  • Toda vez que i < 4 , o nome do jogador aparece na tela.
  • Se a entrada de dados está fora do laço, ela não é repetida.
  • Diferente de outras estruturas de repetição, o comando Enquanto é verificado no início dos testes. Experimente atribuir 4 para variável i logo após a linha de inicio do algoritmo – O código não é executado e nada é mostrado na tela.

Comando enquanto – Acumulando valores.

Como a partir de agora temos múltiplas entradas de dados, podemos acumular estes valores. Exemplo:
Desenvolva um algoritmo que leia 3 números e mostre na tela o resultado da soma desses números.

  • Neste exemplo a variável soma (dentro do laço – loop) está funcionando como um acumulador. Toda vez que um número é digitado a variável soma incrementa o resultado a um novo número até que contador = 4.
  • Como foi atribuído 1 ao contador, o algoritmo recebe e soma apenas 3 números.
  • O VisualG considera o valor zero se não for atribuido nenhum valor para variável. Experimente retirar as linhas 5 e 6 deste algoritmo. Se o fizer, verá que o algoritmo receberá e somará 4 números, porque passa a considerar o zero.
  • Caso queira mostrar na tela parciais da soma, basta incluir ou repetir a linha 13 dentro do laço.

Comando enquanto – Flag.

Uma flag no comando enquanto representa um mecanismo que serve para controlar – interromper ou permitir a execução de alguns comandos.

Definimos um valor no algoritmo que, caso seja digitado, indicará que o usuário deseja finalizar a entrada de novos dados. Podemos criar uma constante, pois não será alterada durante a execução do programa. E também devemos incluir uma pergunta atrelada a um comando de decisão SE-ENTÃO. Assim o usuário terá a escolha de continuar ou não (flag). Veja este exemplo:

Somar todos os valores que o usuário for digitando até que ele digite o número 0 (zero). Quando o usuário digitar 0 (zero), o laço deve acabar e apresentar o resultado da soma até aquele momento. Vídeo:
 
A finalidade da flag é encerrar uma repetição.
Revisão – Questões desafio!
  • 1 – Faça um algoritmo que leia 5 números e retorne a soma e a média desses valores.

 

  • 2 – Desenvolva um algoritmo que leia n números e faça a soma destes números. O algoritmo deverá ser executado até que o usuário digite não ou N para encerrar a soma e mostrar o resultado. Enquanto o usuário responder sim ou S, o algoritmo deve continuar somando.

 

  • 3 – Desenvolva um algoritmo que leia o salário de 3 empregados de uma empresa. Este algoritmo deve calcular a média salarial da empresa.

 

  • 4 – Calcule a média entre duas notas para 5 alunos de uma escola. Receber as  notas e o nome de cada aluno.
    Cada vez que o programa executar o laço, temos na tela a pergunta ao usuário:
    Digite as notas das provas A1 e A2:
    Logo em seguida o algoritmo mostra a média e o nome desse aluno.
    Por fim. Após ler as 5 notas e mostra a média de cada aluno, o algoritmo mostra a média de toda turma na tela.
  • 5 – Construa um algoritmo que receba 5 números inteiros e positivos e mostre na tela qual o maior número digitado.
  • 6 – Faça um algoritmo que receba a idade de 3 pessoas e mostre mensagem informando “Pode aposentar” ou “Não pode aposentar” para cada pessoa. Considere a idade de 65 anos para se aposentar.