04 - Estruturas de Repetição

Prévia do material em texto

1 
 
Estruturas de Repetição 
 
4.1 Introdução 
 
Existem situações em que, para se obter a solução do problema, é necessário fazer com que um conjunto de 
instruções seja executado várias vezes. O objetivo aqui é apresentar e discutir estruturas (comandos) que 
possibilitem a execução de um conjunto de instruções várias vezes, com o programador escrevendo esse 
conjunto apenas uma vez. 
 
Suponha, por exemplo, que um determinado clube social tenha registrado a quantidade de latas de cerveja 
vendidas no último carnaval. Considerando que cada lata foi vendida a R$2,00, desejasse saber o total 
arrecadado no último carnaval, com a venda das latas de cerveja. Obviamente que, para esse problema, 
tem-se como entrada a quantidade de latas vendidas e deseja-se saber, como solução do problema (saída), 
qual o total arrecadado. Veja, a seguir, o respectivo algoritmo (algoritmo Clube-Social-1). 
 
Algoritmo Clube-Social-1 
 
Variáveis 
 Qtidade_Vendida : Inteiro 
 Valor-Arrecadado : Real 
 
Inicio 
 Leia Qtidade_Vendida 
 Valor Arrecadado  Qtidade_Vendida*2.0 
 Escreva Valor-Arrecadado 
Fim 
 
Veja que o problema apresentado, consiste em determinar-se c total arrecadado com a venda de latas de 
cerveja no último carnaval. Se desejarmos determinar o total arrecadado, em cada um dos últimos três 
carnavais, o algoritmo poderia ser.escrito conforme a seguir (algoritmo Clube-Social-2): 
 
Algoritmo Clube-Social-2 
 
Váriáveis 
 Qtidade_Vendida : Inteiro 
 Valor_Arrecadado : Real 
 
Inicio 
 Leia Qtidade_Vendida 
 Valor Arrecadado  Qtidade_Vendida*2.0 
 Escreva Valor_Arrecadado 
 Leia Qtidade_Vendida 
 Valor Arrecadado  Qtidade_Vendida*2.00 
 Escreva Valor_Arrecadado 
 Leia Qtidade_Vendida 
 Valor Arrecadado  Qtidade_Vendida*2.00 
 Escreva Valor Arrecadado 
Fim 
 
Observe no algoritmo Clube-Social-2 que a solução do problema é a mesma para cada ano. Assim, as 
2 
 
instruções para cada um dos anos, podem ser as mesmas. Observe também que, se quiséssemos 
determinar o total arrecadado em cada um dos últimos trinta anos, usando a mesma metodologia, teríamos 
que escrever trinta vezes o mesmo conjunto de instruções, o que obviamente se tornaria i mpraticável. 
 
Considerando que, para cada um dos casos, as instruções a serem executadas são as mesmas, é muito mais 
adequado que se escreva o conjunto de instruções apenas uma vez, e que se instrua o computador para 
que repita a execução das instruções um determinado número de vezes. 
 
4.2 Comando Enquanto-Faça 
 
Uma das formas de fazermos com que um conjunto de instruções seja executado várias vezes é utilizando o 
comando Enquanto-Faça. Para analisar sua forma e funcionamento, vamos considerar o seguinte problema: 
 
"Escrever um algoritmo que, a partir do saldo bancário da conta de um cliente, imprima a mensagem Conta 
Estourada, se o saldo for negativo, e a mensagem Conta Normal, se o saldo não for negativo". 
 
Pela definição do problema, podemos considerar que se tem como entradas o número da conta e o valor do 
saldo bancário do cliente e, como saída, uma mensagem dizendo se a conta tem ou não saldo negativo. O 
algoritmo para o problema pode ser escrito como segue (algoritmo Banco_1): 
 
Algoritmo Banco_1 
 
Variáveis 
 Saldo : Real 
 Numero_conta : Inteiro 
 
Inicio 
 Leia Numero_conta, Saldo 
 Se Saldo < 0 Então 
 Escreva Numero-conta, 'Conta Estourada' 
 Senão 
 Escreva Numero-conta, 'Conta Normal' 
 Fim Se 
Fim 
 
Veja que o algoritmo Banco_1 resolve o problema considerando a existência de uma única conta. Se 
quisermos considerar a existência de várias contas, o que é a situação mais comum, e para a qual faz muito 
mais sentido a utilização de uma máquina para a sua resolução, teremos que fazer com que as instruções, 
que resolvem o problema para a conta de um cliente, sejam repetidas várias vezes. Para isso, faz-se 
necessário um comando que, ao ser executado faça que determinado grupo de instruções seja repetido 
várias vezes. 
 
