Olá pessoal!

Neste post vou falar um pouco sobre as estruturas de repetição ou os laços.

As estruturas de repetição executam várias vezes uma parte do código, até que certa condição seja atingida.
Normalmente esta condição se dá através da verificação de uma variável, se ela atende um requisito ou não.

O Visualg possui 3 estruturas de repetição:

- repita … ate
- enquanto … faca
- para … faca

O comando repita … ate

Este comando repete o trecho de um programa até a condição ser atingida.
Sua estrutura é a seguinte:

repita
"conjunto de instruções"
ate  "condição"

Onde:
- conjunto de instruções: São as instruções que devem ser repetidas até a condição ser atingida
- condição: A condição a ser verificada

O laço termina quando a condição estipulada for verdadeira.

Exemplo:

Fazer um algorítimo que mostre os números de 0 à 9.

Vamos tomar nossa condição como sendo um índice.
Este índice nada mais é que uma variável que será incrementada a cada passagem do laço, até que essa variável alcance um valor.

algoritmo "ContaNumero"
// Função : Mostrar os números de 0 à 9
// Autor : Alex Giuliano Martins
// Data : 15/4/2012
// Seção de Declarações

var
i: inteiro //Declaração da nossa variável "i"

inicio
 i <- 0 //Nossa variável é inicializada recebendo o valor 0, FORA DO LAÇO!
 repita //Início do laço
  escreval("Número: ", i) //Escreve o valor que atualmente está na variável "i"
                          //Nesta primeira passagem, apresenta 0, pois foi atribuído acima,
                          //fora do laço.
  i <- i + 1 //Aqui, a cada passagem, a variável "i" recebe o valor dela mesma + 1
             //Ou seja, na primeira passagem será 0 + 1 que transformará em 1
             //Na segunda passagem será 1 + 1, que transformará em 2, depois 2 + 1, que vira 3,
             //então 3 + 1, que vira 4, 4 + 1, que vira 5...
 ate i >= 10 //A condição para que o laço pare é o conteúdo da variável "i" ser maior ou igual a 10
fimalgoritmo

Repare que a condição é verificada após a passagem de todo o código. E isso significa:

No comando repita … ate, o código é executado AO MENOS uma vez, pois quando ele começa, nenhuma condição é verificada.

Note também que a condição para parada é i >= 10 (i maior ou igual a 10) e não 9. Mas por que?
Pense bem… Se a condição fosse i >= 9, quando o valor de i chegar a 9 o laço seria finalizado. Ou seja, não haveria uma nova passagem pelo escreval(Número: “,i) e então o 9 não apareceria.
Então a condição para que seja executado n vezes é i >= n + 1.

O comando enquanto … faca

Não há muita diferença entre este e o repita … ate, a não ser o fato de que o enquanto … faca faz a verificação da condição ANTES de executar o bloco de repetição.

Veja o mesmo caso anterior reescrito para o enquanto … faca:

algoritmo "ContaNumero"
// Função : Mostrar os números de 0 à 10
// Autor : Alex Giuliano Martins
// Data : 15/4/2012
// Seção de Declarações

var
i: inteiro //Declaração da nossa variável "i"

inicio
 i <- 0 //Nossa variável é inicializada recebendo o valor 0, FORA DO LAÇO!
 enquanto i <= 10 faca //Início do laço e da verificação de condição. Aqui "i" é menor que 10
  escreval("Número: ", i) //Escreve o valor que atualmente está na variável "i"
                          //Nesta primeira passagem, apresenta 0, pois foi atribuído acima,
                          //fora do laço.
  i <- i + 1 //Aqui, a cada passagem, a variável "i" recebe o valor dela mesma + 1
             //Ou seja, na primeira passagem será 0 + 1 que transformará em 1
             //Na segunda passagem será 1 + 1, que transformará em 2, depois 2 + 1, que vira 3,
             //então 3 + 1, que vira 4, 4 + 1, que vira 5...
 fimenquanto //Agora é necessário informar ao Visualg onde é o fim da estrutura de repetição,
             //para continuar a execução do programa na linha abaixo do bloco.
fimalgoritmo

Isso significa que se logo no começo fizermos i <- 10 (ou qualquer número acima de 10), o bloco de repetição não será executado nenhuma vez.

Outra coisa muito importante de se notar é a condição a ser verificada.
Neste exemplo utilizamos a condição i <= 10, então os números vão correr de 0 – 10 (e 10 SERÁ mostrado!).
Isto é algo que pode causar algum problema. Se quiser um valor por exemplo de 0-9, existem duas maneiras de conseguir:

