A maior rede de estudos do Brasil

Grátis
146 pág.
livro programando com pascal - jaime evaristo

Pré-visualização | Página 20 de 50

integer: e de que a expressão que controla um 
comando case deve retornar um valor de um tipo ordenado e o tipo real não o é.
3.9 Exercícios propostos
1. Escreva um programa que realize arredondamentos de números utilizando a regra usual da 
matemática: se a parte fracionária for maior do que ou igual a 0,5, o número é arredondado para o inteiro 
imediatamente superior, caso contrário, é arredondado para o inteiro imediatamente inferior.
2. Escreva um programa para verificar se um inteiro dado é um quadrado perfeito exibindo, nos casos 
afirmativos, sua raiz quadrada.
3. Escreva um programa para determinar o maior de três números dados.
4. Escreva um programa para classificar um triângulo de lados de comprimentos dados em escaleno (os 
três lados de comprimentos diferentes), isósceles (dois lados de comprimentos iguais) ou equilátero (os três 
lados de comprimentos iguais).
5. Escreva um programa para verificar se um triângulo de lados de comprimentos dados é retângulo 
exibindo, nos casos afirmativos, sua hipotenusa e seus catetos.
6. Escreva um programa para determinar as raízes reais ou complexas de uma equação do segundo grau, 
dados os seus coeficientes.
7. Escreva um programa para determinar a idade de uma pessoa, em anos meses e dias, dadas a data (dia, 
mês e ano) do seu nascimento e a data (dia, mês e ano) atual.
8. Escreva um programa que, recebendo as quatro notas bimestrais de um aluno da escola referida no 
exemplo 8 da seção 3.5, forneça a nota mínima que ele deve obter na prova final para que ele seja aprovado.
Observação
Para receber as respostas dos exercícios propostos, encaminhe mensagem para jaime@ccen.ufal.br, 
assunto RESPOSTAS EXERCÍCIOS PASCAL, contendo NOME, INSTITUIÇÃO (se for o caso), 
CIDADE/ESTADO e CATEGORIA (docente, estudante ou auto-didata).
Capítulo 4 Estruturas de Repetição
4.1 Para que servem estruturas de repetição
Um locutor brasileiro ao narrar um jogo de basquete ou de futebol americano nos Estados Unidos recebe 
a informação do placar eletrônico sobre a temperatura do estádio medida em graus fahrenheit. Naturalmente, 
ele deve fornecer aos telespectadores brasileiros a temperatura em graus Celsius. Para isto, o locutor, de 
posse de um computador, poderia utilizar o programa abaixo, que foi solicitado no primeiro item do segundo 
exercício da seção 2.12.
{Programa que converte uma temperatura dada em Graus fahrenheit para Graus Celsius}
program ConvTemp;
var Celsius, Fahrenheit : real;
begin
writeln('Digite a temperatura em graus Fahrenheit');
readln(Fahrenheit);
Celsius := 5*(Fahrenheit - 32)/9;
writeln(Fahrenheit, ' graus Fahrenheit correspondem a ', Celsius, ' graus Celsius');
end.
Se o placar eletrônico indicasse uma temperatura de 60o F, o narrador executaria o programa com a 
entrada 60 e receberia a saída
A temperatura de 60 graus fahrenheit corresponde a 15.55 graus Celsius
Evidentemente, seria mais prático a produção da transmissão do evento disponibilizar para o locutor uma 
tabela contendo as temperaturas possíveis em graus fahrenheit e as correspondentes em graus Celsius. A 
confecção desta tabela poderia ser feita através de um programa que contivesse vários comandos que 
calculassem para cada temperatura em graus fahrenheit pretendida a correspondente temperatura em graus 
Celsius e exibissem estas temperaturas. Neste caso, não haveria necessidade de comando de entrada; porém, 
para cada temperatura em graus fahrenheit pretendida, haveria, pelo menos, um comando de atribuição e um 
comando de saída. Se a faixa de temperatura em graus fahrenheit a ser coberta pela tabela fosse de vinte 
graus a oitenta graus, teríamos um programa como o programa abaixo.
{Programa (muito ruim) que gera uma tabela de conversão de temperaturas em graus Fahrenheit para 
graus Celsius} 
program TabelaDeConversaoDeTemperatura
var fahrenheit : integer;
begin
writeln(Tabela de conversão graus Fahrenheit/graus Celsius');
writeln('-------------------------------------------------');
writeln(' Fahrenheit | Celsius');
writeln('-------------------------------------------------');
Fahrenheit = 10;
writeln(' ',Fahrenheit, ' | ', 5.0*(Fahrenheit - 32)/9);
Fahrenheit = 11;
writeln(' ',Fahrenheit, ' | ', 5.0*(Fahrenheit - 32)/9);
. . .
 {Mais "uma porção" de comandos!}
Fahrenheit = 80;
writeln(' ',Fahrenheit, ' | ', 5.0*(fahrenheit - 32)/9);
end.
Isto seria contornado se pudéssemos repetir a execução dos comandos que gerariam as temperaturas em 
graus fahrenheit e as correspondentes em graus Celsius. A linguagem Pascal possui os comandos for; while 
do e repeat until, chamados estruturas de repetição ou laços, cujas execuções redundam em repetições da 
execução de uma determinada seqüência de comandos. 
4.2 O comando for
O comando for é uma estrutura de repetição que repete a execução de uma dada seqüência de comandos 
um número de vezes que pode ser determinado pelo próprio programa, e devendo ser escrito com a seguinte 
sintaxe:
for Variavel := Expressao1 to Expressao2 do
seqüência de comandos
onde Varialvel é uma variável de um tipo ordenado (integer, char e boolean, para lembrar) que é chamada 
variável de controle da estrutura e Expressao1 e Expressao2 são expressões cujos valores são do tipo de 
dado da variável de controle (numa boa parte das vezes Expressao1 e Expressao2 são constantes, quando são 
chamadas Valor inicial e Valor final). Além disto, e como nas opções de um comando if, há a necessidade 
dos delimitadores begin e end quando a seqüência de comandos tem mais de um comando.
A semântica do comando for é a seguinte: quando da sua execução, o valor da Expressao1 é armazenado 
na variável de controle e o conteúdo desta (Vc) é comparado com o valor da Expressao2 (VFinal); se Vc <= 
VFinal, a seqüência de comandos é executada. Em seguida o conteúdo da variável de controle é 
automaticamente incrementado de uma unidade e nova comparação é feita com VFinal. Isto tudo se repete 
até que o conteúdo da variável de controle seja maior que o valor da Expressao2. 
Por exemplo, o programa
var i : integer;
begin
for i := 1 to 10 do
write(i, ' ');
end.
exibe na tela 
1 2 3 4 5 6 7 8 9 10 
enquanto que o programa
var i : integer;
begin
for i := 10 to 1 do
write(i, ' ');
end.
não exibe nada na tela, pois, quando da execução do comando for, a variável de controle i recebe o valor 10 e 
este já é maior que o Valor final 1(um), implicando a não execução da seqüência de comandos nem uma 
única vez.
Se, por alguma razão, se pretende que a variável de controle seja decrementada e, portanto, que o Valor 
final seja menor que o Valor inicial, deve-se substituir a preposição to pela "preposição" downto. Assim, o 
programa
var i : integer;
begin
for i := 5 downto 1 do
write(i, ' ');
end.
exibe na tela:
5 4 3 2 1
Com a estrutura aqui referida, a questão da geração de uma tabela de conversão de temperaturas em 
graus fahrenheit para graus Celsius seria simples.
{Programa para gerar uma tabela de conversão de temperaturas em graus Fahrenheit para graus 
Celsius}
program TabelaDeConversaoFarenheitCelsius;
uses Crt;
var Farenheit : integer;
Celsius: real;
begin
ClrScr;
writeln('Tabela de conversao graus Farenheit/graus Celsius');
writeln('-------------------------------------------------');
writeln(' Farenheit | Celsius');
writeln('-------------------------------------------------');
for Farenheit := 20 to 80 do
begin
Celsius := 5.0*(Farenheit - 32)/9;
 writeln(' ', Farenheit,' ', Celsius:0:2);
end;
end.
Na execução do comando for, a variável Fahrenheit é inicializada com o valor 20, que é comparado com 
80, a correspondente temperatura em graus Celsius é calculada e os dois valores são exibidos. Em seguida, o 
conteúdo de Fahrenheit