Repetição com teste no início

A repetição com teste no início consiste em uma estrutura de controle do fluxo de execução que permite diversas vezes um mesmo trecho do algoritmo, porém, sempre verificando antes de cada execução se a condição de repetição foi alcançada, permitindo, desta maneira, nova execução do trecho.

Para se realizar tal repetição, utiliza-se a estrutura enquanto, que permite que um bloco ou uma ação primitiva seja repetida enquanto determinada <condição> for verdadeira. O modelo genérico desse tipo de repetição se apresenta a seguir.

enquanto <condição> faça C1; C2; . . . Cn; fimenquanto;

Quando o resultado da <condição> for falso, o comando de repetição é abandonado. Se a mesma for falsa já na primeira passada, os comandos não serão executados nenhuma vez, o que se apresenta como a característica principal desse modelo de repetição.

Exemplo

Para se inserir no cálculo da média dos alunos (algoritmo 5) um laço ou looping utilizando a estrutura enquanto, que estrutura poder-se-ia utilizar?

A condição seria que a quantidade de médias calculadas fosse menor ou igual ao número de alunos que se deseja calculá-la (por exemplo, 40). No entanto, o que indica quantas vezes a média foi calculada? A estrutura enquanto não oferece um recurso que permita saber quantas vezes ela foi calculada. Logo, deve-se refletir sobre uma maneira de contagem, o qual pode ser feito a partir de um contador, o qual é representado por uma variável com um determinado valor inicial cujo valor é incrementado8 _{a cada repetição. A}

seguir apresenta-se um exemplo de contador:

8 _{Incrementar significa somar um valor normalmente constante.}

Exemplo (contador)

1. inteiro: contador; // declaração da variável contador

2. contador ← 0; // atribui à variável contador o valor zero como valor inicial

3. contador ← contador + 1; // incrementa o contador de 1

O processo de contagem ou de incremento do contador começa na linha 3, através da expressão aritmética que incrementa à variável contador o valor 1, armazenando este resultado na própria variável contador. Repetindo-se este comando várias vezes, percebe-se que a variável vai aumentado gradativamente de 1 (de 1 em 1), simulando o que se necessita, ou seja, uma contagem de execuções realizadas.

Aplicando-se estes conceitos no algoritmo 5, tem-se:

Algoritmo 8 – Média Aritmética para 40 alunos – Fonte: Forbellone e Eberspächer (2005).

1. início // começo do algoritmo 2. // declaração de variáveis

3. real: N1, N2, N3, N4, // notas bimestrais 4. MA; // média anual

5. inteiro: contador; // contador

6. contador ← 0; // inicialização do contador

7. enquanto (contador < 40) faça // teste de condição de parada 8. leia (N1, N2, N3, N4); // entrada de dados

9. MA ← (N1 + N2 + N3 + N4) / 4; // processamento – cálculo da média 10. escreva (“Média Anual = “, MA); // saída de dados

11. se (MA >= 7,5) 12. então

13. início // bloco verdadeiro

14. escreva (“Aluno Aprovado”); // saída de dados

15. escreva (“Parabéns pela aplicação!”) // saída de dados 16. fim;

17. senão

18. início // bloco falso

19. escreva (“Aluno Reprovado”); // saída de dados

20. escreva (“Você precisa se dedicar mais!”); //saída de dados 21. fim;

22. fimse;

23. contador ← contador + 1; // incrementar o contador em 1 24. fimenquanto;

25. fim. // termino do algoritmo

Cabe salientar que o contador iniciou com o valor 0 antes do looping, e que a cada interação foi incrementado em 1. Pode-se fazer uma variação do algoritmo 8 tentando-se calcular a média geral da turma, calculada com a média aritmética das 40 médias anuais, utilizando-se a seguinte expressão aritmética:

(M1 + M2 + M3 + M4 ...+ M39 + M40)/40

o que se torna inviável. Pode-se utilizar as vantagens da estrutura de repetição fazendo um looping que a cada execução acumule o valor, conceitualmente

chamada de acumulador, de cada aluno. Após o término da repetição, tem-se a soma da média de todos os alunos na variável de acumulação, restando apenas dividí-la pelas médias somadas (40).

Exemplo (acumulador)

1. inteiro: acum, // declaração da variável acumulador

2. X; // declaração de uma variável numérica qualquer

2. acum ← 0; // atribui à variável acumulador o valor zero como valor inicial

3. acum ← acumulador + X; // acumula em acumulador o valor anterior mais o valor de x

O processo de acumulação se assemelha muito ao processo realizado pelo contador. A única diferença é que na acumulação o valor adicionado pode variar de acordo com o valor a ser acrescentado, enquanto no contador o valor adicionado é constante. Uma solução para o algoritmo 8 levando-se em conta a média aritmética da turma seria:

Algoritmo 9 – Média Aritmética Anual para 40 alunos – Fonte: Forbellone e Eberspächer (2005). 1. início // começo do algoritmo

2. // declaração de variáveis 3. real: MA, // média anual

4. acm, MAT; // acumulador e média anual da turma 5. inteiro: contador; // contador

6. contador ← 0; // inicialização do contador 7. acm ← 0; // inicialização do acumulador

8. enquanto (contador < 40) faça // teste de condição de parada 9. leia (MA); // entrada de dados

10. acm ← acm + MA; // soma em acm dos valores de MA 11. contador ← contador + 1; // incrementar o contador em 1 12. fimenquanto;

13. MAT ← acm/50; // cálculo da média anual da turma 14. escreva (“Média anual da turma = “, MAT);

15. fim. // termino do algoritmo

O algoritmo 9 utiliza um pré-conhecimento da quantidade de alunos. E se não se tivesse o conhecimento deste número? Como faríamos para controlar o looping? Necessita-se, nesta situação, de um looping que fosse executado por uma quantidade indeterminada de vezes. Logo, necessita-se de outro critério de parada, que possibilite ao looping um fim após a última média anual (independente de quantas sejam) ter sido informada. Pode-se resolver este problema utilizando um valor predefinido como finalizador, a ser informado após a última média.

Para se aplicar tal conceito ao algoritmo da média geral da turma, usa-se como finalizador o valor -1 que, quando encontrado, encerra o looping sem ter seu valor computador ao acumulador.

Algoritmo 10 – Média Aritmética Anual com finalizador – Fonte: Forbellone e Eberspächer (2005). 1. início // começo do algoritmo

2. // declaração de variáveis

3. real: MA, // média anual de um aluno dado

4. acm, MAT; // acumulador e média anual da turma 5. inteiro: contador; // contador

6. contador ← 0; // inicialização do contador 7. acm ← 0; // inicialização do acumulador 8. MA ← 0; // inicialização da variável de leitura

9. enquanto (MA <> -1) faça // teste de condição de parada 10. leia (MA); // entrada de dados

11. se (MA <> -1) então // evita acumulação do finlizador 12. início

13. acm ← acm + MA; // acumula em acm os valores de MA lidos

14. contador ← contador + 1; // contagem do número de médias fornecidas 15. fim;

16. fimse; 17. fimenquanto;

18. se (contador > 0) // houve pelo menos uma exceção 19. então

20. início

21. MAT ← acm/contador; // cálculo da média anual da turma 22. escreva (“Média anual da turma = “, MAT);

23. fim; 24. senão

25. escreva (“Nenhuma média válida fornecida”); 26. fimse;

27. fim. // termino do algoritmo