Estruturas de Repetição

É muito comum a situação em que se precisa repetir certo trecho de um programa determinado número de vezes. Por exemplo, quando é preciso calcular a folha de pagamento de uma empresa, sendo que o mesmo cálculo é efetuado para cada um dos funcionários.

Essas estruturas de repetição são muitas vezes chamadas de Laços ou de Loops.

A classificação das estruturas de repetição é feita de acordo com o conhecimento ou não do número de vezes que os comandos serão executados. Então, os laços dividem-se em:

• laços contados: quando se sabe quantas vezes o comando composto deverá ser executado.
• laços condicionais: quando não se sabe o número de vezes que o conjunto de comandos no interior do laço será repetido.

Laços Contados

Os laços contados são bastante utilizados quando se conhece o número de vezes que se deseja executar um certo conjunto de comandos. Esse tipo de laço é uma estrutura dotada de mecanismos para contar o número de vezes que o comando composto em seu interior é executado.

Abaixo temos a sintaxe para os laços contados em português estruturado:

	Para <var> ate <número final> passo <incremento> <comando composto> Proximo

A semântica do laço contado é a seguinte: no início da execução da construção é atribuído um valor  a  variável  <var>. 

Se <var> for maior que o <número final>, então o comando composto não é executado e a execução do programa segue pelo primeiro comando seguinte a Proximo. Se <var> for menor que o <número final>, então o comando composto é executado e, ao final do mesmo, o valor de <var> é incrementado de 1, 2,..., n de acordo com o valor em <inc>.

Feito isso, é novamente feita a comparação entre <var> e <número final> e repete-se o processo até que <var> tenha um valor maior que <número final>.

Quando o laço é finalizado, a execução do algoritmo prossegue pela instrução imediatamente seguinte ao Proximo.

Como exemplo de uso do laço contado, tem-se um algoritmo para somar 30 vezes o mesmo número:

	variaveis numerico numero, soma, contador inicio soma = 0 Escrever “Este é um algoritmo para somar 30 vezes o mesmo número” Escrever “Número : ” Ler numero Para contador = 1 até 30 passo 1 soma = soma + numero Proximo Escrever “Soma : ”, soma fim Tutorial de aplicação do algoritmo

Já que o incremento da variável contador é de 1 na construção Para, então este trecho passo 1 poderia ser omitido.

Mais um exemplo de uso do laço contado, tem-se um algoritmo para realizar o decremento de 15 números (de 20 até 5) e efetuar a subtração do número 5 destes números.

	variaveis numerico sub, contador inicio sub = 0 Para contador = 20 até 5 passo -1 sub = contador - 5 Escrever “Subtraçao : ”, sub Proximo fim Tutorial de aplicação do algoritmo

Laços Condicionais

Laços condicionais são aqueles em que o conjunto de comandos em seu interior é executado enquanto uma determinada condição seja satisfeita. Nos laços condicionais, não se sabe quantas vezes o interior do laço será executado.

A construção que implementa o laço condicional em português estruturado é o faça enquanto e sua sintaxe é a seguinte:

	Faça enquanto <condição> <comando composto> Fim_enquanto

Sua semântica é a seguinte: ao início da construção Faça enquanto a condição é testada, se o seu resultado for falso, então o comando composto no seu interior não é executado e a execução segue normalmente pela instrução seguinte ao fim_enquanto.

Se a condição for verdadeira o comando composto é executado e, ao seu término, retorna-se ao teste da condição. Então, o processo continua enquanto a condição testada for verdadeira.

Abaixo, tem-se o fluxograma representando a construção do Faça_enquanto.

Aplicações

As aplicações nas estruturas de repetição, importantes em qualquer linguagem de programação, são:

• Contador;
• Acumulador;
• Flag.

A) Contador

É uma variável numérica qualquer, a qual recebe um valor inicial, e que é incrementada por um valor fixo, normalmente +1, a cada repetição.

Abaixo temos um exemplo, em que a variável x é um contador que conta de 1 até 20.

	variaveis numerico x inicio x = 0 faca enquanto x < 20 x = x +1 escrever x fim_enquanto fim Tutorial de aplicação do algoritmo

Nos dois exemplos de laços contados, usando o para/Proximo também foi utilizada esta técnica de contador. A variável que é o contador, nestes dois exemplos, foi chamada de contador, mas poderia ter outro nome como x, y ou z.

