Antes de mais, faço votos de que se encontrem bem.  

Todos os alunos serão avaliados segundo os critérios de avaliação aprovados em Conselho Pedagógico, que se encontram disponíveis, desde o início do ano letivo, no blogue da disciplina, na pasta Avaliação, os Critérios de avaliação.

Tendo em conta que a autoavaliação escrita serve para aferir conteúdos, ficam aqui algumas diretrizes:

Sê sincero(a). Essa é, sem dúvida, a regra mais importante da autoavaliação. Mentir para ti mesmo anula o propósito do exercício e não leva a qualquer lugar. O objetivo deve ser: ter um panorama realista do teu desempenho atual.

Verifica fatos. Para não te perderes no imaginativo ou criar qualidades e defeitos, é preciso ter em conta dados concretos. Então, justifica todas as tuas conclusões, esclarece os conceitos que justificam a tua nota consultando os critérios de avaliação. Revê o teu trabalho realizado ao longo das aulas, consulta a tua pasta partilhada e outros tipos de provas como testes de avaliação.

• Para proceder à autoavaliação, descarregar o ficheiro para o computador Aqui

• Preencher o ficheiro, gravar como ficheiro PDF, com o seguinte nome de ficheiro:

 12ºturma e o seu nome, exemplo: 12ºA Ana Ferreira

•  Enviar o ficheiro para correio.aluno@gmail.com com o assunto Autoavaliação

Não sugiro algum trabalho extra pois alguns alunos iriam aproveitar-se disso para copiar trabalhos e não seria uma avaliação justa. No entanto, estou disponível para conferência online agendada, para os alunos que desejem uma avaliação extra, individual.

Desejo o melhor nestes tempos difíceis e bom trabalho.

Testes

Para o enunciado Instrução For vA,

$ Criar um programa em Pascal para ler um número (uma quantidade de números) e a seguir ler essa quantidade de números.

Depois de ler todos os números o programa deve apresentar como resultado:

·      o maior dos números inseridos;

·      o menor dos números  inseridos;

·      a média dos números inseridos.

$ Utilizar o comando For.

ver solução aqui
---------------------------------------------------------------------------------------------------------------------------------------------------------------

Para o enunciado Instrução For vB,

$ Criar um programa em Pascal para ler um número (uma quantidade de números) e a seguir ler essa quantidade de números.

Depois de ler todos os números o programa deve apresentar como resultado:

·      calcule e mostre a quantidade de números inseridos entre 30 e 90;

·      a média dos números lidos.

$ Utilizar o comando For.

ver solução aqui
---------------------------------------------------------------------------------------------------------------------------------------------------------------

Para o enunciado Instrução ForCase vA,

$ Criar um programa em Pascal em que, para um dado número de alunos introduzido pelo utilizador, dê o resultado de um exame através de um conceito de acordo com a seguinte tabela:

Intervalo da pontuação obtida	Conceito
0 a 49	D
50 a 69	C
70 a 89	B
90 a 100	A

$ Utilizar o comando Case, com as listas de valores como listas de intervalos, para obter a pontuação obtida.

$ Utilizar o comando For

ver solução aqui

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 2² ou 5⁵) é 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, 2⁵ é 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.