You are on page 1of 28

Capítulo 4

Comandos de Repetição

No mundo real, é comum a repetição de procedimentos para se realizar tarefas. Esses procedimentos não são repetidos eternamente, mas se encerram quando o objetivo é atingido. Por exemplo, quando uma pessoa aperta um parafuso, ela gira a chave de fenda uma vez, duas vezes etc. até que o parafuso esteja apertado o suficiente. Durante esse processo, é verificado, a cada volta, se o parafuso já está bem firme. Da mesma forma, podemos estruturar várias atividades diárias como repetitivas. Durante a chamada feita por um professor, por exemplo, ele chama os nomes enquanto não terminar a lista. Outras repetições podem ser quantificadas com antecedência. O aluno de castigo que precisa escrever 100 vezes no quadro negro: “Não vou fazer bagunça nunca mais”, executa a mesma instrução 100 vezes. Todas as repetições têm uma característica comum: o fato de haver uma verificação de condição que pode ser representada por um valor lógico, para determinar se a repetição prossegue ou não. Essa é a base para a implementação dos comandos de repetição em algoritmos. Em vez de fazermos um trabalho braçal, escrevendo a mesma instrução várias vezes, poderemos utilizar uma estrutura que indique que tal instrução será executada quantas vezes for necessária.

4.1 Comando enquanto
Antes de vermos a sintaxe em nosso pseudocódigo, vejamos um exemplo do mundo real: o problema do elevador. Um elevador residencial tem um comportamento que pode ser descrito de forma algorítmica. Vejamos o seu funcionamento: • Na subida: sobe cada andar, verificando se está em um andar selecionado dentro do elevador. Isso é feito até chegar ao andar mais alto selecionado dentro ou fora do elevador.

60

Capítulo 4 • Comandos de Repetição
enquanto não chegar ao andar mais alto selecionado interna/externamente faça início suba um andar, início

61

se o andar foi selecionado internamente então pare,

abra as portas, fim fim

feche as portas,

• Na descida: desce cada andar, verificando se está em um andar selecionado dentro ou fora do elevador. Isso é feito até chegar ao andar mais baixo selecionado dentro ou fora do elevador
enquanto não chegar ao andar mais baixo selecionado interna/externamente faça início desça um andar, se o andar foi selecionado interna/externamente então início pare, abra as portas, feche as portas, fim fim

O comando enquanto caracteriza-se por uma verificação de encerramento de atividades antes de se iniciar (ou reiniciar) a execução de seu bloco de instruções. Dessa forma, no algoritmo do elevador, antes de subir/descer um andar é verificado se o andar atual é o mais alto/baixo selecionado. Caso não seja, um conjunto de atividades é executado (sobe/desce um andar, verifica se é um andar selecionado e abre (ou não) as portas). Vejamos sua sintaxe:
enquanto <valor booleano> faça <continuação do algoritmo> <bloco de instruções>

Voltemos ao exemplo do aluno de castigo. Fazer um algoritmo que escrevesse para ele, cem vezes, “Não vou fazer mais bagunça”, antes deste capítulo, seria uma tarefa inglória. O algoritmo seria semelhante ao descrito a seguir. Algoritmo Lição_Aluno_Versão1
início escreva(“Não escreva(“Não escreva(“Não escreva(“Não ... fim vou vou vou vou fazer fazer fazer fazer mais mais mais mais bagunça!”); bagunça!”); bagunça!”); bagunça!”);

{ O comando precisa ser escrito 100 vezes... }

Algoritmo Soma_Média100 var contador: inteiro. Essa variável conterá o número de iterações já realizadas. { Nenhuma iteração foi feita até aqui } 1 2 3 enquanto (contador < 100) faça { O bloco será repetido 100 vezes } { Ainda não foi somado nenhum valor } . sendo atualizada a cada nova iteração. necessitaremos de uma variável que fará o papel de contador. Bem. escreva(“Não vou fazer mais bagunça!”). Uma estratégia muito comum para esse tipo de situação é acompanhar a execução das repetições contando cada vez que o bloco é executado. início valor.2 Problema 12 – Ler 100 números e calcular a soma e a média Faça um algoritmo que leia 100 números e retorne a soma e a média desses valores. precisaremos verificar. início { Nenhuma iteração foi feita até aqui } { O bloco será repetido 100 vezes } enquanto (contador < 100) faça fim fim contador  contador + 1. Cada execução do bloco de instruções é chamada iteração. de alguma forma. soma  0. se o comando já foi executado 100 vezes. Para que tenhamos a informação de quantas iterações já foram realizadas no laço. contador  0.1.1 Problema 11 – Escrever 100 vezes "Não vou fazer mais bagunça" Faça um algoritmo que escreva 100 vezes o texto: “Não vou fazer mais bagunça”. 4. Algoritmo Lição_Aluno_Versão2 var contador: inteiro.62 Algoritmos e Programação Para que possamos utilizar o comando de repetição. 4. enquanto <não foi executado 100 vezes o próximo bloco > faça escreva(“Não vou fazer mais bagunça!”). o problema reside em implementar essa verificação. { A cada iteração. utilizando um comando de repetição. O próprio comando de repetição em conjunto com seu bloco de instruções é conhecido como loop ou laço. início contador  0. soma.1. média: real. conta-se mais 1 } Vejamos a seguir outros exemplos.

