Lógica e Linguagem de Programação

Aula 04 - Estruturas de Repetição

Repetição com Teste no Final - Repita Até
Professor: Danilo Giacobo

Este guia irá lhe ajudar a entender o laço de repetição repita-até. Ela é uma estrutura de
repetição usada para repetir um ou mais comandos baseado em uma condição que é sempre
testada no final da estrutura. Ele repete (executa) as instruções até que a condição se torne
verdadeira. Enquanto ela for falsa este laço de repetição continua executando as instruções.
Sua sintaxe, isto é, a forma de escrever corretamente o mesmo em pseudocódigo é:

repita
C1;
C2;
...
...
Cn;
até <condição>;

Onde:
 <condição> é uma expressão simples ou composta que resulte em verdadeiro ou falso;
 C1, C2, Cn são instruções válidas de um algoritmo em pseudocódigo.

O funcionamento básico do laço repita-até se resume então a:

 Executar as instruções contidas dentro do laço de repetição na sequência em que
foram escritas;
 Quando chegar ao final da estrutura (até <condição>) a condição é verificada.
 Se ela (a condição) for verdadeira, o laço de repetição é encerrado com apenas uma
repetição. Ele sempre é executado ao menos uma vez!
 Se ela (a condição) for falsa, então os comandos dentro da estrutura serão
executados novamente do início (repita) e quando chegar ao último comando a
condição é novamente testada para ver se continua a execução do laço ou não e
assim até a condição ser verdadeira e o mesmo ser encerrado.
 Um cuidado muito importante a ser tomado é escrever o laço de repetição cuja
condição possa se tornar verdadeira para que o algoritmo possa terminar sua
execução; caso contrário acontecerá o que chamamos de laço infinito ou loop infinito,
algo extremamente perigoso em um programa de computador real.
 Geralmente usamos uma variável do tipo contadora (uma variável simples do tipo
inteiro) para sabermos quantas vezes o laço de repetição já executou, assim
conseguimos controlar melhor a repetição das instruções contidas no mesmo.

A seguir serão mostrados alguns exemplos simples de utilização do laço repita-até. Algumas
partes do algoritmo serão omitidas por questões de espaço.
1. Escrever seu nome 5 (cinco) vezes. 6. Exibir uma contagem regressiva com BOOM

inteiro: contador; inteiro: contador;

contador ← 1; contador ← 10;
repita repita
escreva (“Danilo Giacobo”); escreva (contador);
contador ← contador + 1; contador ← contador - 1;
até (contador > 5); até (contador < 0);
escreva (“*** BOOOOOM ***”);
2. Escrever seu nome n vezes.
7. Realizar a soma dos números inteiros de 1 a
inteiro: contador, n; 10.
contador ← 1;
leia (n); inteiro: n, soma;
repita n ← 1;
escreva (“Danilo Giacobo”); soma ← 0;
contador ← contador + 1; repita
até (contador > n); soma ← soma + n;
n ← n + 1;
3. Escrever os números inteiros de 0 a 10. até (n > 10);
escreva (soma);
inteiro: contador;
contador ← 0; 8. Realizar a soma em separado dos números
repita pares e ímpares de 1 a 20.
escreva (contador);
contador ← contador + 1; inteiro: n, soma_p, soma_i;
até (contador > 10); n ← 1;
soma_p ← 0;
4. Escrever os números pares entre 0 e 20. soma_i ← 0;
repita
inteiro: contador; se (n mod 2 = 0) então
contador ← 0; soma_p ← soma_p + n;
repita senão
escreva (contador); soma_i ← soma_i + n;
contador ← contador + 2; fimse;
até (contador > 20); n ← n + 1;
até (n > 20);
5. Escrever os números ímpares entre 1 e 30. escreva (soma_p, soma_i);

