4- Comandos de Repetição

Comando enquanto
comandos de repetição combinados com
comando de condição
comandos de repetição encadeados
comando repita
comando para
-Exemplos em Linguagem C
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
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, podemos utilizar uma
estrutura que indique que tal instrução será executada
quantas vezes for necessária.
4.1 Comando enquanto
Um elevador tem um comportamento que pode ser descrito na
forma de algoritmo.

Na subida

enquanto não chegar ao andar mais alto selecionado faça

inicio
suba um andar,
se o andar foi selecionado internamente então
inicio
pare,
abra as portas,
feche as portas,
fim
fim
Na descida

enquanto não chegar ao andar mais baixo selecionado faça

inicio
desça um andar,
se o andar foi selecionado internamente/externamente então
inicio
pare,
abra as portas,
feche as portas,
fim
fim
O comando enquanto caracteriza-se por uma verificação de
encerramento da atividade antes de iniciar(ou reiniciar) a execução
de seu bloco de instruções.

Vejamos sua sintaxe:

enquanto <valor booleano> faça

<bloco de instruções>
<continuação do algoritmo>

Cada execução do bloco de instruções é chamada iteração.

O comando de repetição juntamente com o seu bloco de instruções
é chamado de loop ou laço.
Uma variável fará o papel de contador, contendo o número de
iterações já realizadas, sendo atualizada a cada nova iteração.
Problema 11 – Escrever 100 vezes “ um texto qualquer”

Algoritmo Escrever_100_vezes

var contador: inteiro;

inicio
contador ← 0; {Nenhuma iteração foi feita até aqui}
enquanto( contador <100) faça {O bloco será repetido 100
vezes}
inicio
escreva(“Vou plantar”, contador+1,”castanheiras”);
contador← contador +1;
fim
fim
4.1.2 Problema 12- Ler 100 números e calcular a soma e
a média
Algoritmo Soma_Media 100
var contador : inteiro;
valor, soma, media: real;
inicio
contador ← 0;
soma←0;
enquanto (contador < 100) faça
inicio
escreva(“Entre com um valor:”);
leia(valor);
soma←soma + valor;
contador←contador +1;
fim
media←soma/contador;
escreva(“Soma=”,soma,”Média=”,media);
fim
Exercícios propostos

1.Adapte o algoritmo Soma_Media_100 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.

2. Adapte o algoritmo Escrever_100_vezes, para ler uma

variável do tipo caractere. Se o caractere for A, escrever 100
vezes, se o caractere for B escrever 1000 vezes.
 4.1.3 Problema 13 – Calcular a multiplicação de dois
números sem o operado “*”.

A multiplicação pode ser expressa por meio de somas. Por exemplo:

6*3 igual a 6+6+6 ou 3+3+3+3+3+3
O algoritmo é:
Soma-se um elemento com ele próprio o número de vezes do
segundo elemento.
 Algoritmo Mult_Soma
var cont, oper1, oper2, resul: inteiro;
inicio
cont ←0;
resul←0;
escreva(“Entre com o primeiro valor);
leia(oper1);
escreva(“Entre com o segundo valor);
leia(oper2);
enquanto(cont < oper2) faça
inicio
resul←resul + oper1;
cont←cont + 1;
fim
escreva(“O resultado da multiplicação é: “, resul);
fim
Exercícios propostos

1. Faça três testes de mesa para o algoritmo anterior com as

seguintes entradas: 0 e 3; 3 e 6; 6 e 3.
2. Para a segunda e terceira entrada, note que apesar de dar o
mesmo resultado, o número de instruções executadas é
diferente. Melhore a eficiência do algoritmo para que o valor
somado seja o maior, e o valor menor seja usado para o
controle do laço.

4.1.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. Se o número for negativo, informe que o valor é inválido.
n*(n-1)(n-2)*...*1, para n>1 e n!=1 para n =0 e n=1

Problemas que incluem repetição é importante:

1.Situação desejada na entrada do laço
2.O que vai ser executado em cada iteração
3.Ponto de saída do laço

1. O laço só pode iniciar após a leitura do valor n e a verificação se

tal valor é válido.Caso o valor de retorno seja 0 ou 1, o fatorial
deve ser retornado como 1 e o comando de repetição não precisa
ser executado.
2. É necessário acumular o resultado da multiplicação do valor pelo
próximo (n*n-1*...).Também é preciso subtrair 1 do último valor
que foi multiplicado.
3. A saída do laço ocorre quando o valor a ser multiplicado chegar a
1.
 Algoritmo Fatorial
