Escolar Documentos
Profissional Documentos
Cultura Documentos
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.
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;
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.
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);