Conforme já colocado, o comando Enquanto-Faça tem essa função e sua forma geral pode ser escrita como 
segue. 
 
Enquanto expressão lógica Faça 
Conjunto de instruções 
Fim Enquanto 
 
Assim como a estrutura de seleção Se tem por base uma expressão lógica, também a estrutura de repetição 
3 
 
Enquanto-Faça apresenta uma expressão lógica. O Enquanto-Faça faz com que o conjunto de instruções 
colocado em seu interior seja repetido enquanto o valor da expressão lógica for verdadeiro. Sempre que o 
fluxo de execução chegar no Enquanto, será calculado o valor da expressão lógica. Se esta apresentar o 
valor verdadeiro, então o fluxo de execução passará para a execução das instruções internas ao Enquanto, 
na ordem em que aparecem. Ao encontrar o Fim Enquanto, o fluxo de execução retornará ao Enquanto e 
será novamente avaliada a expressão lógica. Se esta tiver o valor verdadeiro, as instruções internas ao 
Enquanto serão novamente executadas. Se, quando o fluxo de execução chegar ao Enquanto, a expressão 
lógica apresentar o valor falso, então o fluxo será transferido para a execução da primeira instrução após o 
Fim Enquanto. 
 
Com isto, podemos concluir que em algum momento do processo de repetição das instruções internas ao 
Enquanto será necessário que a expressão lógica assuma o valor falso, pois do contrário, o fluxo jamais sairá 
do Enquanto, e o conjunto de instruções será repetido infinitas vezes. 
 
Voltando ao nosso problema de análise do saldo bancário, se quisermos um algoritmo que faça a análise 
para dez contas, podemos escrever a solução conforme a apresentada pelo algoritmo Banco-2. 
 
Algoritmo Banco_2 
 
Variáveis 
 Saldo : Real 
 Numero_conta, Contador : Inteiro 
 
Inicio 
 Contador  0 
 Enquanto Contador < 10 Faça 
 Contador  Contador + 1 
 Leia Numero_conta, saldo 
 Se Saldo < 0 Então 
 Escreva Numero_conta, 'Conta Estourada' 
 Senão 
 Escreva Numero_conta, 'Conta Normal' 
 Fim Se 
 Fim Enquanto 
Fim 
 
Observe que, no algoritmo Banco_2, utilizamos a variável Contador, que inicialmente recebe o valor zero. 
Na primeira vez que o fluxo de execução chega ao Enquanto, a expressão lógica, Contador < 10 tem o valor 
verdadeiro. Assim, são executados todos os comandos internos ao Enquanto. Observe também que, no 
conjunto de comandos internos ao Enquanto, colocamos o comando 
 
Contador  Contador + 1 
 
o qual fará com que o conteúdo da variável Contador seja incrementado de uma unidade toda vez que for 
executado. Assim, a cada vez que for executado o conjunto de instruções que estiver dentro do Enquanto, 
Contador aumentará de uma unidade, até que chegue ao valor 10, quando então, ao retornar ao início do 
Enquanto, será verificado que a expressão lógica vale falso. Conforme seu funcionamento, se o valor da 
expressão lógica for falso, o fluxo de execução sairá automaticamente do Enquanto e passará para a 
execução da próxima instrução após o Fim Enquanto. 
 
No algoritmo Banco_2, todos os comandos colocados internamente ao comando Enquanto foram 
4 
 
deslocados em relação a coluna do Enquanto - Fim Enquanto. Conforme já vimos, esse processo denomina-
se identação e tem por objetivo facilitar a visualização e análise dos comandos que estão sendo repetidos. 
 
4.3 Repetição Controlada pelo Usuário 
 
Veja que o algoritmo Banco_2 resolve o problema para dez contas bancárias. Se quisermos processar 
duzentas contas, teremos que modificar o algoritmo, alterando a expressão lógica para Contador < 200. Os 
demais comandos ficariam exatamente iguais. Podemos evitar essa modificação escrevendoum algoritmo 
mais genérico, de forma que o usuário defina o número de vezes que deseja repetir o conjunto de 
instruções (nesse caso, o número de contas bancárias que deseja processar). O controle do número de 
repetições por parte do usuário só pode ser aplicado quando fizer sentido a intervenção do usuário. Esse 
controle, quando possível, pode ser feito das seguintes formas: 
a) Solicitação ao usuário do número de casos a processar; 
b) Uso de um valor finalizador; 
c) Solicitação de continuação a cada caso processado; 
d) Utilização de menus com opção de finalização. 
 