var valor, fat, n: inteiro;
inicio
escreva(“Entre com o valor: “);
leia(valor);
se(valor < 0) então
escreva(“Valor inválido!”);
senão
inicio
fat←1;
n←valor;
enquanto(n>1) faça
inicio
fat←fat*n;
n←n-1;
fim
escreva(“O fatorial calculado é: “,fat);
fim
fim
 Exercício proposto

Modifique o algoritmo do fatorial para:

Quando o valor de entrada foi menor que zero, escrever:
“Valor inválido. Entre com um valor maior que zero.”
E receber o novo valor, até que ele seja válido.

4.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.
Poderemos ter comandos de decisão aninhados a comandos de
repetição e vice-versa.
...
se<valor booleano>então
inicio
...
enquanto<valor booleano>faça
inicio
...
fim
...
fim
senão
inicio
...
enquanto<valor booleano> faça
inicio
...
se<valor booleano>então
inicio
...
fim
senão
inicio
...
fim fim fim
4.2.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.
Um número é ímpar quando sua divisão por 2 não é exata, ou seja,
o resto resultante da divisão inteira do número por 2 tem valor 1.

se ((numero resto 2) = 1) então

<código para número ímpar>
senão
<código para número par>

Como o algoritmo solicita a soma dos valores ímpares dentro de

uma faixa, teremos que fazer o acúmulo do resultado apenas
quando a condição ímpar for atendida.
Essa condição será testada para todos os números dentro da faixa,
por meio de um laço.
 Algoritmo Soma_Ímpares_Versão1
var inferior, superior, num, soma: inteiro;
inicio
soma←0;
escreva(“Entre com o limite inferior: “);
leia(inferior);
escreva(“Entre com o limite superior: “);
leia(superior);
num←inferior;
enquanto(num <= superior) faça
inicio
se(num resto 2 = 1) então
soma←soma + num;
num←num + 1;
fim
escreva(“Somatório: “,soma);
fim
Exercícios propostos
1. 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. Para isso faça um laço que
garanta a entrada de um intervalo válido(inferior < superior)
2. Adapte o algoritmo Soma_Ímpares_Versão1.Substitua o teste em
que verificamos se o número é ímpar dentro do laço. Faça um
único teste antes do laço.Determine se o número é ímpar e
consideres como limite inferior o próximo ímpar(ou o próprio
número caso este seja ímpar). Faça o laço aumentando 2 a 2 seu
valor, sem necessidade de novas verificações.
3. Qual dos dois algoritmos é mais eficiente ??
4.2.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.
Um número é primo quando é divisível por si próprio e por 1.

Algoritmo Força Bruta.

É a mais simples das estratégias de projeto, pode ser definida
como uma solução direta para resolver um problema, geralmente
baseada diretamente no enunciado do problema e nas definições
dos conceitos envolvidos.Geralmente não são eficientes, mas são
fáceis de se projetar, e de se entender.

Testar a divisibilidade do número avaliado por todos os números

menores que ele.
 Algoritmo Primo_Versão 1
var numero, divisor: inteiro;
divisivel: booleano;
{Variáveis booleanas são úteis para determinara saída ou não de laços}
inicio
escreva(“Entre com um número a ser testado: “);
leia(numero);
divisivel←F;
divisor←numero -1;
enquanto(não(divisivel) e divisor>1) faça
inicio
se(numero resto divisor = 0) então
divisivel ←V;
senão
divisor←divisor – 1;
fim
se(não(divisivel)) então
escreva(“O número”,numero,”é primo”);
senão
escreva(“O número”,numero,”não é primo”);
fim
O algoritmo apresentado não é eficiente.
Otimizações possíveis:

1. Com exceção do número 2, só precisamos testar números ímpares.

2.É mais fácil um número ser divisível por um número pequeno do

que por um número maior. Portanto, se iniciarmos a procura do
divisor de baixo para cima, ao invés de cima para baixo, como foi
implementado, teremos chance de encontrar o número antes.

3. Nenhum número pode ser divisível por outro número maior que a
metade dele.Portanto, não precisamos testar a divisibilidade dos
números na faixa entre a metade e o próprio número.

Se levarmos em conta tais considerações, teremos um