inteiro: contador;
contador ← 1;
repita
escreva (contador);
contador ← contador + 2;
até (contador > 30);
Usando a estrutura repita-até para validação de dados
O repita-até é bastante útil em um algoritmo/programa para realizar a validação dos dados de
entrada de um processo. Como ele verifica o dado depois de lido ele se torna a estrutura ideal
para esse tipo de caso. A seguir são mostrados alguns exemplos.

Para validar se um número é positivo. Para validar se um conceito é válido e emitir uma
mensagem.
inteiro: n;
repita caracter: conceito;
leia (n); repita
até (n >= 0); leia (conceito);
se (conceito <> “A” e conceito <> “B” e conceito <>
Para validar se um número é maior que zero e “C” e conceito <> “D”) então
emitir uma mensagem. escreva (“Informe A, B, C ou D.”);
fimse;
inteiro: n; até (conceito = “A” ou conceito = “B” ou conceito = “C”
repita ou conceito = “D”);
leia (n);
se (n <= 0) então Para validar o sexo de uma pessoa.
escreva (“Informe um número maior que 0.”);
fimse; caracter: sexo;
até (n > 0); repita
leia (sexo);
Para validar se uma nota é válida (considerando 0 até (sexo = “M” ou sexo = “F”);
a 100).
Para validar o sexo de uma pessoa e emitir uma
real: nota; mensagem.
repita
leia (nota); caracter: sexo;
até (nota >= 0 e nota <= 100); repita
leia (sexo);
Para validar se uma nota é válida (considerando 0 se (sexo <> “M” e sexo <> “F”) então
a 100) e mostrar uma mensagem. escreva (“Informe M ou F.”);
fimse;
real: nota; até (sexo = “M” ou sexo = “F”);
repita
leia (nota); Para validar se uma variável do tipo inteiro qualquer
se (nota < 0 ou nota > 100) então possui um determinado valor e continuar repetindo
escreva (“Informe uma nota entre 0 e 100.”); até a pessoa informar esse valor.
fimse;
até (nota >= 0 e nota <= 100); inteiro: var;
repita
Para validar se um conceito é válido. leia (var);
até (var = 0);
caracter: conceito;
repita
leia (conceito);
até (conceito = “A” ou conceito = “B” ou conceito = “C”
ou conceito = “D”);
Usando a estrutura de repetição repita-até para repetir o algoritmo todo.
A estrutura repita-até é útil para repetir grande parte do algoritmo depois que o mesmo é executado
pela primeira vez. Nos exemplos abaixo ele é usado para pedir para a pessoa se ela quer executar
o algoritmo mais uma vez; caso ela não queria a mesma deve informar o valor que encerra o
algoritmo.
Exemplo 1: algoritmo para verificar se um número é par.
início
inteiro: n;
caracter: continuar;
repita
escreva (“Informe um número inteiro: ”);
leia (n);
se (n mod 2 = 0) então
escreva (“O número informado é par!”);
senão
escreva (“O número informado não é par!”);
fimse;
escreva (“Deseja tentar novamente (S/N)?”);
leia (continuar);
até (continuar = “N”);
fim.

Exemplo 2: algoritmo para verificar se um número é primo.

início
inteiro: n, qtde, cont;
caracter: continuar;
repita
leia (n);
qtde ← 0;
cont ← 1;
enquanto (cont <= n) faça
se (n mod cont = 0) então
qtde ← qtde + 1;
fimse;
cont ← cont + 1;
fimenquanto;
se (qtde = 2) então
escreva (“O número informado é primo!”);
senão
escreva (“O número informado não é primo!”);
fimse;
escreva (“Deseja tentar novamente (S/N)?”);
leia (continuar);
até (continuar = “N”);
fim.
Exercícios
Resolva os problemas a seguir usando a estrutura de repetição repita-até.

1. Escrever um algoritmo para mostrar os números inteiros de 0 a 10 (crescente).