1 – A condição ser  i <= 9
2 – A condição ser i < 10 (aqui o i não chega ao 10, pois a condição é ser MENOR que 10)

Nas duas condições acima, quando i chegar ao valor de 9, o laço deixa de executar.

Os dois comandos explicados acima (repita … ate e enquanto … faca) tem uma característica muito importante em comum:

NÃO ESQUEÇA DE COLOCAR UM CONTADOR (ÍNDICE) SENDO INCREMENTADO DENTRO DO BLOCO DE REPETIÇÃO, PARA ATINGIR A CONDIÇÃO!

Isso significa que se você não colocar um incremento no seu índice (como i <- i + 1), seu bloco será repetido infinitamente (loop infinito), e seu programa ficará “travado” (na verdade, ele está executando as instruções, porém como a parada nunca chega, ele não para ;) )

O comando para … faca

Este é um pouco diferente dos dois acima, pois ele não precisa de um índice sendo incrementado no corpo do laço.
O incremento é feito por ele mesmo, na mesma linha em que ele inicia.
Veja o exemplo:

algoritmo "ContaNumero"
// Função : Mostrar os números de 0 à 10
// Autor : Alex Giuliano Martins
// Data : 15/4/2012
// Seção de Declarações

var
i: inteiro //Declaração da nossa variável "i"

inicio
 para i de 0 ate 10 passo 1 faca //Início do laço que já impõe a condição, ou seja, i de 0 até 10.
  escreval("Número: ", i) //Escreve o valor que atualmente está na variável "i"
                          //Nesta primeira passagem, apresenta 0, pois foi atribuído acima,
                          //no início do laço.
 fimpara //Agora é necessário informar ao Visualg onde é o fim da estrutura de repetição,
         //para continuar a execução do programa na linha abaixo do bloco.
fimalgoritmo

Então aqui não há como entrar em loop infinito por falta de um incrementador.
Repare a existência do “passo 1″. Isso indica ao programa que ocorrerá o incremento em “i” de 1 em 1. Se fosse “passo 2″, o incremento seria de 2 em 2. E também é possível decremento dos passos sendo necessário apenas o sinal negativo (-) antes do número do passo (além, claro, da inversão da condição):

para i de 10 ate 0 passo -1 faca

Aqui o bloco será repetido com o valor de “i” iniciando em 10 e indo até 0.

Bem, pelas estruturas de repetição, estas são as principais informações. Não há segredo. Apenas basta lembrar-se:

- O repita … ate e o  enquanto … faca PRECISAM de um índice e um incremento DENTRO do bloco de repetição, para o programa não entrar em loop infinito.
- O repita … ate executa o código ao menos uma vez, pois a condição de parada é verificada apenas no final do bloco.
- O enquanto … faca pode não executar nenhuma vez, se a condição já for satisfeita logo no início. Além disso, ele PRECISA de uma indicação de onde termina o bloco: fimenquanto.
- O  para … faca executa o incremento logo na sua definição, não sendo necessário um incrementador interno, no bloco do código. Também precisa de uma instrução de término: fimpara.

Fica aqui um exemplo prático da vida cotidiana sobre loop infinito:

O diretor disse à secretária:

— Vamos viajar para o exterior por uma semana, para um Seminário. Faça os preparativos da viagem!

A secretária faz uma chamada para o marido:

— Vou viajar para o exterior com o diretor por uma semana. Se cuida, querido.

O marido liga para a amante:

— Minha mulher vai viajar para o exterior por uma semana, então nós vamos poder passar a semana juntos, meu docinho!

A amante liga para um menino a quem dá aulas particulares:

— Tenho muito trabalho, na próxima semana não precisa vir às aulas.

O menino liga para o seu avô:

— Vô, na próxima semana não tenho aulas, a minha professora estará ocupada. Vamos passar a semana juntos?

O avô (que é o diretor desta história) liga para a secretária:

— Vou passar a próxima semana com o meu neto, então não vou participar daquele Seminário. Pode cancelar a viagem.

A secretária liga para o marido:

— O diretor da empresa mudou de idéia e acabou cancelando a viagem.

O marido liga para a amante:

— Não poderemos passar a próxima semana juntos, a viagem da minha mulher foi cancelada.

A amante liga para o menino das aulas particulares:

— Mudança de planos: esta semana vamos ter aulas como normalmente.

O menino liga para o avô:

— Vô, a minha professora disse que esta semana tenho aulas. Desculpe-me, não vai dar para fazer-lhe companhia.

O avô liga para a sua secretária:

— Meu neto acabou de dizer que não vai poder ficar comigo essa semana. Continue com os preparativos da viagem ao seminário!

Por enquanto, é isso pessoal!