O algoritmo Banco_3 apresenta uma solução onde o usuário define o número de casos a processar. 
Observe que, antes de processar qualquer conta bancária, é solicitado para que o usuário entre com a 
quantidade de contas que deseja processar. Assim, enquanto o valor de Contador for menor que o valor 
informado pelo usuário (Quantcontas), o conjunto de instruções dentro do Enquanto será repetido. 
 
Algoritmo Banco_3 
 
Variáveis 
 Saldo, Soma : Real 
 Numero_conta, Contador, Quantcontas : Inteiro 
 
Inicio 
Contador  0 
Soma  0 
 Escreva 'Entre com a quantidade de contas: ' 
Leia Quantcontas 
 
Enquanto Contador < Quantcontas Faça 
Contador  Contador + 1 
Leia Numero_conta, Saldo 
Soma  Soma + Saldo 
Se Saldo < 0 Então 
Escreva Numero_conta, 'Conta Estourada' 
Senão 
Escreva Numero_conta, 'Conta Normal' 
Fim Se 
Fim Enquanto 
Escreva 'Soma dos saldos: ', Soma 
Fim 
 
O algoritmo Banco_3, além de analisar cada uma das contas, também calcula a soma dos saldos das contas. 
Para tanto, é utilizada a variável Soma, que inicialmente recebe o valor zero e que, a cada conta processada, 
acumula (acrescenta) o valor do saldo da conta. Isto acontece toda vez que for executado o comando: 
5 
 
 
Soma  Soma + Saldo 
 
Outra forma em que o usuário controla o número de casos a processar consiste na utilização de um valor 
finalizador para alguma variável de entrada. O valor finalizador deve ser um valor absurdo, ou seja, um valor 
que não faça sentido como dado de entrada. Por exemplo, se a variável de entrada for a idade de uma 
pessoa, pode-se perfeitamente utilizar qualquer valor negativo como valor finalizador. Não faz sentido que 
alguém tenha idade menor que zero. No algoritmo Banco_4 a seguir, o controle do número de contas a 
processar é feito através de um valor absurdo para o número da conta. 
 
Algoritmo Banco_4 
 
Variáveis 
 Saldo, Soma : Real 
 Numero_Conta : Inteiro 
 
Inicio 
 Soma  0 
Escreva 'Entre com numero da conta. Digite um valor negativo para terminar' 
Leia Numero_Conta 
 
Enquanto Numero_Conta >= 0 Faça 
Escreva 'Digite valor do saldo da conta', Numero-Conta 
Leia Saldo 
Soma  Soma + Saldo 
Se Saldo < 0 Então 
Escreva Numero_conta, 'Conta Estourada' 
Senão 
Escreva Numero_conta, 'Conta Normal' 
Fim Se 
 
Escreva 'Digite o numero da conta (valor negativo se quiser terminar)' 
Leia Numero-conta 
Fim Enquanto 
Escreva 'Soma dos saldos:', Soma 
Fim 
 
Pelo especificado no algoritmo Banco_4, antes de entrar no Enquanto é solicitado que o usuário entre com 
o número da conta. O algoritmo informa ao usuário para entrar com um número de conta menor que zero, 
caso queira encerrar o processamento das contas. Da mesma forma, após o processamento de cada conta e 
antes de voltar ao Enquanto, também é solicitado que o usuário entre com o número de nova conta, 
devendo entrar com número negativo caso queira encerrar. Observe que a colocação de um comando de 
entrada antes do Enquanto, para ler o número da conta, foi necessária em função de que a expressão lógica 
do Enquanto usa o valor do número de conta. O valor a ser usado como finalizador deve ser um valor 
absurdo, e do mesmo tipo da variável de entrada. 
 
O controle do número de vezes que se deseja repetir determinado conjunto de instruções, especialmente 
quando tem-se a repetição do processamento envolvendo pelo menos uma entrada, também pode ser feito 
fazendo-se com que, após o processamento da entrada, seja solicitado do usuário uma confirmação de 
continuação ou não. Dependendo do caso, especialmente em situações que envolvem a entrada de uma 
grande quantidade de dados, essa forma pode tornar-se cansativa. O algoritmo Banco_5 utiliza essa técnica. 
 
Algoritmo Banco_5 
 
Variáveis 
Saldo, Soma : Real 
Numero_conta : Inteiro 
Resposta : Literal 
6 
 
 
Inicio 
 