Note que a variável que é contador não precisa ser incrementada ou decrementada, o próprio comando para/Proximo realiza o incremento ou decremento.

B) Acumulador

É uma variável numérica qualquer, que recebe um valor inicial, e que é incrementada por um valor variável, a cada repetição.

Como exemplo, vamos calcular a média aritmética das notas de uma turma de 40 alunos, imprimindo primeiro as notas e sua soma, e depois a média.

	variaveis numerico x, acumul, nota, media inicio x = 0 acumul = 0 faca enquanto x < 40 x = x + 1 // x é o contador ler nota acumul = acumul + nota   //  acumula soma das notas escrever nota fim_enquanto media = acumul/40 escrever “A soma das notas é : ”, acumul escrever “A média da turma é : ”, media fim Tutorial de aplicação do algoritmo

Outro exemplo: Fazer um algoritmo para ler os salários de 500 funcionários de uma determinada empresa e contar quantos ganham menos de 5 salários mínimos e quantos ganham mais de 15 salários mínimos. Somar o total da folha de pagamento do mês.

	variaveis numerico salmin, salmin5, salmin15, x, total, salario inicio salmin5 = 0 salmin15 = 0 x = 0 total = 0 ler salmin para x = 1 ate  500 // o contador x conta funcionários ler salario // salario do funcionário total = total + salario // acumula o total da folha do mês se salario < 5*salmin entao salmin5 = salmin5 + 1 senao se salario > 15*salmin entao salmim15 = salmin15 + 1 fim_se fim_se Proximo // próximo funcionário escrever “Funcionários que ganham menos que 5 salários mínimos: ”, salmin5 escrever “Funcionários que ganham mais que 15 salários mínimos: ”, salmin15 escrever “O total da folha de pagamento é: ”, total fim Tutorial de aplicação do algoritmo

C) Flag

Flag é um dado falso, usado quando não se sabe o número total de determinada variável. Serve para condição de fim.

Por exemplo, para calcular a média de idades de uma turma de alunos, e não se sabe quantos alunos. Na lista de idades, vamos acrescentar a idade falsa (flag) de 99 anos.

	variaveis numerico contador, soma, idade, media inicio contador = 0 soma = 0 ler idade // idade do 1° aluno faca enquanto idade < 99 contador = contador + 1 // conta o número de alunos soma = soma + idade // acumula ler idade fim_enquanto media = soma / contador escrever “Numero de alunos é: ”, contador escrever “Média de idades é: ”, media fim Tutorial de aplicação do algoritmo

Note que no exemplo acima, temos as três aplicações sendo usadas. O contador (variável contador), o acumulador (variável soma) e o flag (idade falsa de 99 anos).

Aninhamentos

Um aninhamento é o fato de se ter qualquer um dos tipos de construção apresentados nesta unidade, dentro do conjunto de comandos de uma outra construção.

Em qualquer tipo de aninhamento é preciso que a construção interna esteja completamente embutida na construção externa.

Abaixo temos um exemplo de aninhamentos.

Síntese

As estruturas de controle do fluxo de execução são essenciais para que se possa alterar a seqüência de execução dos comandos de um programa em função dos dados do mesmo.

Um comando composto é um conjunto de comandos simples, sejam eles instruções primitivas ou instruções como as estudadas nesta unidade.

Uma estrutura seqüencial é aquela em que os comandos vão sendo executados numa seqüência preestabelecida, um após o outro.

As estruturas de decisão permitem escolher qual o caminho a ser seguido num algoritmo em função de uma ou mais condições. A instrução Se usa apenas uma condição, enquanto que a instrução Faça caso usa uma ou mais condições.

As estruturas de repetição são utilizadas quando se quer repetir um trecho de um algoritmo. Quando o número de vezes que o trecho será repetido é conhecido diz-se que o laço é do tipo contado (a construção usada é o Para). Quando este número não é conhecido e é função de certa condição, então temos os laços condicionais (a construção usada é o Faça enquanto).

Nas estruturas de repetição, temos três aplicações, a saber: contador, acumulador e flag.

Os aninhamentos podem usar qualquer uma das construções apresentadas, desde que a construção mais interna deva estar inteiramente contida na construção mais externa.