Estruturas de Repetição usando o Visualg

CONTEUDO ELABORADO EXCLUSIVAMENTE COM O AUXILIO DA BIBLIOTECA GOOGLE..

Saudações caros amigos, após a elaboração do primeiro tutorial venho até aqui compartilhar este novo manual.

Neste tutorial veremos os comandos de repetição.

INÍCIO

As estruturas de repetição executam varias vezes uma determinada parte de um código, até que a 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 uma variavel 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 comando 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 numeros de 0 ah 9

var

i: inteiro // Declara a nossa variavel "i"

inicio

i <- 0 //Nossa variavel é inicializada recebendo o valor 0!

repita //Início do comando de repetiçã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 mostra que:

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 numeros de 0 ah 9

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:

// Função : Mostrar os numeros de 0 ah 9

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.