ESTRUTURA DE REPETIÇÃO (LOOP) ENQUANTO

Existem situações em que é necessário efetuar a repetição de um trecho de programa um determinado número de vezes. Nesse caso, poderá ser criado um looping que efetue o processamento de um determinado trecho, tantas vezes quantas forem necessárias. Os loopings também são chamados de laços de repetição ou malhas de repetição.

Um exemplo de estrutura de repetição é o ENQUANTO. Nela o nosso programa irá repetir determinado trecho de códigos enquanto algo estiver acontecendo, ou seja, enquanto uma determinada condição for verdadeira, parando a repetição assim que a condição se torna falsa.

Ela é uma estrutura de repetição condicional pré-teste, pois faz uso de uma condição que determina a continuidade ou não do looping, e que se encontra antes do trecho de código a ser executado (verifica condição primeiro e depois executa).

No entanto o enquanto é uma estrutura que por ser condicional precisa ser limitada (deve ter um início e um fim) caso contrário acaba gerando uma repetição infinita. Para isso é necessário o uso de uma variável que exerça a função de CONTROLE ou CONTADOR, ou seja, ela deverá controlar o meu laço de repetição contando quantas vezes eu já realizai determinada instrução. Em geral costuma-se usar o I como contador (prática empregada pela maioria dos programadores), no entanto qualquer variável pode exercer essa função. Veja a estrutura do Enquanto: 

 

 1. EXEMPLO 1

Elaborar um programa que realiza a leitura de um número qualquer e mostre a tabuada deste número.

algoritmo "TABUADA_PRE-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
ESCREVAL ("INFORME O NÚMERO DA TABUADA QUE DESEJA CONSULTAR.")
LEIA (X)
ESCREVAL (" ") //Linha que pulei entre a leitura do número e a tabuada
ESCREVAL ("A TABUADA DO",X," É:")
ENQUANTO (CONT <= 10) FACA //Estrutura que inicia meu looping e que realiza a verificação prévia da condição, onde enquanto o contador for menor ou igual a 10 o programa repetirá o que vai abaixo
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 enquanto e o fimenquanto
FIMENQUANTO //Estrutura que encerra o meu looping levando-o de volta para o enquanto
fimalgoritmo 

 

2. EXEMPLO 2

Elaborar um programa que leia dois valores inteiros e efetue a soma do menor para o maior dos números que se encontram entre eles: por exemplo: sendo informados os valores 1 e 10 o programa fará:

1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 = 55

ALGORITMO "SOMAR DO MENOR PARA O MAIOR DE UM EM UM" // Nome do meu programa
VAR
CONT, X, Y, S, V : INTEIRO

// Variáveis Contador, X e Y (Valores que serão digitados), Soma e Valor(que será o valor que estará sendo somado ao menor valor representando os números entre ele e o maior)
INICIO
CONT<-1  

//Contador iniciado em um para somar já de inicio este valor ao menor entre os valores digitados, visto que teremos de escrever o menor valor antes do meu loop
S<-0

// Soma iniciada em 0 para não ter influencia em nenhum valor somado à ela
ESCREVA("INFORME UM VALOR INTEIRO:")
LEIA (X) //Entrada de Dados
ESCREVA("INFORME UM OUTRO VALOR INTEIRO:")
LEIA (Y)//Entrada de Dados
SE (X>Y) ENTAO //Condição onde se X for maior que Y, Y é o menor e será atribuído à S para ser mostrado na tela e ser somado dos seus sucessores
   S<-Y   ESCREVA(Y," + ")  

//Impressão na tela do MENORVALOR + (o restante dos valores somados
   ENQUANTO (V<X-1) FACA //Estrutura de repetição, onde enquanto o valor que vem após o menor valor digitado for menor que o número que vem antes de X o programa executará o que vem abaixo disso e antes do FIMENQUANTO
      V<-Y+CONT //Sucessor, ou seja se Y começa valendo 2, o V valerá 3, 4, 5,... até o X
      S<-S+V //Soma que vai acrescendo sempre o valor de V, tendo começado valendo Y
      ESCREVA(V, " + ")

//Impressão na tela dos SUCESSORES_DE_Y +  (VALOR_DE_X)
      CONT<-CONT+1

//Processamento que faz meu contador crescer de um em um, sem isso meu loop é infinito
   FIMENQUANTO //Instrução que para o meu LOOP, mandando o de volta para o enquanto
   S<-S+X //Soma da soma de Y e todos os números menores que X e maiores que Y à X
   ESCREVA(X," = ",S) //Impressão na tela de X = SOMATOTAL
SENAO //Estrutura a ser executada caso Y seja maior ou igual a X
   SE (X=Y) ENTAO //Verificação para saber se X é igual a Y, se for os números serão somados e será mostrado o resultado.
      S<-X+Y
      ESCREVA (X," + ",Y," = ",S)
   SENAO //Estrutura a ser executada caso Y seja maior que X, onde Y será o menor valor e portanto será atribuído à S para ser mostrado na tela e ser somado dos seus sucessores
      S<-X
      ESCREVA(X," + ")
      ENQUANTO (V<Y-1) FACA //Estrutura de repetição, onde enquanto o valor que vem após o menor valor digitado for menor que o número que vem antes de Y o programa executará o que vem abaixo disso e antes do FIMENQUANTO
         V<-X+CONT //Sucessor, ou seja se X começa valendo 2, o V valerá 3, 4, 5,... até o Y
         S<-S+V  

//Soma que vai acrescendo sempre o valor de V, tendo começado valendo X
         ESCREVA(V, " + ") //Impressão na tela dos SUCESSORES_DE_Y +  (VALOR_DE_X)
         CONT<-CONT+1 //Processamento que faz meu contador crescer de um em um, sem isso meu loop é infinito
         FIMENQUANTO //Instrução que para o meu LOOP, mandando o de volta para o enquanto
      S<-S+Y //Soma da soma de X e todos os números menores que Y e maiores que X à Y
      ESCREVA(Y," = ",S) //Impressão na tela de X = SOMATOTAL
   FIMSE //Estrutura que finaliza a minha primeira condição
FIMSE//Estrutura que finaliza a minha segunda condição
FIMALGORITMO //Estrutura que finaliza o meu programa