é importante que o valor inicial da variável seja definido antes da entrada do laço. os valores que serão entrados pelo usuário serão 5. nesta seqüência). Tabela 4. somando-se seu valor atual com o novo valor lido. consideremos o laço até 3 e não até 100. para que um valor desconhecido não seja atribuído na primeira iteração do laço. 4. Vejamos o teste de mesa para a melhor compreensão do processo. soma  soma + valor.1). É interessante verificar o processo de acumulação de valores feito na variável soma (linha 6).Capítulo 4 • Comandos de Repetição início 63 4 5 6 7 fim escreva(“Entre com um valor: ”). soma). Para que isso funcione. 9 (ou seja. conta-se mais 1 } 8 9 10 fim escreva(“Soma: “. Seu valor é atualizado a cada iteração. Para viabilizar a realização do teste de mesa. { A cada iteração. Entrada: 5. contador  contador + 1. escreva(“Média: ”. 4 e 9. média). como está no algoritmo (Tabela 4.1 – Teste de mesa para Soma_Média100 Instrução 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 Linha contador valor soma média 1 0 ? ? ? 2 0 ? 0 ? 3 0 ? 0 ? 4 0 ? 0 ? 5 0 [5] 0 ? 6 0 5 5 ? 7 1 5 5 ? 3 1 5 5 ? 4 1 5 5 ? 5 1 [4] 5 ? 6 1 4 9 ? 7 2 4 9 ? 3 2 4 9 ? 4 2 4 9 ? 5 2 [9] 9 ? 6 2 9 18 ? 7 3 9 18 ? 3 8 9 10 3 3 3 3 9 9 9 9 18 18 {18} 18 ? 6 6 {6} . leia(valor). média  soma / contador.

leia(operando2). Exercício proposto 1. Esse teste é executado nas instruções 3. Porém. Em vez disso. após o bloco de instruções pertencente ao comando enquanto. . contador: inteiro. { A cada iteração. como fora definido. operando2. 3. a condição é falsa (no nosso teste. Para implementar esse algoritmo. 4.64 Algoritmos e Programação Note que a condição de entrada/saída do laço está na linha 3. a instrução a ser executada é a do início do bloco. Perceba também que o teste é repetido sempre após o bloco de instruções (linha 7) pertencente ao laço. soma-se um elemento com ele próprio o número de vezes do segundo elemento. Exercícios propostos 1.1. { Ainda não foi somado nenhum valor } { O bloco será repetido “operando2” vezes } resultado  resultado + operando1. utilize apenas o operador de adição “+”. 6 e 6. início escreva(“Entre com o segundo valor: ”). Adapte o algoritmo Soma_Média100 para que o número de valores a ser computado seja determinado a partir de uma variável de entrada e não como um valor fixo no programa. estamos considerando enquanto contador < 3) e a próxima instrução a ser executada (instrução 19) está na linha 8. resultado.resultado). na linha 4 (instruções 4. 3. na instrução 18. Ou seja. o resultado da expressão 6 * 3 é o mesmo de 6 + 6 + 6 ou 3 + 3 + 3 + 3 + 3 + 3. Algoritmo Mult_Soma var contador: inteiro. { Nenhuma iteração foi feita até aqui } 1 2 3 4 5 6 7 8 9 escreva(“Entre com o primeiro valor: ”). 9 e 14). devemos lembrar que qualquer multiplicação pode ser expressa por meio de somas. contador  0. fim contador  contador + 1. Faça três testes de mesa para o algoritmo anterior com as seguintes entradas: 0. leia(operando1). Por exemplo. início operando1. 8. 13 e 18. enquanto (contador < operando2) faça resultado  0. 3.3 Problema 13 – Calcular a multiplicação de dois números sem o operador "*" Faça um algoritmo que calcule a multiplicação de dois números inteiros sem utilizar o operador “*”. conta-se mais 1 } 10 fim escreva(“O resultado da multiplicação é: “. Quando a condição é verdadeira.

o fatorial deve ser retornado como 1 e o comando de repetição não precisa ser executado. se (valor < 0) então escreva(“Valor inválido!”). Também é preciso subtrair 1 do último valor que foi multiplicado. Se você fez o exercício anterior. um ponto crucial para resolver um problema que inclua a repetição é a definição do ponto de saída do laço.2) *. 4. n  valor. pode notar que o número de instruções a serem executadas para a segunda e a terceira entrada é diferente. Isso porque sempre o operando1 será somado e o operando2 determinará quantas vezes o laço será repetido. independentemente de sua ordem. representado por n!.Capítulo 4 • Comandos de Repetição 65 2. * 1. Se o número for negativo. o laço só pode se iniciar após a leitura do valor n e a verificação se tal valor é válido. n: inteiro. é dado por: n * (n . fim fim .. senão início fat  1.).. fat. apesar de o resultado ser o mesmo. garantindo assim que o menor número de instruções seja executado para qualquer entrada. Algoritmo Fatorial var valor. Nesse problema. informe que o valor é inválido. Melhore o algoritmo para que o valor maior seja somado e o valor menor seja o determinante para o controle do laço.1) * (n . A saída do laço é feita quando o valor a ser multiplicado chegar a 1. enquanto (n > 1) faça início fat  fat * n. fat). Além disso. Sabemos que o fatorial de um número n. n  n – 1. diminui-se 1 } fim escreva(“O fatorial calculado é: “.. preparando-o para a próxima iteração ou para a saída do laço.4 Problema 14 – Calcular o fatorial de um número Faça um algoritmo que leia um número inteiro e calcule o seu fatorial. início escreva(“Entre com um valor: ”). Caso o valor seja 0.1 *. leia(valor). para n > 0 e n! = 1 para n = 0 Como dito anteriormente. { A cada iteração.. A cada iteração dentro do laço. é necessário acumular o resultado da multiplicação do valor pelo subseqüente (n * n . é importante se definir a situação desejada para a entrada no laço e o que vai ser executado em cada iteração.1.

ou seja.. pois a condição de controle do laço (n > 1) não é satisfeita nenhuma vez e o valor do fatorial permanece em 1... enquanto <valor booleano> faça . início fim se <valor booleano> então . Exercício proposto 1. senão início . 4.. como na adição..66 Algoritmos e Programação Note que o valor inicial de fat é 1 e não 0.2 Comandos de repetição combinados com comandos de condição A utilização de comandos de repetição combinados com comandos de condição permite resolver problemas bem mais complexos que os vistos até agora. e sua compreensão é absolutamente fundamental para o desenvolvimento de algoritmos mais sofisticados.. Exemplo: . se <valor booleano> então início .... O fatorial de 1 ou 0 é calculado implicitamente.. já que nesses casos o laço não é executado. assim como acontece com o 0 em relação à adição. como esperado. estruturas como as descritas a seguir podem ocorrer intercaladas quantas vezes forem necessárias. senão .. { Fim do bloco se } início enquanto <valor booleano> faça . o ferramental já apresentado é a base para toda a seqüência de algoritmos. Faça dois testes de mesa referentes ao algoritmo Fatorial para o cálculo do fatorial dos números 1 e 5. Ou seja. Os comandos de condição podem fazer parte de blocos pertencentes a comandos de repetição e vice-versa. Esta situação ilustra o fato de que o bloco de instruções pertencente ao laço pode não ser executado nenhuma vez.... Na realidade.. qualquer número multiplicado por 1 é ele próprio. início fim fim . Isso porque o elemento neutro na multiplicação é o 1 e não o 0. caso a condição de controle não seja satisfeita na primeira passagem. como se poderia imaginar.

fim fim escreva(“Somatório: “.. 4. soma  soma + num. num  inferior.Capítulo 4 • Comandos de Repetição início fim fim fim fim . { Fim do bloco enquanto } { Fim do bloco senão } <continuação do algoritmo> Na estrutura anterior temos comandos de decisão aninhados a comandos de repetição e vice-versa. leia(superior). início soma  0. . início enquanto (num <= superior) faça se (num resto 2 = 1) então num  num + 1. superior.. Esse tipo de estrutura é extremamente útil para resolver problemas em diversas situações. .... leia(inferior). o resto resultante da divisão inteira do número por 2 tem valor 1. escreva(“Entre com o limite superior: “).. soma: inteiro. num. Algoritmo Soma_Ímpares_Versão1 var inferior.1 Problema 15 – Calcular a soma dos números ímpares de um intervalo Faça um algoritmo que calcule a soma de todos os números ímpares dentro de uma faixa de valores determinada pelo usuário. ou seja. Essa condição será testada para todos os números dentro da faixa.2.. Vejamos como fica o código: se ((número resto 2) = 1) então [senão ] <código para número ímpar> <código para número par> Como o algoritmo solicita a soma dos valores ímpares dentro de uma faixa. Um número é ímpar quando sua divisão por 2 não é exata. por meio de um laço. soma). escreva(“Entre com o limite inferior: “). teremos que fazer o acúmulo do resultado apenas quando a condição ímpar for atendida. 67 .. Vejamos a seguir alguns exemplos..

Compare o número de instruções executadas com o teste de mesa do algoritmo Soma_Ímpares_Versão1 (visto no exercício 1).68 Algoritmos e Programação Exercícios propostos 1. Faça o teste de mesa com intervalo definido entre 4 e 13. 3. Por definição. divisível  F. Faça o teste de mesa dos algoritmo Soma_Ímpares_Versão1 adaptado no exercício proposto 3.2 Problema 16 – Determinar se um número é primo Faça um algoritmo que leia um número inteiro positivo e determine se este é primo ou não. b. 2.2. Substitua o teste em que verificamos se o número é ímpar dentro do laço para. Adapte o algoritmo Soma_Ímpares_Versão1 para obrigar o usuário a entrar com um valor para o limite inferior menor que o valor definido para o limite superior. um número é primo quando é divisível somente por si próprio e por 1. divisor: inteiro. temos de definir por quais números é divisível. Faça o laço aumentando 2 a 2 seu valor para que apenas os números ímpares sejam calculados. Portanto. faça um laço que garanta a entrada de um intervalo válido (inferior < superior). considerando os limites 4 e 13. Adapte o algoritmo Soma_Ímpares_Versão1. e que podemos dizer ser uma aproximação de “força bruta”. poderia ser testar a divisibilidade do número avaliado por todos os números menores que ele. sem a necessidade de novas verificações. para determinar se um número é primo. c. 4. . acumulá-lo à variável soma pela seqüência: a. Algoritmo Primo_Versão1 var número. { Variáveis booleanas são úteis para determinar a saída ou não de laços } início leia(número). Vejamos a implementação deste algoritmo. Determine se o número é ímpar e considere como limite inferior o próximo ímpar (ou o próprio número caso este seja ímpar). 4. divisível: booleano. escreva(“Entre com um número a ser testado: ”). A aproximação mais simples. então. Faça um único teste antes do laço. Para isso.

divisível  F. se (número resto 2 = 0 e número > 2) então senão divisível  V. Vejamos: 1. se (não(divisível)) então senão fim escreva(“O número “. Números pares (com exceção do 2) não podem ser primos. leia(número). “ é primo. divisor: inteiro.”). Portanto. { Número par diferente de 2 } { Números ímpares menores que 6 são primos e não precisam entrar no laço } enquanto (não(divisível) e divisor <= número / 2) faça { Esta condição será falsa se o número for par } . Portanto. Basta que analisemos com um pouco mais de profundidade que perceberemos que várias otimizações podem ser aplicadas ao raciocínio utilizado nesse algoritmo. Se um número não for divisível por 2. Se levarmos em conta tais considerações. só precisaremos testar números ímpares. escreva(“O número “. 69 divisor  divisor – 1. número. não se pode dizer que seja propriamente eficiente. como foi implementado. É mais fácil que um número seja divisível por um número pequeno do que por um número maior. divisor  3. Algoritmo Primo_Versão2 var número. Apesar de o algoritmo Primo_Versão1 ser eficaz. 3. se iniciarmos a procura do divisor de baixo para cima.Capítulo 4 • Comandos de Repetição enquanto (não(divisível) e divisor > 1) faça início se (número resto divisor = 0) então senão fim divisível  V. 2.”). ao invés de cima para baixo. visto que resolve o problema para o qual foi projetado. não precisamos testar a divisibilidade dos número na faixa entre a metade e o próprio número. não será divisível por nenhum outro número par. Portanto. pois executará muito menos instruções para responder a mesma questão. escreva(“Entre com um número a ser testado: ”). Nenhum número pode ser divisível por outro número maior que a metade dele. teremos um algoritmo muito mais eficiente que o anterior. divisor  número – 1. com exceção do número 2. “ não é primo. teremos chance de encontrar o número muito antes. início divisível: booleano. visto que são divisíveis por 2. número.

o número menor sempre será menor que a raiz quadrada do resultado da multiplicação e o número maior. divisível: booleano. • 20 é divisível pelos números 1. 18 * 2 e 36 * 1). 4 * 9. só precisamos testar a divisibilidade de um número por valores iguais ou inferiores à sua raiz quadrada. . 6 * 6. 5. • 36 é divisível pelo números 1. Um raciocínio mais sofisticado pode ainda nos dar uma otimização final. e um será maior que o outro. maior que a raiz quadrada do número em questão. menor o outro. 10 e 20 (1 * 20. e 17 * 1). 4. 3. número. 18 e 36 (1 * 36. quando os números se repetem em ordem inversa. a não ser que tais números sejam iguais (quando o número tem uma raiz quadrada exata). A relação se inverte após a linha da raiz quadrada. 2. 2. 2 * 8. “ não é primo. Algoritmos e Programação divisor  divisor + 2. escreva(“O número “. • 17 é divisível pelos números 1 e 17 (1 * 17. Vejamos alguns exemplos para facilitar a compreensão deste ponto: • 15 é divisível pelos números 1. 12.”). } se (não(divisível)) então senão fim escreva(“O número “. 4 * 5. 8 e 16 (1 * 16. No caso de divisores diferentes. 2 * 10. 4. • 16 é divisível pelos números 1. 10 * 2 e 20 * 1). Algoritmo Primo_Versão3 var número. Podemos. 5 * 4. 2 * 18. 12 * 3.70 início se (número resto divisor = 0) então senão fim divisível  V. divisor: inteiro. 9 * 4. • 25 é divisível pelo números 1. 5. 4. Ou seja. 5 * 5 e 25 * 1). número. 3 * 12. Podemos perceber que quanto maior um dos fatores. { Serão testados divisores ímpares: 3. não terá outro divisor que não ele próprio ou o 1. 9. 6. 4 * 4. 3. 5 e 15 (1 * 15. Adaptando o algoritmo. concluir que se um número não for divisível por um número menor ou igual à sua raiz quadrada. teremos o que se vê no exemplo a seguir.”). 5 e 25 (1 * 25.. Os exemplos anteriores são para ilustrar a seguinte propriedade da divisibilidade de um número: qualquer número que seja divisível por outro terá como divisores dois números ou fatores. “ é primo. 5 * 3 e 15 * 1). então. 8 * 2 e 16 * 1). será um número primo. 2. Portanto. 3 * 5.

fim { Fim do bloco enquanto externo } . A estrutura do algoritmo que contém laços encadeados segue: <nome do algoritmo> <declaração de variáveis> início . 5.. { Número par } se (número resto 2 = 0 e número > 2) então divisível  V... enquanto <valor booleano> então início .”). leia(número).”).. senão divisor  3.... fim 71 Exercício proposto 1. senão escreva(“O número “.. Verifique qual o número de instruções é necessário executar em cada uma delas e veja a diferença entre suas execuções. “ é primo. <continuação do algoritmo> fim .. número.. . a utilização de comandos de repetição encadeados geralmente causa uma certa dificuldade para o seu acompanhamento à primeira vista. fim se (não(divisível)) então escreva(“O número “.3 Comandos de repetição encadeados Apesar de seguir o mesmo padrão de encadeamento de outros comandos já vistos.. Faça dois testes de mesa referentes aos três algoritmos que identificam um número primo. } divisor  divisor + 2.... enquanto (não(divisível) e divisor <= número raiz 2) faça { Números ímpares menores que 9 são primos e não precisam entrar no laço } início se (número resto divisor = 0) então divisível  V. Verifique as seguintes entradas: 15 e 29. enquanto <valor booleano> faça início . “ não é primo. fim { Fim do bloco enquanto interno } .Capítulo 4 • Comandos de Repetição início escreva(“Entre com um número a ser testado: ”). divisível  F. número. senão { Serão testados números ímpares: 3. 4..

abstraindo um dos laços e se concentrando no segundo. leia(alunos). Por exemplo. início enquanto (cont < alunos) faça { Ainda não foi somado nenhum valor } { Será repetido para cada aluno da turma } escreva(“Entre com a nota do aluno: ”. nesse caso. Considere como entradas o número de turmas e o número de alunos de cada turma. alunos: inteiro. . As turmas são um conjunto. leia(nota). E ainda podemos tê-los combinados com comandos de decisão e assim por diante. cont  0. Até aí. No caso da soma de 100 números. os números entrados eram acumulados dentro do laço. Podemos até mesmo resolver um exercício de cada vez. tínhamos que executar um bloco de condição para cada possível divisor do número em questão.3. Vejamos. podemos ter tantos laços encadeados quanto precisarmos. Até agora. soma.1 Problema 17 – Calcular a média das turmas de uma escola Faça um algoritmo que calcule a média de todas as turmas de uma escola. Nesse caso precisaríamos de três laços encadeados (escolas/turmas/alunos). A utilização de laços encadeados pode ser necessária quando precisamos fazer uma operação repetitiva para cada elemento dentro de um conjunto. { Nenhuma iteração foi feita até aqui } 1 2 3 4 5 6 7 escreva(“Entre com o número de alunos”). Para cada conjunto.72 Algoritmos e Programação De fato. um único laço seria suficiente. que será o resultado da média das turmas. Porém. início nota. Imaginemos que precisássemos calcular a média das notas de uma classe. precisaríamos de um laço. a solução do problema para apenas uma turma. 4. dois laços encadeados. soma  0. E se precisássemos ainda fazer o cálculo para todas as escolas de uma cidade. imaginemos agora que precisássemos calcular a média das notas de todas as turmas de uma escola. para depois resolvermos o problema de todas as turmas: Algoritmo Média_Turma var cont. além da média geral. no caso da soma dos números primos. cont + 1). A média de cada turma deve ser apresentada. Um detalhe importante de se notar na resolução desse tipo de algoritmo é o fato de os laços geralmente terem condições diferentes e independentes. repetindo-se o processo para cada número. média: real. As notas dos alunos dentro de cada turma são outro conjunto. usamos os laços para fazer operações sobre um conjunto de elementos. então.

soma  0. { Nenhuma iteração foi feita até aqui } 1 2 3 4 5 6 7 8 9 escreva(“Entre com o número de turmas: ”). a parte da média das escolas conta com uma situação que não temos: a média de cada turma não é conhecida de antemão pelo usuários. a não ser que estes executassem o primeiro algoritmo. início média_turma. É claro que esta solução não é razoável. média). cont  cont + 1. cont + 1). Bem. média_escola  soma / turmas.Capítulo 4 • Comandos de Repetição 8 9 fim soma  soma + nota. De fato. início enquanto (cont < turmas) faça { Ainda não foi somado nenhum valor } { Será repetido para cada turma } leia(média_turma). soma_escola: real. Agora. considerando que temos as médias de cada turma já preparadas pelo usuário. soma_turma. soma. o que precisa ser feito é substituir o trecho do segundo algoritmo em que o usuário entra com as médias das turmas pelo primeiro algoritmo. alunos. cont  cont + 1. média_turma. cont_t. turmas: inteiro. que é quem calcula a média de cada turma. anotassem num papel o resultado de cada turma e executassem o segundo algoritmo para passar esses valores. turmas: inteiro. Atenção especial deve ser dada ao possível conflito de variáveis. vamos resolver o que seria o cálculo das médias de uma escola. os contadores utilizados nos dois algoritmos tratam de elementos diferentes (alunos e turmas. média_escola: real. cont  0. Algoritmo Média_Escola_Versão2 var cont_a. média_escola). leia(turmas). Entretanto. 73 10 11 fim escreva(“A média da turma é: ”. escreva(“Entre com a média da turma: ”. Por exemplo. respectivamente) e devem ser tratados como variáveis independentes. fim 10 11 fim escreva(“A média da escola é: ”. soma  soma + média_turma. Algoritmo Média_Escola_Versão1 var cont. média  soma / alunos. resolvemos as duas partes do algoritmo. . média_escola. nota.

início enquanto (cont_t < turmas) faça { Será repetido para cada turma da escola } cont_a  0. em que cada turma será contada } leia(nota). mais um aluno } 15 16 17 18 fim escreva(“A média da turma ”. média_escola  soma_escola / turmas.5] 7. leia(alunos). da turma. 19 20 fim escreva(“A média da escola é: ”. cont_a + 1). cont_t  cont_t + 1. soma_escola  soma_escola + média_turma. { A cada iteração. cont_t + 1. { O laço externo. início escreva(“Entre com o número de alunos da turma ”. acompanhemos o teste de mesa considerando uma escola com duas turmas com 3 e 2 alunos cada uma (Tabela 4. mais uma turma } média_turma  soma_turma / alunos.5 cont_t turmas 0 0 0 0 0 0 0 {0} 0 0 0 0 0 ? ? ? [2] 2 2 2 2 2 2 2 2 2 média_ turma ? ? ? ? ? ? ? ? ? ? ? ? ? soma_ média_ turma escola ? ? ? ? ? ? 0 0 0 0 0 0 7. média_turma). “ é: ”.2). escreva(“Entre com o número de turmas: ”). cont_t + 1). média_escola). soma_escola  0. { O laço interno. fim { A cada iteração.2 – Teste de mesa para Média_Escola_Versão2 Instrução Linha cont_a alunos nota 1 2 3 4 5 6 7 8 9 1 2 3 4 5 6 7 8 9 10 11 12 13 ? ? ? ? ? 0 0 0 0 0 {0} 0 0 ? ? ? ? ? ? ? ? [3] 3 3 3 3 ? ? ? ? ? ? ? ? ? ? ? [7. Tabela 4. cont_a  cont_a + 1. enquanto (cont_a < alunos) faça { Será repetido p/ cada aluno da turma } escreva(“Entre com a nota do aluno: ”. soma_turma  soma_turma + nota.74 início Algoritmos e Programação 1 2 3 4 5 6 7 8 9 10 11 12 13 14 cont_t  0. leia(turmas). Para facilitar o teste.5 ? ? ? ? ? ? ? ? ? ? ? ? ? soma_ escola ? 0 0 0 0 0 0 0 0 0 0 0 0 E I 10 11 12 13 . em que cada aluno será contado } soma_turma  0. da escola.

5 5.5 5.5 5.5 7.5 5.5 soma_ média_ turma escola 7.5 14.5 5.5 12.5} 8.5 14.5 8.5 5.5 7.5 {8.5 8.25 {7.5 7.5 12.5 5.25} soma_ escola 0 0 0 0 0 0 0 0 0 0 0 0 0 0 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 14.5 5.5 5.5 7.5 5.5 8.5] 5.5 5.5 [8] 8 8 8 8 [9] 9 9 9 9 9 9 9 9 9 9 75 cont_t turmas 0 0 0 0 0 0 0 0 0 0 0 0 0 {0} 0 1 1 1 1 {1} 1 1 1 1 1 1 1 1 1 1 1 1 1 {1} 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 média_ turma ? ? ? ? ? ? ? ? ? ? ? ? 6 {6} 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 8.5 7.5 18 18 18 18 18 18 18 18 18 0 0 0 0 0 0 8 8 8 8 8 17 17 17 17 17 17 17 17 17 17 ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? 7.5 12.5 12.5 5.5 8.5 12.5 [5] 5 5 5 5 [5.Capítulo 4 • Comandos de Repetição Instrução Linha cont_a alunos nota 14 14 10 11 12 13 14 10 11 12 13 14 10 15 16 17 18 5 6 7 8 9 10 11 12 13 14 10 11 12 13 14 10 15 16 17 18 5 19 20 1 1 {1} 1 1 2 2 {2} 2 2 3 3 3 3 3 3 3 0 0 0 0 0 {0} 0 0 1 1 {1} 1 1 2 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 [2] 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 7.5 5.5 I 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 I I E I I I E .5 14.5 14.

leia(superior). Isto ocorre em virtude do encadeamento dos laços. exceto pelo fato de que a condição de controle só é testada após a execução do bloco de comandos. início 1 2 3 4 escreva(“Entre com o limite superior: “). A média de cada escola deve ser apresentada. Vejamos sua sintaxe: repita até <valor booleano>.4 Comando repita Além do comando enquanto.4. . como é o caso do comando enquanto. existem outras estruturas para implementar laços repetitivos. 4. Note que o número de instruções executadas é bastante grande. e não antes. soma  0. sem a necessidade do teste na entrada do bloco. que será o resultado da média de todas as escolas da cidade. O comando repita funciona de forma similar ao comando enquanto. Considere como entrada o número de escolas. Vejamos um exemplo: 4. Algoritmo Soma_Ímpares_Versão2 var superior. soma: inteiro. além da média geral. num. num  1. Cada escola tem diversas turmas. Os custos computacionais de laços encadeados no desempenho de algoritmos serão analisados com mais detalhes no capítulo 12.76 Algoritmos e Programação As linhas identificadas com E  são relativas ao laço externo e as marcadas com I  são relativas ao laço interno. podemos utilizar o comando repita sempre que tivermos certeza de que o bloco de instruções será executado ao menos uma vez.1 Problema 18 (adaptação do problema 15) Faça um algoritmo que calcule a soma dos números ímpares entre 1 e um limite superior definido pelo usuário. o número de turmas de cada escola e o número de alunos de cada turma. Faça um algoritmo que calcule a média de todas as escolas de uma cidade. mesmo tendo usado entradas pequenas (duas turmas com 3 e 2 alunos). <bloco de instruções> <continuação do algoritmo> Assim. Exercício proposto 1.

a saída do laço só ocorre quando a condição se torna falsa. Vejamos o teste de mesa considerando o limite superior como 4 (Tabela 4. a saída de um laço repita ocorre quando a condição booleana se torna verdadeira. Pelo exemplo. soma).3). Nos laços enquanto. enquanto (num <= superior).Capítulo 4 • Comandos de Repetição repita início 77 5 6 7 fim se (num resto 2 > 0) então num  num + 1. podemos perceber que a condição do laço até (num > superior) é diferente da similar no comando enquanto implementada no problema 15. Tabela 4. ao contrário do comando enquanto. . Isso ocorre porque na realidade o que é executado é apenas o teste de controle e o desvio do fluxo do algoritmo dependendo do resultado do teste. soma  soma + num. Isso ocorre porque. escreva(“A soma dos números ímpares é: “. 8 9 fim até (num > superior).3 – Teste de mesa para Soma_Ímpares_Versão2 Instrução Linha num superior soma 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 1 2 3 4 5 6 7 8 5 7 8 5 6 7 8 5 7 8 9 ? ? ? 1 1 1 2 2 2 3 3 3 3 4 4 4 5 5 5 ? ? [4] 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 0 0 0 0 0 1 1 1 1 1 1 1 4 4 4 4 4 4 4 Notemos que a linha do comando repita não é registrada na execução.

.78 Algoritmos e Programação Exercícios propostos 1. fará com que a condição de controle seja atingida e o laço se encerre no momento oportuno. num. início enquanto (num <= superior) faça se (num resto 2 > 0) então num  num + 1. perceberemos que a maioria deles tem comportamento similar.. temos a separação do comando em três cláusulas: preparação. Faça um algoritmo que determine se um número é primo (utilize o comando repita). <passo para alcance da condição>) faça <continuação do algoritmo> <bloco de instruções> Portanto.. <condição 2 de controle>. 2. Vejamos um exemplo: Algoritmo Soma_Ímpares_Versão3 var inferior. condição e passo. soma: inteiro. em algum momento. { Instrução utilizada para que a condição de controle seja atingida } fim fim O comando para procura resumir essas três características comuns à maioria das implementações de laços em uma só instrução. superior. 4.. escreva(“Entre com o limite superior: “).. Uma situação inicial. soma  soma + num. leia(superior). <instrução2 de preparação> . ou preparação para a entrada no laço } { Teste de entrada/saída } num  1.]. um teste de controle para a entrada/saída do bloco e uma instrução dentro do laço que.]. início soma  0. { Situação inicial. facilitando assim a construção típica de laços. <condição1 de controle>[. Faça a multiplicação apenas por meio de somas (utilize o comando repita). A sintaxe do comando para: para (<instrução1 de preparação> [. definida antes do início do laço como uma preparação para a sua entrada.5 Comando para Se analisarmos os exemplos de utilização de laços.

4. e a condição toda é Verdadeira apenas se todas as condições o forem. estas são separadas por vírgula e executadas na ordem em que se encontram no comando. nesses casos. Nesse caso. O comando para é executado da seguinte maneira: 1. 5. Ou seja. Passe para o item 2. por exemplo. Quando temos mais de uma condição de controle (segunda cláusula). soma: inteiro. um comportamento implícito sempre igual. Nesses casos. início 1 2 escreva(“Entre com o limite superior: “). Já a linguagem de programação C implementa todas as cláusulas do comando para. Algumas linguagens de programação não implementam explicitamente a terceira cláusula (passo). Caso seja Verdadeiro. em geral. Saia do laço e prossiga o algoritmo. Execute o teste de controle. deve-se obrigatoriamente fazer uso dos comandos enquanto ou repita. é equivalente a uma condição lógica ligada pelo conectivo e. O comando para é equivalente à seguinte estrutura: <instrução de preparação> início enquanto (<teste de controle>) faça <instruções> fim <passo> Implementemos novamente o algoritmo Soma_Ímpares_Versão1 utilizando o comando para em vez do comando enquanto: Algoritmo Soma_Ímpares_Versão4 var superior. Não há como representar composição de condições ou no comando para. e esta tem. passe para o item 6. Execute o bloco de instruções. . 3. 2. Execute o passo para alcance da condição de controle. soma  0. num. os testes também são realizados em ordem. o para é usado quase que exclusivamente em algoritmos com contadores. o passo sempre é o incremento/decremento em 1 à variável preparada na primeira cláusula. quando temos mais de uma instrução de preparação (primeira cláusula). Execute a instrução de preparação na primeira iteração do laço.Capítulo 4 • Comandos de Repetição 79 Vale citar que. Caso contrário. No caso da linguagem Pascal. passe para o item 3. 6.

mas internamente seu funcionamento é igual ao do comando enquanto ou repita. e não há ganho de . O bloco de instruções do comando para só contém uma instrução (o comando se) e. não precisa ser delimitado pelo início/fim.4). Algoritmos e Programação para (num  1. por isso.4. Vejamos o teste de mesa considerando o limite superior como 4 (Tabela 4.4 – Teste de mesa para Soma_Ímpares_Versão4 Instrução Linha num superior soma 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 1 2 3 4 4 5 6 4 4 5 4 4 5 6 4 4 5 4 4 7 ? ? ? 1 1 1 1 2 2 2 3 3 3 3 4 4 4 5 5 5 ? ? [4] 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 0 0 0 0 0 0 1 1 1 1 1 1 1 4 4 4 4 4 4 {4} Passo Teste de entrada/saída Passo Teste de entrada/saída Passo Teste de entrada/saída Passo Teste de entrada/saída Instrução inicial Teste de entrada/saída Comentários Perceba que o número de instruções executadas é praticamente igual ao número de instruções executadas na implementação do mesmo algoritmo utilizando o comando repita apresentado na seção 4. soma). Tabela 4. Isso porque o comando para é uma construção diferente no que diz respeito apenas ao estilo de programação. apesar de o número de linhas do algoritmo ser diferente. escreva(“A soma dos números ímpares é: “. sendo representada separadamente no teste de mesa. num  num + 1) faça se (num resto 2 > 0) então soma  soma + num. Podemos notar que a linha 4 (do comando para) contém mais de uma instrução.80 3 4 5 6 7 fim leia(superior). num <= superior.

n.1 Problema 19 – Calcular o somatório Faça um algoritmo que calcule a seguinte fórmula: � i=3 n (5 * i + 2) em que n é definido pelo usuário. n. início 1 2 3 4 5 6 fim escreva(“Entre com o limite superior: “). i <= n. 2. 3.5. 4. para (i  3. Faça o teste de mesa para o algoritmo Somatório. Exercícios propostos 1. Faça um algoritmo que determine se um número é primo. Esse tipo de fórmula encaixa-se perfeitamente na estrutura do comando para. i  i + 1) faça somat  somat + (5 * i + 2).Capítulo 4 • Comandos de Repetição 81 desempenho ou diminuição de instruções executadas pela sua utilização. leia(n). Temos apenas uma diminuição do número de linhas do algoritmo em virtude de seu estilo compacto. escreva(“O somatório somat). Podemos separar: • Instrução de preparação: i = 3 • Condição de saída: i = n • Passo: i  i + 1 Algoritmo Somatório var i. somat  0. em que descrevemos três instruções em apenas uma linha. “ é “. Faça os próximos algoritmos utilizando o comando para. . Faça a multiplicação apenas por meio de somas. � i=3 n (5 * i + 2) para o limite definido “. somat: inteiro.

Caso o quociente não seja exato. Faça um algoritmo que calcule a potenciação utilizando o operador “*”. utilizando o operador de adição ou subtração. o resultado procurado é 4. . Considerando que a potenciação é o resultado de várias multiplicações e que a multiplicação pode ser expressa por meio de adições. o número de vezes que se subtraindo o dividendo (operando1) pelo divisor (operando2) chegar a 0 é o quociente procurado. 6. 4.3 = 0 (12 subtraído 4 vezes (quociente) por 3 é igual a 0). define-se o máximo divisor comum (MDC) como sendo o maior inteiro que divide simultaneamente a e b”. Depois. faça um algoritmo que leia dois números e encontre o mínimo múltiplo comum (MMC). faça o teste de mesa para garantir que o exercício está correto. a partir deles. é preciso verificar que a próxima subtração terá um resultado negativo: 13 div 3  13 . faça um algoritmo que leia dois números e. a potenciação pode ser representada por uma série de multiplicações. faça o teste de mesa para garantir que o exercício está correto.3 = 1. por exemplo. Esse algoritmo deve utilizar o seguinte método para calcular o MMC: "multiplicar os dois números e dividirpelo MDC (máximo divisor comum)". Da mesma forma que a multiplicação pode ser expressa como o resultado de várias adições.3 . múltiplo comum de a e b”. Vejamos o exemplo: 12 div 3. Faça um algoritmo que calcule a soma dos números primos entre 1 e 100.3 . Portanto.3 . observe que a operação de divisão segue o raciocínio similar ao da multiplicação.3 . 3. 5. Operando1: 12 Operando2: 3 Quociente: 4 Se calcularmos 12 . Depois.82 Algoritmos e Programação 4. Ou seja. define-se o mínimo múltiplo comum (MMC) como sendo o menor inteiro positivo. 10 div 3 = 3.3 .6 Exercícios do capítulo 1. 2. teremos –2.3 . Para auxiliar na resolução deste exercício. implemente um algoritmo que realize a potenciação apenas por meio de adições. Dada a definição de MMC: “dados dois números inteiros a e b não nulos. porém de forma inversa. Dada a definição de MDC: “dados dois números inteiros a e b não nulos. Faça um algoritmo que calcule a divisão inteira de dois números. descubra o máximo divisor comum (MDC). Subtraindo-se mais uma vez.

se o número é o MMC testando sua divisibilidade pelos dois números. Faça um algoritmo que encontre o n-ésimo termo da série de Fibonacci. Otimize o algoritmo do exercício 7 considerando que os números candidatos ao MMC devem ser múltiplos do maior dos dois números. mas o valor do maior dos dois números). A série de Fibonacci é dada por: fib(n) = fib(n . dentro do laço para encontrar o MMC. parta do maior dos dois números e verifique. dentro do laço. mas que em vez de utilizar a fatoração. parta do seguinte princípio: "o MMC é o menor número maior ou igual ao maior dos dois números escolhidos e que é divisível pelos dois números iniciais.1) + fib(n .2) para n > 1. Exemplos: fib(0) = 0 fib(1) = 1 fib(2) = fib(1) + fib(0) = 1 + 0 = 1 fib(3) = fib(2) + fib(1) = 1 + 1 = 2 fib(4) = fib(3) + fib(2) = 2 + 1 = 3 fib(5) = fib(4) + fib(3) = 3 + 2 = 5 fib(6) = fib(5) + fib(4) = 5 + 3 = 8 . 8." Portanto. sendo n definido pelo usuário e maior que 5: � i=5 n (2 * i2+ 5 * i + 1) 10. teste apenas seus múltiplos (somando não 1. Faça o algoritmo para a resolução do somatório a seguir. 9. Faça um novo algoritmo para o cálculo do MMC de dois números. Portanto.Capítulo 4 • Comandos de Repetição 83 7. o valor é dado por definição: fib(0) = 0 e fib(1) = 1. Para n = 0 e n = 1.

1 Encontrar o n-ésimo termo da série de Fibonacci (exercício 10) Faça um algoritmo que encontre o n-ésimo termo da série de Fibonacci. fib_N) 4.84 Algoritmos e Programação 4. Todo programa implementado tem o seu correspondente em pseudocódigo no apêndice A ou no próprio corpo do livro. { penúltimo valor } { último valor } { O comando 'for' corresponde ao comando 'para'. Os programas escolhidos contêm exemplos comentados dos conceitos e notações introduzidos no capítulo. fib_menos_1. Output).1. fib_menos_2. Para mais informações sobre a série de Fibonacci.  Arquivo Cap_04_10.7 Exemplos de programas em Pascal e C A seguir. veja o exercício 10 na página 84. var n.7. writeln('O n-ésimo termo da série de Fibonacci é: '.pas program Fibonacci(Input.1. { O comando a seguir equivale a 'para (i  2.2 Ler 100 números e retornar a soma e a média aritmética desses valores (problema 12) Faça um algoritmo que leia 100 números e retorne a soma e a média aritmética desses valores. para calcular o n-ésimo termo da série de Fibonacci: '). i  i + 1)' } for i := 2 to n do begin Em Pascal.7. fib_menos_1 := 1. { O conectivo 'or' corresponde ao conectivo 'ou' } if (n = 0) or (n = 1) then else fib_N := n readln(n). end. 4.7. fib_N. i: integer. fib_menos_1 := fib_N.1 Programas em Pascal 4. a cláusula 'passo' é implícita } fib_N := fib_menos_1 + fib_menos_2. end. . end. fib_menos_2 := fib_menos_1. write('Digite n. temos programas para facilitar a transição do pseudocódigo para linguagem de programação. i <= n. begin begin fib_menos_2 := 0.

1. soma). valor: real. { O comando 'repeat' corresponde ao comando 'repita'} repeat { Em Pascal. contador := contador + 1.  Arquivo Cap_04_prob18.3 Calcular a soma dos números ímpares entre 1 e um limite superior (problema 18) Faça um algoritmo que calcule a soma dos números ímpares entre 1 e um limite superior definido pelo usuário. num. writeln('A soma dos números ímpares de 1 até '. readln(valor).'). Output). var contador: integer. { A cada iteração conta-se mais um } { Calcula a média aritmética } writeln('Soma: '. Output). . soma := soma + valor. end.Capítulo 4 • Comandos de Repetição 85  Arquivo Cap_04_prob12. superior. soma: integer. end.7. { O comando 'while' corresponde ao comando 'enquanto' } while (contador < 100) do begin write('Entre com um valor: ').pas program Soma_media_100(Input. writeln('Média aritmética: '. ' é: '. valor := 0. soma := soma + num. begin soma := 0. num := 1. o repeat não precisa da definição explícita do início/fim do bloco } if num mod 2 > 0 then num := num + 1. contador := 0. soma:18:2). { ainda não foi somado nenhum valor } write('Entre com o limite superior: '). media := soma / contador. begin soma. until (num > superior).pas program Soma_impares(Input. soma := 0. 4. readln(superior). { Nenhuma iteração feita até aqui } { Ainda não foi somado nenhum valor } writeln('Digite 100 valores para calcular a média aritmética. media:18:2). var superior. media. end.

return 0. i. i <= n. para calcular o n-ésimo termo da série de Fibonacci. fib_menos_2 = 0.86 Algoritmos e Programação 4.2 Ler 100 números e retornar a soma e a média aritmética desses valores (problema 12) Faça um algoritmo que leia 100 números e retorne a soma e a média aritmética desses números. veja o exercício 10 na página 84.  Arquivo Cap_04_10.h> int main() { int n. /* nenhuma iteração feita até aqui */ soma = 0. fib_N = n.h> int main() { int contador. } } printf("O n-ésimo termo da série de Fibonacci é: %d \n". printf("Digite 100 valores para calcular a média aritmética. contador = 0.  Arquivo Cap_04_prob12. &n). .2. printf("Digite n. i++) { /* O comando for corresponde ao comando "para" */ /* último valor */ /* penúltimo valor */ fib_N = fib_menos_1 + fib_menos_2. for (i = 2. fib_menos_1 = fib_N. /* ainda não foi somado nenhum valor */ valor = 0. valor. scanf("%d".2.7.7. float soma.2 Programas em C 4.\n"). Para mais informações sobre a série de Fibonacci.7.1 Encontrar o n-ésimo termo da série de Fibonacci (exercício 10) Faça um algoritmo que encontre o n-ésimo termo da série de Fibonacci. if (n == 0 || n == 1) else { fib_menos_1 = 1.c #include <stdio. fib_menos_2 = fib_menos_1. media.\n"). fib_N. fib_menos_2. fib_N). } 4.c #include <stdio. fib_menos_1.

} .7.2. &valor). num.Capítulo 4 • Comandos de Repetição while (contador < 100) { printf("Entre com um valor: "). soma). &superior). contador = contador + 1. printf("Soma: %f\n". /* se o número é ímpar */ if (num % 2 > 0) soma = soma + num. do /* O comando do/while faz a mesma função do comando repita/até */ { num = num + 1. /* a cada iteração conta-se mais 1 */ } /* Calcula a média aritmética */ media = soma / contador.c #include <stdio. printf("Média: %f\n".\n"). superior. soma = 0.  Arquivo Capítulo_04_prob18.h> int main() { int superior. num = 0. soma = soma + valor. soma). media). soma. /* ainda não foi somado nenhum valor */ printf("Entre com o limite superior. return 0. return 0. scanf("%d". printf("A soma dos números ímpares de 1 até %d é: %d\n". } 87 4. scanf("%f".3 Calcular a soma dos números ímpares entre 1 e um limite superior (problema 18) Faça um algoritmo que calcule a soma dos números ímpares entre 1 e um limite superior definido pelo usuário. } while (num <= superior).