ESTRUTURA DE REPETIÇÃO (LOOPING) REPITA... ATE

O laço de repetição Repita... ate é um tipo de laço condicional pós-teste, uma vez que executa uma condição somente após executar tudo aquilo que se pretende repetir dentro do laço, sua finalidade é a mesma que a do enquanto, sendo esta a de poupar linhas de código na escrita de códigos repetitivos.

Mesmo assim são várias as diferenças entre o Enquanto e o Repita, sendo algumas delas:

• O fato de que enquanto um é condicional pré-teste o outro é pós-teste;
• A condição empregado num laço enquanto é sempre contrária à que executa o mesmo número de repetições num laço Repita (onde, o contrário de maior é menor ou igual; o contrário de menor é maior ou igual; e o de igual é diferente);
• No laço Enquanto as instruções são repetidas enquanto a condição é verdadeira, interrompendo-se o laço somente quando esta se tornar falsa, enquanto que no Repita as instruções são executadas enquanto a condição permanece falsa, interrompendo-se somente no momento em que esta se torne verdadeira;
• Num algoritmo que faça uso do laço Enquanto o programa pode terminar sua execução sem ter executado as instruções do laço nenhuma vez (caso a condição não chegue a ser verdadeira de início, quando se chega no Enquanto), o que é impossível num laço Repita que irá executar as instruções pelo menos uma vez e sendo a condição verdadeira terá fim, caso contrário também será encerrado.

Por fim, pode-se dizer que o Repita é em quase tudo o contrário do Enquanto, podendo ser muito bem empregado quando queremos por exemplo, forçar o usuário a digitar um conjunto exclusivo de dados.

No laço repita fazemos uso de uma variável que exercerá a função de contador, sendo responsável portanto, por controlar o laço de repetição contando quantas vezes este está sendo executado, e o laço irá executar as devidas instruções até que a condição que rege o laço se torne verdadeira (seja alcançada, em geral pelo contador), assim como no enquanto é importante garantir que a condição será alcançada em algum momento para que não seja criado um loop infinito (o que é um dos mais comuns erros ao se trabalhar com laços de repetição).

1. EXEMPLO 1

Criar um programa que leia um número de 0 até 10 e imprima a sua tabuada na tela.

algoritmo "TABUADA_PÓS-TESTE" //Nome do meu programa
// Função :
// Autor :
// Data : 01/05/2011
// Seção de Declarações
var
CONT: INTEIRO //Declaração da veriável contadora geralmente inteira
X, R: REAL //Declaração das variáveis que usarei no programa
inicio
CONT <- 0  //Inicialização do meu contador em 0, assim minha tabuada começará em 0
REPITA //Estrutura que inicia meu loop que irá garantir que só serão digitados números de 0 até 10
ESCREVAL ("INFORME O NÚMERO DA TABUADA QUE DESEJA CONSULTAR.")
LEIA (X)
ATE (X > -1) E (X < 11) //Finalização do meu loop com a devida condição
ESCREVAL (" ") //Linha que pulei entre a leitura do número e a tabuada
ESCREVAL ("A TABUADA DO",X," É:")
REPITA //Estrutura que inicia meu looping
R<-X*CONT //Multiplicação do número digitado pelo usuário pelo contador que crescerá de um em um, sendo X vezes 1, X vezes 2, ...
ESCREVAL (X," X ",CONT," = ",R) //Grafia da forma tradicional de tabuada
CONT <- CONT + 1 //Encremento que fará meu contador crescer de um em um contando graças a isso quantas vezes ele realizou a instrução entre o Repita e o Ate
ATE (CONT > 10)//Estrutura que encerra o meu looping e que realiza a verificação póstuma da condição, onde caso o contador seja maior que 10 o programa será encerrado e sendo manor ou igual, este repetirá o que vai logo acima
fimalgoritmo