Soma  0 
Resposta  'Sim' 
Enquanto Resposta = 'Sim' Faça 
Leia Numero_conta, Saldo 
Soma  Soma + Saldo 
Se Saldo < 0 Então 
Escreva Numero-conta, 'Conta Estourada' 
Senão 
Escreva Numero-conta, 'Conta Normal' 
Fim Se 
Escreva 'Processar outra conta (Sim/Nao)?' 
Leia Resposta 
Fim Enquanto 
Escreva 'Soma dos saldos:', Soma 
Fim 
 
Observe, no algoritmo Banco_5, que a cada conta processada, e antes de retornar ao Enquanto, o algoritmo 
faz com que seja solicitado ao usuário que informe se deseja continuar ou não. A resposta fornecida pelo 
usuário será armazenada na variável Resposta. Ao encontrar o Fim Enquanto, o fluxo de execução retornará 
ao Enquanto e será calculado o valor da expressão lógica Resposta = 'Sim', o qual definirá se uma nova 
conta deve -ser processada ou se o processo de repetição será finalizado. 
 
O algoritmo Menu, apresentado a seguir, resolve o problema de efetuar uma operação aritmética 
envolvendo dois valores. Além dos dois valores, o usuário também define que operação aritmética deve ser 
realizada. Veja que o número de casos a processar está sob o controle do usuário. Quando o usuário 
escolher a opção 'F' para Operação, a expressão lógica do Enquanto terá o valor falso e o processo de 
repetição será encerrado. 
 
Algoritmo Menu 
 
Variáveis 
a, b, resultado : Real 
Chave : Lógico 
Operacao : Literal 
 
Inicio 
Chave  verdadeiro 
Enquanto chave Faça 
Escreva 'Entre com o primeiro valor :' 
Leia a 
Escreva 'Entre com o segundo valor :' 
Leia b 
Escreva 'Escolha uma das opções ' 
Escreva '+ Somar os dois valores' 
Escreva '- Subtrair o segundo valor do primeiro valor' 
Escreva '* Multiplicar os dois valores' 
Escreva '/ Dividir o primeiro valor pelo segundo valor' 
Escreva 'F' Para cancelar e finalizar' 
Leia Operacao 
Escolha Operacao 
'+': Resultado  a + b 
7 
 
Escreva 'A soma e:', Resultado 
'-': Resultado  a - b 
Escreva 'A diferença e:', Resultado 
 '*': Resultado  a * b 
Escreva 'O produto e:', Resultado 
'/': Resultado  a / b 
Escreva 'O quociente e:', Resultado 
'F': Chave  falso 
Senão 
Escreva 'Entrada inválida' 
Fim Escolha 
Fim Enquanto 
Fim 
 
Uma outra forma de fazermos com que um conjunto de instruções seja executado uma ou mais 
vezes, é usando o comando Repita. Sua forma geral pode ser colocada como: 
Repita 
Comando 1 
Comando 2 
 ... 
 Comando n 
Até expressão lógica 
Quando o fluxo de execução chegar ao Repita, automaticamente serão executados os comandos 
internos ao Repita (comandos 1 a n). Quando o fluxo de execução chegar no Até, será avaliada a 
expressão lógica. Se a expressão lógica valer falso, então o fluxo de execução retornará ao início do 
Repita e os comandos internos serão novamente executados. Quando o fluxo de execução chegar 
no Até e a expressão lógica apresentar o valor verdadeiro, então a execução sairá do Repita e 
passará para a primeira instrução imediatamente após o Até. 
 
Veja que, diferentemente do Enquanto, o comando Repita avalia a expressão lógica no final e, 
portanto, o conjunto de instruções a ser repetido é executado pelo menos uma vez. 
 
O algoritmo MelhorAluno utiliza o Repita para determinar o melhor aluno deuma turma de alunos. 
 
Algoritmo MelhorAluno 
 
Variáveis 
Nota, Max, Quant, Contador :Inteiro 
Nome, Melhor : Literal 
 
Inicio 
Escreva 'Entre com a quantidade de alunos' 
Leia Quant 
 Max  -1 
Contador  0 
Repita 
Escreva 'Entre com o nome do aluno' 
Leia Nome 
Repita 
Escreva 'Digite a nota do aluno (valor de 0 a 10) 
Leia Nota 
8 
 
Até (Nota >= 0) E (Nota <= 10) 
Se Nota > Max Então 
Max  Nota 
Melhor  Nome 
Fim Se 
 
Contador  Contador + 1 
Até Contador = Quant 
Escreva 'Melhor aluno: ', Melhor 
Fim 
 