algoritmo muito mais eficiente que o anterior, pois executará
muito menos instruções .
Algoritmo Primo_Versão 2
var numero, divisor: inteiro;
divisivel: booleano;
inicio
escreva(“Entre com um número a ser testado: “);
leia(numero);
divisivel←F;
se(numero resto 2 = 0 e numero >2) então {numero par ≠ de 2}
divisivel←V;
senão
divisor←3;
enquanto(não(divisivel) e divisor <=numero/2) faça
inicio
se(numero resto divisor = 0) então
divisivel ←V;
senão
divisor←divisor +2;
fim
se(não(divisivel)) então
escreva(“O número”,numero,”é primo”);
senão
escreva(“O número”,numero,”não é primo”);
fim
Pode-se demonstrar que:
Se um número não for divisível por um número menor ou igual a
sua raiz quadrada, não terá outro divisor que não ele próprio ou 1,
ou seja, será um número primo.
Portanto podemos adaptar o algoritmo Primo_Versão 2,
substituindo a linha

enquanto(não(divisivel) e divisor <=numero/2) faça

Por

enquanto(não(divisivel) e divisor <=numero raiz 2) faça

Exercício proposto: Para as entradas 15 e 29, faça testes de mesa,

para os três algoritmos que identificam um número primo e decida
qual o mais eficiente.
4. 3 Comandos de repetição encadeados

Calcular a media das notas de uma classe

Calcular a media das notas de todas as turmas da escola

Calcular a media das notas de todas as escolas de uma cidade

Deve-se usar Programação estruturada

 Algoritmo Média_Turma
var cont, alunos: inteiro;
nota, soma, media:real;
inicio
cont←0;
soma←0;
escreva(“Entre com o número de alunos”);
leia(alunos);
enquanto(cont < alunos) faça
inicio
escreva(“Entre com a nota do aluno: “, cont +1);
leia(nota);
soma=soma + nota;
cont←cont + 1;
fim
media←soma/alunos;
escreva(“A média da turma é: “,media);
fim
4.4 Comando repita
O comando repita funciona de forma similar ao comando enquanto,
exceto pelo fato de que a condição de controle só é testada após a
execução do bloco de comandos.

Sintaxe

repita
<bloco de instruções>
até <valor booleano>
<continuação do algoritmo>
Podemos utilizar repita sempre que tivermos a certeza de que o bloco
de instruções será executado ao menos uma vez, sem a necessidade
do teste na entrada do bloco.
4.4.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
Algoritmo Soma_Ímpares_Versão 2
var superior, num, soma: inteiro;
inicio
soma←0;
escreva(“Entre com o limite superior: “);
leia(superior);
num←0;
repita
inicio
num←num +1;
se(num resto 2 = 1) soma←soma+num;
fim
até(num <superior);
escreva(“A soma dos números ímpares é: “,soma);
fim
4.5 Comando para
O comando para, é uma alternativa para os comandos enquanto e
repita, em que a sintaxe é feita em uma só instrução, facilitando
assim a construção dos laços.

Sintaxe

para( preparação;condição;passo ) faça

<bloco de instruções>
<continuação do algoritmo>
A seguir o algoritmo Soma_Ímpares_Versão 2 utilizando o
comando para em vez do enquanto.

Algoritmo Soma_Ímpares_Versão4
var superior, num, soma: inteiro;
inicio
soma←0;
escreva(“Entre com o limite superior: “);
leia(superior);
para(num ←1;num<=superior;num←num+1) faça
se(num resto 2 > 0) então
soma← soma + num;
escreva(“A soma dos números ímpares é: “, soma);
Fim
O bloco de instruções do comando para só contém uma instrução(o
comando se) e, por isso, não precisa ser delimitado pelo inicio/fim.
4.5.1 Problema 19- Calcular o somatório

Faça um algoritmo que calcule a seguinte fórmula:

n
Σ(5*i+2) em que n é definido pelo usuário.
i=3

Usando o comando para:

Preparação -> i=3
Condição -> i=n
Passo -> i←i+1
 Algoritmo Somatório
var i, n. somat: inteiro;
inicio
escreva(“Entre com o limite superior: “);
leia(n);
somat←0;
para(i←3; i<=n; i←i + 1) faça
somat← somat + (5*i +2);
escreva(“ O somatório para o limite definido”, n,
“é”,somat);
fim
Exercícios propostos:

9. e 10. do livro texto (pagina 83)

Exemplos em linguagem C