Instruções de Repetição: REPEAT, WHILE e FOR
8.3 Instruções de Repetição -
Repeat, While e For
As instruções de repetição
permitem, tal como o nome indica, repetir a execução das instruções que lhe
estejam associadas. O número de repetições pode ser controlado por uma
expressão booleana ou por um valor que define o número de repetições
pretendidas. As instruções de repetição condicional utilizam o primeiro método
enquanto que as instruções de repetição com contador utilizam o último. Em Pascal,
existem duas instruções do primeiro tipo, as instruções repeat e while,
e uma do segundo, a instrução for.
8.3.1 A Instrução de Repetição
Condicional REPEAT
Se pretendermos efetuar mais do
que uma vez o cálculo da raiz quadrada ou do quadrado de um número, usando o
programa exemplificado anteriormente, sem necessitarmos de iniciar uma nova
execução do programa, podemos utilizar a instrução repeat...until
(repetir…até).
A estrutura duma instrução REPEAT... UNTIL.é a seguinte:
Nesta nova versão do programa, o utilizador terá à sua
disposição uma terceira opção: Terminar (letra T). O programa é o seguinte:
program calcvarios;
var opcao: char;
numero,
resultado : real;
begin
repeat
writeln;
writeln ('Este programa
calcula a raiz quadrada ou o quadrado de um número pedido ao utilizador');
writeln;
writeln ('R - raiz
quadrada');
writeln ('Q - quadrado');
writeln
('T - terminar');
writeln;
write ('Opção -> ');
readln (opcao);
writeln ('Introduza
um valor');
readln (numero);
case opcao of
'r' ,'R' :begin
resultado := sqrt (numero);
write ('Raiz
quadrada de ', numero :10:3);
writeln (' é igual a', resultado :10:3)
end;
'q' , 'Q'
:begin
resultado :=sqr
(numero);
write ('Quadrado de'
, numero :10:3);
writeln ('é igual a',
resultado :10:3)
end;
't' , 'T' :begin
writeln;
writeln ('Programa Terminado')
end;
else begin
writeln;
write ('Opção errada');
writeln ('deve premir R,
Q ou T')
end;
end;
until (opcao = 't') or (opcao = ' T');
readln
end.
Note que as instruções que
constituem a parte de instruções deste programa estão delimitadas pelas
palavras chave repeat e until (opcao = 't' or opcao = 'T'), ou
seja. todas essas instruções são repetidas até que opção escolhida pelo
utilizador seja a letra 't' ou
Como facilmente se pode verificar,
a repetição termina quando a expressão booleana que sucede a palavra reservada until
tiver como resultado o valor true.
Esta expressão booleana só é
calculada após a execução das instruções incluídas no ciclo repeat … until, o
que significa que essas instruções são executadas pelo menos uma vez.
8.3.1.1 Exemplos Exemplo 1:
Escrever um programa que conte
caracteres lidos do teclado e pare quando aparecer um 'S' (Sair).
Programa:
Program contar (Input,
Output)
Var Contador; integer;
Car: char;
Begin
Contador: = 0;
Writeln (Introduza
caracteres ("S" para sair).);
Repeat
Readln
(car);
Contador:=
contador + 1:
Until (car = 'S' or car = 's'):
Writeln (Total ->', Contador, 'caracteres');
End.
Exemplo 2:
Construir um programa que imprima uma tabela de
senos e cosenos dos
ângulos compreendidos entre O e 360 graus, com um intervalo de 20 graus.
Programa:
Program Tabela;
Const
PI= 3.141592;
Var
Angulo : Integer; (Angulo em Graus}
Radiano : Real; {Angulo em Radianos}
Begin
Writeln (Tabela de valores
trignométricos'); Writeln;
Writeln ('Angulo (graus) Seno Coseno');
Writeln;
Angulo:= 0;
Repeat
Radiano:= Angulo * 2 * PI
/360;
Write (' ', Angulo: 4,' ');
Write (sin. (radiano)
: 7 : 3, ' ');
Writeln
(cos (radiano)
: 7 :3);
Angulo:=Angulo + 20;
Until Angulo>360;
End.
Execução:
Tabela de valores trigonométricos
Ângulo (graus)
|
Seno
|
Coseno
|
0
|
0.000
|
1.000
|
20
|
0.342
|
0.940
|
40
|
0.643
|
0.766
|
60
|
0.866
|
0.500
|
80
|
0.985
|
0.174
|
100
|
0.985
|
- 0.174
|
120
|
0.866
|
- 0.500
|
140
|
0.643
|
- 0.766
|
160
|
0.342
|
- 0.940
|
180
|
0.000
|
- 1.000
|
200
|
- 0.342
|
- 0.940
|
220
|
- 0.643
|
- 0.766
|
240
|
- 0.866
|
- 0.500
|
260
|
- 0.985
|
- 0.174
|
280
|
- 0.985
|
0.174
|
300
|
- 0.866
|
0.500
|
320
|
- 0.643
|
0.766
|
340
|
- 0.342
|
0.940
|
360
|
- 0.000
|
1.000
|
Note que o seno e o cosseno utilizam ângulos em radianos.
Em Pascal não seria necessário
definir a constante PI pois está pré-definida.
8.3.2 A Instrução de Repetição
Condicional while
Considere-se um programa que
calcule a soma e a média aritmética
de uma série de valores
introduzidos pelo teclado.
Este programa deve, repetidamente,
ler um valor do teclado, atualizar a soma e o contador. Este último não é mais
do que uma variável que conta quantos valores já foram introduzidos. O ciclo de
repetições deve terminar quando é introduzido um valor negativo, por outras
palavras, o ciclo deve continuar enquanto os valores introduzidos são positivos
ou zero.
A estrutura duma instrução While...Do (Enquanto...Faça)
é a seguinte:
O seguinte programa efectua os
cálculos pretendidos e utiliza uma instrução while para controlar o
ciclo de repetições:
program somedia;
{calcula a soma e a média duma
série de números}
var numero, soma, media :real; contador
:integer;
begin
soma :=0;
contador :=0;
readIn (numero); {lê
o primeiro número}
while (numero>=0)
do
begin
soma := soma + numero;
contador :=contador + 1;
readln (numero)
end;
if
(contador > 0) then
begin
media :=
soma / contador ;
writeln;
writeln ('Soma =' ,
soma : 10:3, ' Media =' , media: 10:3)
end
else
begin
writeln;
writeln (Valores insuficientes p/ calcular média')
end;
writeln;
writeln ('Programa Terminado')
end.
A instrução while incluí
uma expressão booleana que, neste exemplo, é:
(numero >= 0)
Enquanto esta expressão tiver como
resultado o valor troe a instrução dependente do while é
repetida. Neste caso, essa instrução é a instrução composta que atualiza as
variáveis soma e contador e que lê um valor do teclado para a
variável numero.
8.3.2.1 Exemplo
Construir um programa
que imprima uma tabela de senos dos ângulos. Num círculo trigonométrico com
estes a variarem de 10 em 10 graus (com início em 0 e fim em 360-graus).
Programa:
Program Senos;
Const PI=
3.141592;
Var I: Integer;
Begin
Writeln ('Tabela de
cálculo de senos');
Writeln;
Writeln ('Ângulos
entre O e 360 graus de 10 em 10 graus');
Writeln;
I := 0;
While I< 360 do
Begin
Write ('Sin (', I:4,') =', sin (I * 2* PI/360) :7:3) ;
Write (' ')
I :=I + 10;
Writeln ('Sin (', I:4,') = sin * 2* PI/360) :7:3) ;
I :=I + 10:
End;
Readln
End.
Execução:
Tabela de Cálculo de Senos
Ãngulos entre O e 360 graus de 10 em 10 graus
Sin
|
(
|
0)
|
=
|
0.000
|
Sin (
|
10)
|
=
|
0.174
|
Sin
|
(
|
20)
|
=
|
0.342
|
Sin (
|
30)
|
=
|
0.500
|
Sin
|
(
|
40)
|
=
|
0.643
|
Sin (
|
50)
|
=
|
0.766
|
Sin
|
(
|
60)
|
=
|
0.866
|
Sin (
|
70)
|
=
|
0.940
|
Sin
|
(
|
80)
|
=
|
0.985
|
Sin (
|
90)
|
=
|
1.000
|
Sin
|
(
|
100)
|
=
|
0.985
|
Sin (
|
110)
|
=
|
0.940
|
Sin
|
(
|
120)
|
=
|
0.866
|
Sin (
|
130)
|
=
|
0.766
|
Sin
|
(
|
140)
|
=
|
0.643
|
Sin (
|
150)
|
=
|
0.500
|
Sin
|
(
|
160)
|
=
|
0.342
|
Sin (
|
170)
|
=
|
0.174
|
Sin
|
(
|
180)
|
=
|
0.000
|
Sin (
|
190)
|
=
|
0.174
|
Sin
|
(
|
200)
|
=
|
- 0.342
|
Sin (
|
210)
|
=
|
- 0.500
|
Sin
|
(
|
220)
|
=
|
- 0.643
|
Sin (
|
230)
|
=
|
- 0.766
|
Sin
|
(
|
240)
|
=
|
- 0.866
|
Sin (
|
250)
|
=
|
- 0.940
|
Sin
|
(
|
260)
|
=
|
- 0.985
|
Sin (
|
270)
|
=
|
- 1.000
|
Sin
|
(
|
280)
|
=
|
- 0.985
|
Sin (
|
290)
|
=
|
- 0.940
|
Sin
|
(
|
300)
|
=
|
- 0.866
|
Sin (
|
310)
|
=
|
- 0.766
|
Sin
|
(
|
320)
|
=
|
- 0.643
|
Sin (
|
330)
|
=
|
- 0.500
|
Sin
|
(
|
340)
|
=
|
- 0.342
|
Sin (
|
350)
|
=
|
- 0.174
|
8.3.3 A Instrução de Repetição
For
As instruções de repetição while
e repeat, já descritas, utilizam uma expressão booleana que
determina o momento em que o ciclo de repetições deve ser terminado. São
instruções que devem, portanto, ser aplicadas nos casos em que o número de
repetições não é fixo.
A instrução de repetição for permite
a repetição das suas instruções subordinadas um número fixo de vezes.
A estrutura dum ciclo FOR é a
seguinte:
FOR variável := expressão
TO/DOWNTO expressão. DO instrução;
|
Para, por exemplo, construir um
programa que calcule a potência de um valor (por exemplo 22 ou 55)
é necessário que a base da potência seja multiplicada um número de vezes
equivalente ao valor do expoente. Assim, para calcular, por exemplo, 25
é necessário multiplicar a base 2 cinco vezes.
O seguinte programa utiliza a instrução for para
calcular o valor de uma potência em que a base e o expoente são dados
fornecidos por teclado.
program potencia (input,
output);
var
i, expoente : integer;
resultado, base : real;
begin
writeln ('Introduza a base') ;
readln (base) ;
writeln ('Introduza o
expoente') ;
readln (expoente) ;
resultado := 1 ;
for i := 1 to expoente
do
resultado := resultado * base;
writeln (Valor da
potência', resultado 15: 3);
readln
end.
No programa exemplificado é
utilizada a instrução for com o seguinte especto:
for i := 1 to expoente do
Note que entre as palavras
reservadas for e to existe uma atribuição do valor 1 à variável 1.
Esta variável, vulgarmente conhecida como contador, tem o seu valor
incrementado em uma unidade em cada repetição.
Assim, na primeira execução da
instrução dependente resultado := resultado * base
o valor de i
é 1, na segunda é 2 e assim sucessivamente, até atingir o valor da variável expoente que
é o valor indicado como valor final de i, na instrução for. entre as
palavras reservadas to e do. A variável 1 e as expressões que
indicam o seu valor inicial, neste caso 1, e o seu valor final, neste caso
expoente, têm ser do tipo integer.
Se o
utilizador introduzir um valor, para a variável expoente, que seja menor que 1
(valor inicial), não será executada a instrução for visto que o valor
inicial é superior ao valor final indicado nesta instrução.
Considere-se agora um programa que
calcule o fatorial de um número inteiro positivo. A definição do fatorial de um número n (escrito n!) inteiro e positivo é a
seguinte:
n!=nx(n-1)x(n-2)x...x3x2x1
Por exemplo:
4 ! = 4 x 3 x 2 x 1 = 24
2 ! = 2 x 1 = 2
Um caso particular é: O ! = 1
O seguinte programa utiliza uma
instrução for para efetuar o cálculo do fatorial de um inteiro positivo
introduzido pelo teclado.
program factorial;
VAR
numero, i : integer;
fatorial : real;
begin
writeln ('Introduza um número inteiro positivo’);
readln (numero);
fatorial := 1;
for i := numero downto 1 do fatorial := fatorial * i ;
write ('Fatorial de', numero: 15); writeln ('e igual
a', fatorial :15:3); writeln ('Programa Terminado');
readln
end.
Note que neste caso a instrução for
tem a seguinte forma: for i := numero downto 1 do
A palavra_
reservada to existente no exemplo anterior foi substituída pela palavra downto ir a indicar que o valor do
contador (variável i) sofre um incremento negativo de uma unidade (-1) em cada
repetição. Por exemplo, se o valor fornecido para a variável numero for
5 a variável 1 toma esse valor durante a primeira execução da instrução
subordinada
fatorial := fatorial x i
sendo decrementada para 4 na segunda execução e assim
sucessivamente até atingir o valor final de 1 na última repetição. Neste caso
se o valor inicial for inferior ao valor final. por exemplo 0, a instrução for
não é executada.
8.3.3.1 Exemplos Exemplo(1-:)
Elaborar uma tabuada de
multiplicação de um número que é fornecido pelo utilizador.
Programa:
Program Tabuada;
Var
I, J : Integer;
Begin
Writeln (Tabuada de multiplicação'); Writeln;
Write ('Qual o valor
da tabuada?');
Readln (J);
For I :=1 To 10 Do
Begin
Writeln;
Writeln
(' ', I,' * J,' = ', I * J);
End;
Readln
End.
Execução:
Tabuada de multiplicação Qual o valor da tabuada? 38
1 * 38 = 38
2 * 38 = 76
3 * 38 = 114
4* 38 = 152
5 * 38 = 190
6 * 38 = 228
7 * 38 = 266
8* 38 = 304
9* 38 = 342
10 * 38 = 380
Exemplo 2:
Elaborar um programa que imprima
no écran uma tabela dos fatoriais dos números compreendidos entre 0 e 7.
Programa:
Program Fatoriais;
Var
I , J , K :Integer;
Begin
Writeln ('Tabela de
fatoriais de 0 ate 7');
Writeln;
For I:=0 To 7 Do
Begin
Write (' ', I, '! = 1');
k:=1;
For J:=2 To I Do
Begin
k:=k*J;
Write (' *
' , J);
End;
If k> 1 Then Write (' =', k);
writeln;
writeln;
end;
readln
end.
Note que são
usados dois ciclos FOR, um dentro do outro.
Execução:
Tabela de factoriais de 0 ate 7
0! =1
1 ! = 1
2!
= 1 * 2 = 2
3!
= 1 * 2 * 3 = 6
4!
= 1 * 2 * 3 * 4 = 24
5!
= 1 * 2 * 3 * 4 * 5 = 120
6!
= 1 * 2 * 3 * 4 * 5 * 6 = 720
7!
=1 * 2 * 3 * 4 * 5 * 6 * 7 = 5040
8.3.4 Exercícios com Instruções
de Repetição
1 - Reescreva o programa da secção
8.3.2.1 utilizando um ciclo REPEAT em vez de WHILE.
2 - Faça o mesmo
que no exercício 1 mas com um ciclo FOR.
3 - Elabore um
programa que apresente no écran as tabelas de
verdade dos operadores lógicos
AND, OR e NOT.
4 - Escreva uma sequência de
instruções, usando um ciclo REPEAT, que peça um valor do teclado e imprima uma
mensagem de erro até que o valor esteja entre 0 e 10.
5 - Faça o mesmo
que no exercício 4 mas com um ciclo WHILE.