2. Escrever um algoritmo para mostrar os números inteiros de 10 a 1 (decrescente).
3. Escrever um algoritmo para mostrar os números reais entre 0 e 5 (de meio em meio).
4. Escrever um algoritmo para mostrar os números inteiros maiores que um número informado
pela pessoa.
5. Escrever um algoritmo para mostrar os números inteiros menores que um número informado
pela pessoa.
6. Escolha um algoritmo qualquer que você desenvolveu usando o enquanto e modifique o
mesmo para usar a estrutura repita-até.
7. Escolha um algoritmo qualquer que você desenvolveu usando o enquanto e modifique o
mesmo para realizar a validação da entrada de dados usando a estrutura repita-até.
8. Escolha um algoritmo qualquer que você desenvolveu usando o enquanto e modifique o
mesmo para que a pessoa possa usar o algoritmo mais de uma vez usando a estrutura repita-
até.
9. Escreva um algoritmo para converter um número decimal em binário.
10. Escreva um algoritmo para ler o nome de cinco pessoas e mostrar o nome das mesmas.
11. Escreva um algoritmo para realizar a soma de um conjunto de valores inteiros informados
pela pessoa. Ela inicialmente entrará com o número de valores que ela deseja usar.
12. Escreva um algoritmo para apresentar a soma dos cem primeiros números naturais
(1+2+3+...+98+99+100).
13. Escreva um algoritmo para gerar a tabuada de um número inteiro informado pela pessoa.
Este número deverá ser maior que 0. Realize a validação de dados para isso.
14. Elabore um algoritmo que apresente o somatório dos valores pares existentes na faixa de 1
até 500.
15. Elabore um algoritmo que apresente todos os valores numéricos inteiros ímpares situados na
faixa de 0 a 20.
16. Elabore um algoritmo que apresente os valores numéricos divisíveis por 4 e menores que
200. Sugestão: a variável que controla o contador do laço deve ser iniciada com valor 1.
17. Elaborar um algoritmo que apresente os valores de conversão de graus Celsius em graus
Fahrenheit, de dez em dez graus, iniciando a contagem em dez graus Celsius e finalizando em
cem graus Celsius. O algoritmo deve mostrar os valores das duas temperaturas.
18. Elaborar um algoritmo que leia dez valores numéricos reais e apresente no final o somatório e
a média dos valores lidos.
19. Elaborar um algoritmo que leia sucessivamente valores numéricos e apresente no final o
somatório, a média e o total de valores lidos. O algoritmo deve ler os valores enquanto o usuário
estiver fornecendo valores positivos. Ou seja, o algoritmo deve parar quando o usuário fornecer
um valor negativo (menor que zero).
20. Elaborar um algoritmo que apresente os resultados da soma e da média aritmética dos
valores pares situados na faixa numérica de 50 a 70.
21. Elaborar um algoritmo que leia valores positivos inteiros até que um valor negativo seja
informado. Ao final devem ser apresentados o maior e o menor valores informados pelo usuário.
CUIDADO COM OS LAÇOS DE REPETIÇÃO “REPITA-ATÉ” INFINITOS!

lógico: teste;
teste ← verdadeiro;
repita
escreva (“Eu sou um loop infinito!”);
até (teste = falso);

repita
escreva (“Eu sou um loop infinito!”);
até (1 <> 1);

caracter: sexo;
sexo ← “M”;
repita
escreva (“Eu sou um loop infinito!”);
até (sexo <> “M”);

inteiro: X;
X ← 1;
repita
escreva (“Eu sou um loop infinito!”);
até (X = 2);

inteiro: X, Y;
X ← 1;
Y ← X;
repita
escreva (“Eu sou um loop infinito!”);
até (X <> Y);

inteiro: X;
X ← 1;
repita
escreva (“Eu sou um loop infinito!”);
até (X >= 10);

inteiro: X;
X ← 2;
repita
escreva (“Eu sou um loop infinito!”);
X ← 1;
até (X = 2);