No algoritmo MelhorAluno, a cada vez que for executado o conjunto de instruções internas ao 
primeiro comando Repita, um aluno é processado. Ou seja, é solicitado o nome e a nota do aluno. 
Cada nota de um aluno é comparada com o conteúdo da variável Max. Se o conteúdo de Nota for 
maior que Max, então conclui-se que essa nota é a maior entre as que já foram processadas e, 
portanto, o conteúdo de Max deve ser alterado para o valor dessa nota. Como o algoritmo se 
propõe a determinar também qual o nome do melhor aluno, então toda vez que for encontrada 
uma nota maior que o conteúdo de Max, o nome do aluno que obteve essa nota é salvo na variável 
Melhor. Veja que, a cada aluno processado, o conteúdo da variável Contador é incrementado de 
uma unidade. Dessa forma, em algum momento do processo de repetição, a expressão lógica 
Contador = Quant assumirá o valor verdadeiro, fazendo com que a repetição seja encerrada. 
 
Ainda no algoritmo Melhor Aluno, o segundo comando Repita faz com que o valor lido para nota do 
aluno esteja no intervalo de 0 a 10. Veja que esse Repita só será encerrado se a expressão (Nota >= 
0) E (Nota <= 10) tiver o valor verdadeiro. Sempre que essa expressão for avaliada e apresentar o 
valor falso, o fluxo de execução retornará ao respectivo Repita (segundo comando repita) e será 
solicitado que o usuário digite novamente a nota. O segundo comando Repita só será encerrado 
quando o usuário entrar com um valor válido para nota. 
 
4.5 Comando Para-Faça 
Em muitas situações, o processo de repetição de um grupo de comandos é controlado por algum tipo de 
contador. Ou seja, uma variável que funciona como um contador vai assumindo os valores 1, 2, 3 e assim 
por diante, até que atinja determinado valor, quando, então, a repetição deve ser encerrada. 
 
Assim, considerando esses casos, podemos definir um comando de repetição mais simples, que faça com 
que uma determinada variável vá assumindo automaticamente valores seqüenciais, e que quando atingir 
determinado valor, o processo de repetição seja encerrado. Denominaremos esse comando de Para-Faça 
e sua forma geral pode ser escrita como: 
 
Para Variavel_controle de Vinicial Até Vfinal , Passo Vp Faça 
Bloco de comandos a serem repetidos 
Fim Para 
 
Onde: Variável_controle representa uma variável que controlará o processo de repetição. V inicial consiste no 
valor inicial que deverá ser assumido pela variável de controle. Similarmente, V final constitui-se no valor final 
da variável de controle e, Vp representa qual o incremento que deve ser sofrido pela variável de controle, a 
cada vez que forem executados os comandos internos ao Para-Faça. Consideraremos que os valores inicial e 
9 
 
final, bem como o valor do passo, devem ser do mesmo tipo da variável de controle. Assumiremos também 
que, quando o incremento da variável de controle for 1, este não necessita ser especificado. O algoritmo 
Balanco, usando um comando Para-Faça, determina qual o total arrecadado por um clube ao final de um 
ano. 
 
Algoritmo Balanco 
 
Variáveis 
Mes : Inteiro 
Soma, Receita, Despesa : Real 
 
Inicio 
Soma  0 
Para Mes de 1 Até 12 Faça 
Escreva 'digite receita e despesa do mês', Mes 
Leia Receita, Despesa 
Soma  Soma + Receita - Despesa 
Fim Para 
Escreva 'Total arrecadado durante o ano :', Soma 
Fim 
No algoritmo Balanco, a variável de controle do Para-Faça é Mes. A variável Mes, conforme especifica o 
comando Para-Faça, assume os valores inteiros que vão de 1 até 12. Para cada valor de Mes, as instruções 
internas ao Para-Faça são executadas. Veja que, como não foi especificado o valor do incremento, estamos 
assumindo que o mesmo vale 1. 
Vamos assumir também que, ao chegar no Para-Faça a primeira vez, será calculado automaticamente o 
número de vezes que as instruções internas ao Para-Faça serão executadas. A determinação do número de 
repetições é feita usando-se os valores inicial e final, combinados com o valor do incremento para a variável 
de controle. Com isso, estamos assumindo também que não será possível abandonar a repetição das 
instruções, antes que o número de repetições seja alcançado. Assim, o comando Para-Faça só pode ser 
utilizado quando soubermos o número de vezes que se quer repetir o grupo de comandos.