Documenti di Didattica
Documenti di Professioni
Documenti di Cultura
SEMESTRE
2008/1
SUMÁRIO
1 − FUNDAMENTOS DE PROGRAMAÇÃO
À especicação da seqüência ordenada de passos que deve ser seguida para a realização de uma
tarefa, garantindo a sua repetibilidade, dá-se o nome de algoritmo. Embora esta denição de algoritmo
seja correta, podemos denir algoritmo, de maneira informal e completa como:
Algoritmo pode ser denido também como um conjunto de valores como entrada e produz algum
valor ou conjunto de valores como saída. Um algoritmo deve sempre possuir pelo menos um resultado,
normalmente chamado de saída, e satisfazer a propriedade da efetividade, isto é, todas as operações
especicadas no algoritmo devem ser sucientemente básicas para que possam ser executadas de
maneira exata e num tempo nito.
2
Na prática não é importante ter-se apenas um algoritmo, mas sim, um bom algoritmo. O mais
importante de um algoritmo é a sua correção, isto é, se ele resolve realmente o problema proposto e
o faz exatamente.
Para se ter um algoritmo, é necessário:
Para que um computador possa desempenhar uma tarefa é necessário que esta seja detalhada
passo a passo, numa forma compreensível pela máquina, utilizando aquilo que se chama de programa.
Neste sentido, um programa de computador nada mais é que um algoritmo escrito numa forma
compreensível pelo computador.
i. Ler atentamente o enunciado: Deve-se reler o enunciado de um exercício quantas vezes for
necessário, até compreendê-lo completamente. A maior parte da resolução de um exercício
consiste na compreensão completa do enunciado.
ii. Retirar a relação das entradas de dados do enunciado Através do enunciado, descobrimos
quais são os dados que devem ser fornecidos ao programa, via teclado, a partir dos quais
são desenvolvidos os cálculos. Obs. Pode haver algum algoritmo que não necessite da entrada
de dados (pouco comum).
iii. Retirar do enunciado as informações de saída Através do enunciado podemos descobrir quais são
as informações que devem ser mostradas para compor o resultado nal, objetivo do algoritmo.
4. Determinar o que deve ser feito para transformar as entradas em saídas Nessa fase é que
teremos a construção do Algoritmo propriamente dito. Devemos determinar qual sequência de
passos ou ações é capaz de transformar um conjunto de dados nas informações de resultado.
Para isso, utilizamos os fatores descritos anteriormente, tais como legibilidade, portabilidade,
método cartesiano e planejamento reverso, e nalmente podemos construir o algoritmo.
3
1.1.3 EXERCÍCIOS
1a Questão) Elabore um algoritmo que mova 3 discos de uma torre de Hanói, que consiste em
3 hastes (a-b-c), uma das quais serve de suporte para os três discos de tamanhos diferentes (1-2-3),
os menores sobre os maiores. Pode-se mover um disco de cada vez para qualquer haste, sendo que
nunca deve ser colocado um disco maior sobre um menor. O objetivo é transferir os três discos da
haste A para haste C.
• Os dados propriamente ditos, que correspondem à porção das informações a serem processadas
pelo computador.
1.3 VARIÁVEIS
Na programação, uma variável é um objeto (uma posição, freqüentemente localizada na memória)
capaz de reter e representar um valor ou expressão. Enquanto as variáveis só existem em
tempo de execução, elas são associadas a nomes, chamados identicadores, durante o tempo de
desenvolvimento.
iii. Um nome de variável não poderá ser uma palavra reservada a uma instrução de programa.
5
• Salario - correto
• 1ANO - errado (não começou uma letra)
• ANO1 - correto
• SAL/HORA - errado (contém o caractere /)
• SAL_HORA - correto
• _DESCONTO - errado (não começou com uma letra)
Obviamente é interessante adotar nomes de variáveis relacionados às funções que serão exercidas
pela mesmas dentro de um programa. Outro atributo característico de uma variável é o tipo de dado
que ela pode armazenar. Este atributo dene a natureza das informações contidas na variável. Por
último há o atributo informação, que nada mais é do que a informação útil contida na variável.
Uma vez denidos, os atributos nome e tipo de dado de uma variável não podem ser alterados
e assim permanecem durante toda a sua existência, desde que o programa que a utiliza não seja
modicado. Por outro lado, o atributo informação está constantemente sujeito a mudanças de acordo
com o uxo de execução do programa. Em resumo, o conceito de variável foi criado para facilitar a
vida dos programadores, permitindo acessar informações na memória dos computadores por meio de
um nome, em vez do endereço de uma célula de memória.
Exemplo: Suponha que fosse atribuído os seguintes valores às seguintes variáveis: A = mesa, B
= 0, C = 2, D = -5.4, E = João e E = 5.656.
A gura 1.2 mostra como estas variáveis cam armazendas na memória.
• Dispositivo de entrada é o meio pelo qual as informações (mais especicamente os dados) são
transferidos pelo usuário ou pelos níveis secundários de memória ao computador. Os exemplos
mais comuns são o teclado, o mouse, leitora ótica, leitora de código de barras, as tas e discos
magnéticos.
6
• Sintaxe é a forma como os comandos devem ser escritos, a m de que possam ser entendidos
pelo tradutor de programas. A violação das regras sintáticas é considerada um erro sujeito à
pena do não reconhecimento por parte do tradutor;
• Semântica é o signicado, ou seja, o conjunto de ações que serão exercidas pelo computador
durante a execução do referido comando. Daqui em diante, todos os comando novos serão
apresentados por meio de sua sintaxe e sua semântica, isto é, a forma como devem ser escritos
e a(s) ação(ões) que executam.
1.5.1 EXERCÍCIOS
1a Questão) Dena, com suas palavras, o que é algoritmo.
2a Questão) Cite alguns algoritmos que podemos encontrar na vida quotidiana.
3a Questão)De acordo com seu entendimento, qual é a característica mais importante em um
algoritmo? Justique a sua resposta.
4a Questão) Um algoritmo não pode conter um comando como Escreva todos os números
inteiros positivos. Por quê?
5a Questão) Suponha que temos um robô a nossa disposição. Esse robô chama-se MANNY
e precisa ser ensinado a fazer determinadas tarefas. Para ensinar o MANNY, vamos fazer uso do
7
português para passar-lhe as instruções necessárias à execução de cada atividade. Escreva os passos
necessários para o nosso robô executar:
Um dos principais fatores que motivaram o surgimento da linguagem foi a obtenção de uma
linguagem simples, capaz de incentivar a edição de programas claros e facilmente legíveis, favorecendo
a utilização das boas técnicas de programação.
Assim como as outras linguagens de programação, o Pascal possui várias versões. Cada fabricante
cria sua própria versão com suas particularidades. As versões mais famosas são o Turbo Pascal, da
Borland International, e o MS-Pascal, da Microsoft. Existem versões de Pascal para todos os tipos
de computadores, desde MSX e CP-500 a computadores de grande porte como o IBM 4381.
À medida que o tempo passa, cada fabricante costuma atualizar e melhorar as versões de seus
programas. O mesmo acontece com as linguagens de programação. Em 1983, a Borland criou o Turbo
Pascal, versão 1. Essa versão inicial passou por sucessivas atualizações até que em 1991 tínhamos o
Turbo Pascal, versão 6. Neste texto, onde nos referirmos simplesmente à linguagem Pascal, estamos
nos referindo à versão 5 do Turbo Pascal, lançada em 1988.
executar os comandos básicos da linguagem. Por exemplo, você pode usar uma função trigonométrica
no seu programa fonte, e na hora dela ser executada, o computador saberá como calculá-la. Quem
é que ensina ao computador a calcular valor de função trigonométrica? A resposta a essa pergunta
é simples: toda linguagem de programação possui um conjunto de instruções básicas pronto para
ser adicionado a qualquer programa objeto. Esse conjunto de instruçÕes é a biblioteca padrão da
linguagem. O ato de ligar (link) o programa objeto à biblioteca padrão é chamado ligação (que
algumas pessoas chamam de "linkagem", talvez pelo hábito de usar neologismos). O programa objeto
após a ligação com a biblioteca padrão torna-se um programa executável.
+------------+ +------------+
| Programa | COMPILAÇÃO | Programa |
| fonte |----------->| objeto |
+------------+ +------------+ +-------------+
|----------->| Programa |
+-------------+ | executável |
| Biblioteca | +-------------+
| padrão |
+-------------+
( ) - _ $ ! @ #
+ ? * \ / | < > [ ] : ; , .
É comum um programa fonte em Pascal ter extensão PAS. Se você não mencionar a extensão
de um arquivo, o Pascal incluirá automaticamente a extensão PAS, sempre que for feito algum uso
do mesmo. Neste caso, dizemos que PAS é a extensão "default"( = omissão, falta) do Pascal. A
extensão, geralmente, classica o tipo do arquivo. Algumas extensões bastante comuns são:
Por exemplo, para um programa que trate da resolução de sistemas lineares, um nome natural
poderia ser SISTEMA.PAS. No entanto, o usuário poderia chamá-lo de @##!.)$$ se quisesse. Ambos
são nomes válidos para o Pascal, aliás, para o DOS. Se no disco aparecer também um SISTEMA.BAK
e um SISTEMA.EXE, então é muito provável que o SISTEMA.BAK seja apenas uma cópia do
SISTEMA.PAS e o SISTEMA.EXE seja sua versão executável. Outras versões de Pascal, bem como
outras linguagens de programação, costumam criar arquivos OBJ no disco, correspondentes aos
programas objeto, mas não é esse o caso do Turbo Pascal. Logo, o programa objeto correspondente
a SISTEMA.PAS será mantido apenas na memória e você não terá em disco um SISTEMA.OBJ.
11
• Cabeçalho;
• Especicação das unidades usadas pelo programa;
• Declarações de tipos, constantes, variáveis, rótulos, funções e procedimentos;
• Seção principal.
PROGRAM Nome_do_programa;
O cabeçalho é identicado pela palavra chave PROGRAM, seguida de um nome que identicará
o programa, e encerra-se com um ponto-e-vírgula. Ele serve apenas para orientação do usuário.
Exemplo:
PROGRAM Teste;
Uma linha como essa, atribui o nome Teste a um programa. A especicação das unidades
usadas é feita com um comando USES, seguido dos nomes das unidades a serem usadas separadas
por vírgula, com um ponto-e-vírgula no nal da linha:
Em Pascal, diversos comandos podem ser agrupados em conjuntos denominados unidades (units).
Temos assim uma unidade para vídeo, outra para manipulação de arquivos em disco, outra com os
comandos grácos, etc. Exemplo:
Esta declaração permite que sejam usados no programa comandos, funções, constantes, ... das
unidades CRT e GRAPH.
A seção principal do programa inicia-se com a palavra chave BEGIN, seguida de linhas de
comandos, e encerra-se com a palavra chave END seguida de um ponto:
12
BEGIN
comando1;
comando2;
... ...
END.
(3) x := a + (4) X :=
b + a + B
c;
2.1.1 IDENTIFICADORES
Um identicador é um conjunto de caracteres usado para dar nome a um programa, unidade,
rótulo, variável, tipo, constante, função ou procedimento. Todo identicador deve iniciar-se com uma
letra e pode ser seguido por qualquer quantidade de outras letras, algarismos ou o sinal de sublinhado
( _ ). Somente os 63 primeiros caracteres serão considerados signicativos. Exemplo:
Existem, ainda, alguns identicadores que, apesar de terem um signicado pré-denido para o
Pascal, não são palavras reservadas, como por exemplo: REAL, INTEGER, READ, WRITE, PI,
SIN, COS. O signicado ou a função desses identicadores podem ser redenidos e alterados pelo
usuário.
+---------------------+
| TIPOS PRÉ-DEFINIDOS |
+---------------------+
|
+-------------------------+
| |
+-----------+ +--------------+
| SIMPLES | | ESTRUTURADOS |
+-----------+ +--------------+
| |
| +---+
| |
| Array
+-----------------------+
| | |
string ordinal real
| |
+---------------+ +------------+
| | | |
boolean char inteiro +-----+
| |
| real
+----+
|
integer
Vale ressaltar que a linguagem não possui apenas os tipos abaixo, mas estes é que aparecerão em
99% dos problemas. Em resumo vamos trabalhar com o seguintes tipos:
14
- Integer - Real
- String - Char
- Boolean (Lógico) - Array
Em Pascal, as potências de 10 são indicadas com um E. Por exemplo, 2E07 é o mesmo que 2
vezes 10 elevado a 7; 3.28E-11 é o mesmo que 3,28 multiplicado por 10 à -11.
Os domínios anteriores referem-se aos valores absolutos das constantes. Com isso, temos que
o tipo real da tabela acima corresponde aos números que estão na união dos intervalos [2.9E-39,
1.7E38] e [-1.7E38, -2.9E-39]. Está sendo indicada também a quantidade de dígitos signicativos de
cada tipo.
Exemplo: TYPE
Nome = string[40];
15
Neste exemplo está sendo declarado o tipo Nome que é uma seqüência de até 40 caracteres.
Podem ser consideradas deste tipo as constantes 'Turbo Pascal 5.0', '1991/1992' e 'UFPB - CCEN -
Dep. de Matematicá.
Falaremos dos tipos restantes em capítulos posteriores.
VAR
Identificador, ..., Identificador: Tipo1;
Identificador, ..., Identificador: Tipo2;
... ...
VAR
x, y, z: real;
i, j, k: integer;
Inicio, Fim: boolean;
Tamanho: integer
Nome_do_arquivo: string[15];
Neste bloco VAR estão sendo declaradas as variáveis x, y, z como sendo do tipo real, uma variável
Tamanho do tipo integer, além de outras variáveis (i, j, ...). Os tipos das variáveis não podem ser
mudados durante a execução do programa e os valores que elas podem assumir devem ser compatíveis
com o seu tipo declarado. Por exemplo, a variável i acima pode assumir o valor 2309, mas não pode
assumir um valor fracionário como 0.71.
CONST
Identificador = Expressão;
Identificador = Expressão;
... ...
Identificador: tipo = Valor;
Identificador: tipo = Valor;
... ...
CONST
16
Pi = 3.1415926;
NumeroMaximoDeLinhas = 1024 + 253 + 5;
Mensagem: string[20] = 'Hello world!';
X: integer = 7;
As constantes que são declaradas sem a especicação de tipo não podem ser alteradas durante
a execução do programa. Aquelas cujas declarações contiverem o tipo base, chamadas constantes
tipadas, desempenham um papel parecido com o das variáveis e podem ser alteradas durante a
execução do programa. A diferença entre uma variável e uma constante tipada é que a variável não
pode ter nenhum "valor inicial"na sua declaração.
Identificador := expressão;
Neste tipo de operação, a expressão e o identicador devem ser do mesmo tipo, exceto no caso em
que o identicador for do tipo real e a expressão do tipo inteiro (pois, neste caso, o valor inteiro da
expressão será automaticamente transformado em real). Exemplo: Considere a seguinte declaracão
de variáveis:
VAR
a, b, c: integer;
x, y: real;
teste: boolean;
data: string;
a := -17;
x := y + 3.14;
teste := false;
data := '5/12/1991'
teste := a + b + 1;
c := 6.02E23;
2.1.6 COMENTÁRIOS
Comentários são usados para aumentar a clareza de um programa. Todos os comentários são
desprezados na hora da compilação, logo, eles não têm inuência no desempenho e nem no tamanho
do programa objeto. Um comentário é colocado entre chaves ou entre (* e *).
Para o Pascal, as declarações VAR abaixo serão consideradas equivalentes. Para o usuário, o
segundo bloco de declarações VAR oferece mais clareza.
VAR
mat, { matrícula }
nota, { nota final }
cod: { codigo do curso }
string;
+ Adição - Subtração
/ Divisão * Multiplicação
DIV Quociente da divisão MOD Resto da divisão
inteira inteira
Estas operações podem ser utilizadas com operandos reais ou inteiros, exceto DIV e MOD que
exigem operandos inteiros. A prioridade entre as operações é a mesma da Matemática:
Expressão Valor
------------------------
5 + 2*4 13
(5 + 2)*4 28
7 DIV 2*3 9
7 DIV (2*3) 1
------------------------
Observações:
Em todas elas deve-se acrescentar um argumento entre parênteses à frente do nome da função,
como em COS(x) ou SQRT(y). O Pascal não tem pré-denidas funções como tangente, secante,
arco-seno, ... . Em breve será mostrado como o usuário poderá denir essas funções, bem como
outras com domínio e contradomínio mais complexos.
Exemplo: O modulo do seno do quadrado de x e codicado como ABS(SIN(SQR(x))). Neste tipo
de expressão, é obrigatório que a quantidade de parênteses abertos seja a mesma de fechados.
Exemplo: O quociente entre x2 + 3x e x2 + 5 se escreve como (SQR(x) + 3*x)/(SQR(x) + 5) ou
como (x*x + 3*x)/(x*x + 5). Nestes casos, o uso dos parênteses é fundamental.
19
As funções INT e TRUNC são numericamente equivalentes. A diferença entre elas está apenas
no tipo do valor retornado.
Uma relação é uma comparação realizada entre valores do mesmo tipo, cujo resultado é TRUE
ou FALSE. A comparação é indicada por um dos operadores relacionais a seguir:
No caso de variáveis do tipo CHAR ou STRING, será usada a ordem alfabética para comparar
duas constantes ou variáveis.
Exemplo: Sejam a, b, c, d variaveis booleanas cujos valores são:
a := 1 < 2;
b := 3 >= 5;
c := a OR b;
d := a AND b;
Como 1 < 2 é uma relação verdadeira, temos que a tem valor TRUE; 3 >= 5 é falso, logo, b tem
valor FALSE. Sendo a TRUE e b FALSE temos que c é TRUE, pois a OR b só seria FALSE se a e
b fossem ambas FALSE. O valor de d é FALSE, uma vez que b é FALSE.
Exemplo: Consideremos as variaveis x, y, z, nome1, nome2 e teste declaradas abaixo:
20
VAR
x, y, z: byte;
nome1, nome2: string;
teste: boolean;
x := 3;
y := 10;
z := 4;
nome1 := 'Guizinha';
nome2 := 'Olezinho';
teste := false;
Temos então:
Expressão Valor
--------------------------------------------
x <= y TRUE
(x = z) OR (x + z >= y) FALSE
nome1 < nome2 TRUE
(nome1 <> nome2) AND (NOT teste) TRUE
(nome1 = nome2) AND (x = y) FALSE
(NOT (x > z)) OR teste OR (y <> z) TRUE
Odd(x) AND (NOT Odd(y)) TRUE
Odd(x) XOR Odd(y + 1) FALSE
(x mod 3 = 0) AND (y div 3 <> 1) FALSE
Sqr(Sin(x)) + Sqr(Cos(x)) = 1 TRUE
--------------------------------------------
A prioridade das operações aritméticas, lógicas e relacionais está denida na seguinte tabela:
Prioridade Operadores
-------------------------------------
1 (alta) NOT
2 *. /, DIV, MOD, AND
3 +, -, OR, XOR
4 (baixa) =, <=, >=, <, >, <>
-------------------------------------
2.2 EXERCÍCIOS
1a Questão) Escreva as seguintes expressões de acordo com a sintaxe do Pascal:
3 2
a) sen(2x) = 2.sen(x).cos(x) b) x + 5x - 2x + 4
21
1 arctg(x) + |x|
c) ------------------- d) e
Ln(x + Ln(x)) + 1
CONST
x: real = -3.2; y: real = 4.00;
m: integer = 7;
n: integer = 11;
p: integer = -5;
VAR
a: integer;
z: real;
i) a := 1 + 3*y;
ii) a := ((n - 1)/2) MOD 3;
iii) z := SIN(1 - COS(ARCTAN(2));
iv) z + 5 := x - y;
a) TESTE := X > Y;
b) TESTE := NOT (Abs(X*Y) >= 5e20);
c) TESTE := (X > 0) OR (Y > 10*Abs(X)) OR Classifica;
d) TESTE := (X + Y > 1) AND (Sqrt(Y) < 1.2E-9);
23
Os comandos de entrada ou saída fazem a comunicação entre o programa que está sendo executado
e os periféricos de entrada (teclado, disco) ou os de saída (vídeo, disco, impressora). A entrada ou
saída de dados para um disco será tratada em capítulo posterior.
Cada comando de leitura deve ser encerrado pressionando-se a tecla ENTER. Caso haja mais
de um dado a ser lido por um comando de leitura, deve-se separá-los por pelo menos um espaço em
branco.
Exemplo: Suponhamos que A e B sejam duas variaveis reais de um programa. Quando a execução
do programa chegar em um comando como
Read(A, B);
Então o computador cará esperando que sejam digitados dois números reais para que sejam
atribuídos às variáveis A e B. Por exemplo, digitando-se uma linha como
3.05 -5.17
Pressionando-se ENTER ao nal da digitação dos números, serão atribuídos os valores 3.05 a A
e -5.17 a B. É como se o programa contivesse as atribuições:
A := 3.05; B := -5.17;
24
Onde v1, v2, ... acima podem ser expressões envolvendo variáveis ou constantes do tipo inteiro,
real, string, booleano ou char.
Exemplo: Suponhamos que X seja uma variavel inteira de um programa, com valor 15 no momento
em que for executado o comando:
Depois posicionará o cursor no início da linha seguinte a essa na tela. Observe que a mensagem
"O valor encontrado foi "é uma constante do tipo string. Portanto, neste exemplo, o comando de
saída mostra os valores de uma constante e de uma variável.
Exemplo: Suponhamos que X, Y, Z, A, B e C sejam variaveis com valores respectivamente iguais
a ' Antonio ', ' Jose ', ' Maria ', 60, 75 e 90. Então, o comando:
WRITELN(x, a, y, b, z, c);
A seqüência de comandos:
Antonio
60
Jose
75
Maria
90
Enquanto que
Exibirá:
Em cada um desses casos, o cursor cará posicionado no início de uma nova linha.
Exemplo: Vamos elaborar agora nosso primeiro programa completo. Queremos digitar dois
números inteiros no teclado e desejamos que o computador mostre sua soma no vídeo. Sejam Num1
e Num2 os nomes das variáveis que vão guardar na memória os valores dos números digitados no
teclado. A atribuição de valores a Num1 e Num2, neste caso, será feita por um comando como
READ(Num1, Num2);
Ou como:
READLN(Num1, Num2);
No entanto, quando o computador executar esse tipo de comando, em momento nenhum ele lhe
indicará se ele está esperando um, dois, três ou mais números. Tampouco indicará o tipo de dado
que está sendo esperado, se é um dado numérico ou não. Devido a isso, é recomendado que antes de
qualquer comando READ ou READLN, o programa contenha uma linha anterior com um WRITE
ou WRITELN para mostrar alguma mensagem que oriente o usuário.
Neste caso, colocaremos um comando WRITE para mostrar a mensagem Forneca dois numeros
inteiros : .
Uma vez introduzidos os valores de Num1 e Num2, para somá- los e mostrar o resultado da soma
na tela, basta colocar a expressão Num1 + Num2 em um comando de saída:
Observe que neste WRITELN temos uma constante do tipo string 'Soma = ' e uma expressão
aritmética Num1 + Num2.
Nosso programa ca, então, com o seguinte aspecto:
PROGRAM SomaDeDoisInteiros;
VAR
Num1, Num2: integer;
BEGIN
WRITE('Forneca dois numeros inteiros : ');
READLN(Num1, Num2);
WRITELN('Soma = ', Num1 + Num2);
END.
O caracter de sublinhado _ acima representa a posição do cursor na tela. Qualquer outra saída
de dado posterior à execução do programa seria feita a partir dessa posição. Se a seção principal
deste programa fosse:
BEGIN
WRITELN('Forneca dois numeros inteiros : ');
READLN(Num1, Num2);
WRITE('Soma = ', Num1 + Num2);
END.
... ...
WRITE('Para continuar, pressione [ENTER]');
READLN;
... ...
3.3 FORMATAÇÃO
A impressão dos valores a serem impressos por um WRITE ou WRITELN pode ser formatada
através da especicação da largura do campo de impressão ou do número de casas decimais.
Para valores do tipo inteiro, booleano, string ou char, basta colocar o tamanho do campo de
impressão à direita do valor a ser impresso. Neste caso, o valor e o tamanho do campo devem estar
separados por dois pontos (:).
Se o valor de n for maior do que a quantidade necessária para a impressão do valor de V, então
a largura do campo será completada com espaços em branco adicionados à esquerda.
Exemplo: Consideremos x1, x2, s1, s2 variaveis com valores denidos pelas atribuições
x1 := 8; s1 := 'A';
x2 := 19; s2 := '*';
Para cada comando WRITE abaixo, temos as seguintes saídas mostradas na tela:
Comando Saída
---------------------------------------------------
WRITE(x1) 8
WRITE(x1:2) ^8
WRITE(x1:10) ^^^^^^^^^8
WRITE(x1, s1, x2, s2) 8A19*
WRITE(x1, ' ', s1, ' ', x2, ' ', s2) 8^Â19^*
WRITE(x1, s1:2, x2:5, s2:3) 8^Â^^19^^*
WRITE(x1:6, x2:2) ^^^^^819
WRITE(x1, ' ':5, x2) 8^^^^^19
---------------------------------------------------
28
Se o valor de M for maior do que a quantidade necessária para a impressão do valor de x, então a
largura do campo será completada com espaços em branco adicionados à esquerda. O ponto decimal
ou o sinal negativo ocupam um espaço do campo de impressão. O tamanho do campo de impressão
e a quantidade de casas decimais podem ser fornecidos em forma de expressão aritmética. Valores
reais sem formatação são impressos em forma de potências de 10.
Exemplo: Consideremos Pi e X constantes reais com valores respectivamente iguais a
3.1415926535 e -1991. A tabela a seguir mostra as diversas saídas geradas pelo respectivo comando
WRITE. Denotamos os espaços em branco por .
Comando Saída
-------------------------------------
WRITE(X:9:3) -1991.000
WRITE(X:15:2) ^^^^^^^-1991.00
WRITE(X:10:2) ^^-1991.00
WRITE(X) -1.9910000000E+03
WRITE(Pi) 3.1415926535E+00
WRITE(Pi:4:2) 3.14
WRITE(Pi:7:2) ^^^3.14
WRITE(Pi:10:3) ^^^^^3.141
WRITE(Pi:10:6) ^^3.141592
WRITE(Pi:10:8) 3.14159265
WRITE(Pi:5:0) ^^^^3
-------------------------------------
Exemplo: Vamos construir agora um programa que solicita ao usuário a medida de um ângulo
em graus (um número inteiro) e mostra na tela o seno, o cosseno e a tangente do ângulo fornecido.
As funções trigonométricas pré-denidas SIN(x) e COS(x) operam com um ângulo x em radianos.
Logo, o programa deve ser esperto o suciente para transformar o ângulo em graus, fornecido pelo
usuário, para um valor equivalente em radianos. Isto é feito através de uma multiplicação por Pi/180.
O Pascal tem o valor de Pi pré-denido com 19 casas decimais. Vamos usar três variáveis reais "seno",
"cosseno"e "tangente"para guardar os valores desejados. Vamos exigir que a impressão dos valores
seja em um campo com 8 espaços e 4 casas decimais.
PROGRAM Sen_Cos_Tg;
{ Calculo do seno, cosseno e tangente de um angulo }
VAR
29
AnguloEmGraus: INTEGER;
seno, cosseno, tangente, AnguloEmRadianos: REAL;
BEGIN { inicio da secao principal }
WRITE('Forneca a medida de um angulo (em graus) : ');
READLN(AnguloEmGraus);
WRITELN; { gera uma linha em branco }
AnguloEmRadianos := AnguloEmGraus*Pi/180; { transforma
graus em radianos }
seno := SIN(AnguloEmRadianos); { Calculo dos valores }
cosseno := COS(AnguloEmRadianos); { desejados. Lembre- }
{ se que o Pascal nao }
tangente := seno/cosseno; { tem funcao tangente }
{ pré-definida }
{ Saida dos resultados }
WRITELN('Seno de ', AnguloEmGraus, ' = ', seno:8:4);
WRITELN('Cosseno de ', AnguloEmGraus, ' = ', cosseno:8:4);
WRITELN('Tangente de ',AnguloEmGraus,' = ', tangente:8:4);
END. { fim da secao principal }
Executando-se esse programa (após a digitação correta deve-se pressionar CTRL-F9 e ALT-F5),
vemos na tela algo parecido com:
Um comando que faz parte da unidade CRT e que é bastante usado, é o comando CLRSCR (Clear
Screen) cuja nalidade, como o próprio nome sugere, é limpar a tela. Muitos dos livros sobre Pascal
disponíveis em Português, referem-se às versões anteriores à 4. Nesses livros, não é feita referência à
unidade CRT.
Exemplo: Queremos fornecer tres numeros reais a, b e c ao computador e queremos que ele nos
forneça, com três casas decimais, o valor da área do triângulo cujos lados medem a, b e c. Vamos
querer também que o computador se dê ao trabalho de limpar a tela antes de pedir os valores de a,
b, c. Vamos usar a fórmula da Geometria Plana que diz que, neste caso, a área desejada é igual à
raiz quadrada de p(p - a)(p - b)(p - c) onde p é a metade da soma a + b + c.
30
PROGRAM AreaDoTriangulo;
{
Dados os números reais a, b, ç é fornecida o valor
da área do triângulo cujos lados têm essas medidas.
}
USES CRT; { Permite o uso de comandos da unidade CRT, como
o CLRSCR. Deve ser colocado nesta posição, logo
abaixo do cabeçalho }
VAR
a, b, c, p, area: REAL;
BEGIN
CLRSCR; { Limpa a tela }
{ Leitura dos valores de a, b e c }
WRITE('Valor de a: '); READLN(a);
WRITE('Valor de b: '); READLN(b);
WRITE('Valor de c: '); READLN(c);
{ Calculo da area }
p := (a + b + c)/2;
area := SQRT(p*(p - a)*(p - b)*(p - c));
{ Impressao dos resultados na tela }
WRITELN;
WRITELN('A area do triangulo cujos lados medem');
WRITELN(a:7:3, ',', b:7:3, ' e ',c:7:3,' é' ', area:7:3);
END.
Valor de a: 5
Valor de b: 7
Valor de c: 8.4
A area do triangulo cujos lados medem
5.000, 7.000 e 8.400 é 17.479
3.4.1 EXERCÍCIOS
1a Questão) Escreva um programa em Pascal que leia duas variáveis A e B e depois calcule e
imprima a média dos valores lidos.
2a Questão) Crie um programa que leia quatro números do teclado e imprima a média deles na
tela.
3a Questão)Elabore um programa que leia cinco números do teclado e imprima o produto deles.
4a Questão)Escreva um programa que leia seis números inteiros do teclado e imprima a soma
deles.
5a Questão)Apresente o seguinte algoritmo:
i. Ler 2 valores, no caso variáveis A e B.
31
5∗(F −32)
C= 9
13a Questão) Escrever um algoritmo para calcular o volume de uma esfera sendo fornecido o
valor de seu raio.
V olume = 43 .π.R3
Dividendo:
Divisor:
Quociente:
Resto:
(1+i)2 −1
V alorCalculado = P ∗ i
Onde:
i. i = Taxa;
ii. P = Aplicação Mensal
iii. n = número de meses
Onde,
S1+S2+S3
T = 2
33
4 − ESTRUTURAS DE DECISÃO
Para resolver problemas complexos, um programa deve ser capaz de tomar decisões e escolher
uma entre várias possibilidades. Nestes casos, são necessárias avaliações bem sucedidas de condições
lógicas. O Pascal dispõe de duas estruturas que podem determinar uma direção especíca para um
programa: o comando IF-THEN-ELSE e o comando CASE.
BEGIN
ClrScr;
Write('Valor de x? ');
Readln(x)
END
Todo ponto-e-vírgula escrito antes de um END é opcional. É por isso que omitimos o
ponto-e-vírgula do Readln(x) acima. Também é comum se acrescentar alguns espaçoes em branco
nas linhas de comandos entre o BEGIN e o END (esse acréscimo de espaços em branco costuma ser
chamado endentação ou indentação). Onde a sintaxe do Pascal permitir uma instrução simples,
também permitirá um comando composto.
IF condição THEN
BEGIN
comando1;
END
ELSE
BEGIN
comando2;
END;
ou
IF condição THEN
BEGIN
comando1;
34
END;
onde condição é uma expressão booleana. Se a condição for verdadeira, isto é, for avaliada
em TRUE, então será executado o comando1; se a condição for falsa (FALSE), será executado o
comando2. Na sua segunda forma (sem o ELSE), o IF não executará nenhuma ação se a condição
for falsa.
IF IF
| |
/\ /\
TRUE / \ FALSE TRUE / \ FALSE
+-----<cond>-----+ +-----<cond>-----+
| \ / | | \ / |
| \/ | | \/ |
v v v |
+----------+ +----------+ +----------+ |
| comando1 | | comando2 | | comando1 | |
+----------+ +----------+ +----------+ |
| | | |
+--->---+---<----+ +-------<--------+
| |
O comando1 ou comando2 acima podem ser comandos compostos ou outras estruturas de decisão.
Exemplo: Consideremos a seguinte estrutura de decisão:
IF (x > 0) THEN
BEGIN
WRITE(Sqrt(x));
END
ELSE
BEGIN
x := 1;
END;
Neste caso, se x for um valor numérico positivo, então será mostrado o valor da sua raiz quadrada.
Em caso contrário, será atribuído a x o valor constante 1. A condição neste caso é a expressão lógica
x > 0, o comando1 é o WRITE(Sqrt(x)) e o comando2 é a atribuição x := 1. A condição lógica deste
exemplo não precisaria estar entre parênteses.
OBSERVAÇÃO IMPORTANTE: Não deve haver ponto-e-vírgula antes do ELSE. Se
houvesse, o ponto-e-vírgula seria considerado o nal do IF e, neste caso, o ELSE seria considerado o
comando seguinte ao IF e seria rejeitado.
Exemplo: Suponhamos que x seja uma variável real de um programa e consideremos o seguinte
IF:
END
ELSE
BEGIN
Writeln('X tem modulo >= 1');
END;
Se x em determinado momento valer 2, então a expressão booleana (x > -1) AND (x < 1)
será falsa e, assim, será mostrada na tela a mensagem X tem modulo >= 1. Os parênteses dessa
expressão booleana são essenciais. Sem eles, teríamos
Veja que o AND tem prioriade sobre os operadores de comparação > e < , caríamos com uma
expressão sem sentido equivalente a x > (-1 AND x) < 1.
Exemplo: Consideremos o seguinte fragmento de um programa, no qual estão denidas a variável
booleana CONTINUAR, a variável do tipo char RESPOSTA, e as variáveis inteiras A e B.
...
Write('Continua? (s/n) '); Readln(resposta);
Continuar := (resposta = 'S') OR (resposta = 's');
(* CONTINUAR será TRUE somente quando RESPOSTA
for um S, maiúsculo ou minúsculo *)
IF Continuar THEN
BEGIN (* Inicio do comando composto 1 *)
Write('Forneca o valor de A : ');
Readln(A);
Write('Forneca o valor de B : ');
Readln(B);
END (* Fim do comando composto 1. Nao pode ter
ponto-e-vírgula aqui *)
ELSE
BEGIN (* Inicio do comando composto 2 *)
Writeln;
Writeln('Pressione ENTER para encerrar');
Readln;
END; (* Fim do comando composto 2 e fim do IF *)
...
A função pré-denida SQRT(x) calcula a raiz quadrada de x, se x for maior do que ou igual
a 0. Portanto, se x for negativo, deveremos calcular a raiz de -x e acrescentar um "i"à direita do
resultado. Temos assim uma situação em que o programa deve decidir se calcula SQRT(x) ou se
calcula SQRT(-x), um caso típico de uma estrutura de decisão IF:
PROGRAM RaizQuadrada;
VAR
x: real;
BEGIN
Write('Valor de x? '); Readln(x);
IF (x >= 0) THEN
BEGIN
Writeln('A raiz quadrada de ', x:7:3, ' e'' ',SQRT(x):7:3);
END
ELSE
BEGIN
Writeln('A raiz quadrada de ', x:7:3, ' e'' ',SQRT(-x):7:3, ' í);
END;
END.
Exemplo: A ordem denida no conjunto das constantes do tipo string ou char é uma extensão
da ordem alfabética. As letras maiúsculas são diferenciadas das minúsculas e ocupam uma posição
anterior às mesmas. Assim, a ordem nesses conjuntos satisfaz a:
'A' < 'B' < 'C' < ... < 'Z' < ... < 'a' < 'b' < ... < 'z'
Devido a isso, temos que 'X' < 'b', 'JOAO PESSOA' < 'joao', 'Matematica' < 'logica'.
No fragmento a seguir, nome1, nome2 e aux são duas variáveis do tipo string. Queremos comparar
nome1 com nome2, e se nome1 for maior do que nome2, queremos trocar os valores de nome1
por nome2 entre si. Toda troca de valores de variáveis só é possível com a ajuda de uma variável
intermediária, que neste caso será aux.
...
IF (nome1 > nome2) THEN
BEGIN
aux := nome1; (* Troca nome1 *)
nome1 := nome2; (* por nome2 *)
nome2 := aux;
END;
Se tivéssemos, por exemplo, nome1 = 'Joaó e nome2 = 'Aná, após a execução do IF anterior
passaríamos a ter nome1 = 'Aná e nome2 = 'Joaó. Observe que um fragmento como
37
...
IF (nome1 > nome2) THEN
BEGIN
nome1 := nome2;
nome2 := nome1;
END;
...
não faria a troca desejada. Neste caso, nome1 e nome2 cariam ambas iguais a 'Ana' e o valor 'Joao'
estaria perdido.
Exemplo: O programa a seguir, testa se três números reais fornecidos pelo usuário podem ser
usados como medidas dos lados de um triângulo retângulo. Exige-se que os valores sejam todos
positivos e fornecidos em ordem crescente. Uma vez fornecido os números, o teste para saber se
eles formam um triângulo retângulo ou não será testar se o quadrado do maior deles é a soma dos
quadrados dos menores.
PROGRAM TrianguloRetangulo;
VAR
a, b, c: real;
teste: boolean;
BEGIN
Write('Forneca 3 números positivos em ordem crescente: ');
Readln(a, b, c);
teste := (a > 0) and (b > 0) and (c > 0) and (a < b) and
(b < c); (* TESTE será TRUE somente quando as
condições desejadas forem satisfeitas *)
IF teste THEN
BEGIN
IF (Sqr(c) = Sqr(a) + Sqr(b)) THEN
BEGIN
Writeln(a:6:2, ',', b:6:2, ' e ', c:6:2, ' formam um',
' triangulo retangulo.');
END
ELSE
BEGIN
Writeln(a:6:2, ',', b:6:2, ' e ', c:6:2, ' nao ',
'formam um triangulo retangulo.');
END;
END;
ELSE
BEGIN
Writeln('Os valores fornecidos devem ser positivos e ',
'em ordem crescente.');
END;
END.
Observe que temos dois IF's encaixados. O IF mais interno (IF (Sqr(c)...) só será executado
quando TESTE for TRUE.
Exemplo: Sendo fornecidos 3 números reais, o programa a seguir mostra o maior entre eles.
38
PROGRAM MaiorDeTres;
VAR
x, y, z, maior: real;
BEGIN
Write('Digite tres numeros: '); Readln(x, y, z);
Writeln;
IF (x > y) THEN
BEGIN
IF (x > z) THEN
BEGIN
maior := x;
END;
ELSE
BEGIN
maior := z;
END
END
ELSE
BEGIN
IF (y > z) THEN
BEGIN
maior := y;
END
ELSE
BEGIN
maior := z;
END;
END;
Writeln('O maior dos tres é' ', maior:6:2)
END.
Estamos colocando o módulo na parte imaginária simplesmente porque queremos que x1 tenha
parte imaginária positiva e x2 a parte imaginária negativa, independentemente de a ser positivo ou
não.
39
• Limpar a tela;
• Mostrar a equacao;
• Imprimir as raízes.
PROGRAM Eq_2o_Grau;
{ ======================================================== }
{ RESOLUCAO DE EQUACOES DO SEGUNDO GRAU }
{ ======================================================== }
USES Crt;
VAR
a, b, ç delta, x1, x2, ReX, ImX: real;
BEGIN
Writeln(' 2');
Writeln('RESOLUCAO DA EQUACAO ax + bx + c = 0');
Writeln;
Write('Forneca os coeficientes a, b, c : ');
Readln(a, b, c);
IF (a = 0) THEN { Encerra a execucao quando a = 0 }
BEGIN
Writeln('O valor de "a" nao deve ser nulo.');
HALT;
END;
{ Calculo do discriminante }
delta := Sqr(b) - 4*a*c;
IF (delta >= 0) THEN { Caso das raizes reais }
BEGIN
x1 := (-b + Sqrt(delta))/(2*a); { raiz 1 }
x2 := (-b - Sqrt(delta))/(2*a); { raiz 2 }
END
ELSE { Caso das raizes complexas }
BEGIN
ReX := (-b)/(2*a); { Parte real das raizes }
ImX := Abs(Sqrt(-delta)/(2*a)); { Parte imaginaria }
END;
ClrScr; { Limpa a tela }
Writeln(' ':19, '2');
Writeln('EQUACAO: (', a:7:2, ')x + (', b:7:2, ')x + (',
c:7:2, ') = 0');
Writeln;
IF (delta >= 0) THEN
BEGIN
Writeln('Raizes reais: ', x1:7:2, ' e ', x2:7:2);
END
ELSE
BEGIN
Writeln('Raizes complexas: ', ReX:7:2, ' + ',ImX:7:2, ' í);
Writeln(' ':18, ReX:7:2, ' - ', ImX:7:2, ' í);
END;
Readln; { pausa }
40
END.
2
EQUACAO: ( 1.00)x + ( -2.00)x + ( 3.00) = 0
Raizes complexas: 1.00 + 1.41 i
1.00 - 1.41 i
Deixamos aos usuários com uma disposição maior de trabalho o exercício de melhorar a saída
desses resultados, fazendo-a mais próxima do usual. Por exemplo, no exemplo executado acima, seria
mais interessante (e mais trabalhoso) mostrar uma linha como
2
EQUACAO: x - 2 x + 3 = 0.
Observação: Um dos aspectos que mais causam confusão com relação ao IF em qualquer
linguagem de programação é o IF encaixado (também chamado de IF aninhado). O problema consiste
na diculdade de se indenticar que ELSE está relacionado com qual IF. Nestes casos uma boa
endentação pode ajudar. Observe o seguinte IF:
IF condição1 THEN
BEGIN
IF condição2 THEN
BEGIN
comando1;
END;
END
ELSE
BEGIN
comando2;
END;
A qual dos dois IF's anteriores o ELSE se refere? A forma na qual os IF's foram escritos sugere
erroneamente que o ELSE está relacionado com o primeiro IF. No entanto, ele está relacionado com o
segundo IF. Em geral, o ELSE está ligado ao IF mais próximo. Assim, uma forma melhor de escrever
o fragmento acima é:
IF condição1 THEN
BEGIN
IF condição2 THEN
BEGIN
comando1;
END
ELSE
BEGIN
comando2;
END;
END;
41
Se quiséssemos realmente que o ELSE estivesse relacionado com o primeiro IF, então a forma
correta de se escrever seria:
IF condição1 THEN
BEGIN
IF condição2 THEN
BEGIN
comando1;
END;
END
ELSE
BEGIN
comando2;
END;
Este tipo de erro lógico em um programa, em geral, é difícil de se detectar. Ele costuma ser
chamado de "armadilha dos IF's encaixados".
2a Questão) Para os valores (a=5) (b=7) e (c=9), assinale com X a seqüência de execução dos
Algoritmos abaixo:
a)
SE a = 5 E b = 7 Entao ( )
c: c + 1 ( )
senão ( )
c := c - 1; ( )
fim-se ( )
42
b)
se a = 5 e b < 7 entao ( )
c := 1 ( )
senao ( )
se c = 8 entao ( )
c := 2 ( )
senao ( )
c := 4 ( )
fim-se ( )
fim-se ( )
4a Questão) Para as saídas, considere os seguintes valores: A=2, B=3, C=5, D=9 e E=6.
a) Resposta: _______
Se não D > 5 entao
X := (A + B) * D;
senao
X := (A - B) / C
fim-se
Escrever X
b) Resposta: _______
Se (A > 2) E (B < 7) entao
X := (A + 2) * (B - 2);
senao
43
X := (A + B) / D * (C + D)
fim-se
Escrever X
c) Resposta: ______
Se (A > 2) E (B < 7) entao
X := (A + 2) * (B - 2)
senao
X := X := (A + B) * D / (C + D)
fim-se
Escrever X
d) Resposta: ______
Se (A >= 2) OU (C < 1) Entao
X := (A + D) / 2;
senao
X := D * C;
fim-se
Escrever X
e) Resposta: ______
Se nao (A > 2) ou nao (B < 7) entao
X := A + E;
senao
X := A / E;
fim-se
Escrever X
f) Resposta: ______
Se nao (A > 3) e nao (B < 5) entao
X := A + D;
senao
X := D / B
fim-se
Escrever X
4.2.2 EXERCÍCIOS
1a Questão) Faça um programa que leia dois números inteiros A e B da entrada padrão (teclado)
e retorne o quociente da divisão entre A e B. O programa deve vericar, previamente à divisão, se o
valor de B é diferente de zero.
2a Questão) Leia um valor inteiro X e diga se ele é par ou ímpar.
3a Questão) Escreva um algoritmo para receber o sexo e a idade de uma pessoa. Se a pessoa for
do sexo feminino e tiver menos de 25 anos, imprimir o nome e a mensagem: ACEITA. Caso contrário,
imprimir o nome e a mensagem não aceita. (Considerar para o Sexo as letras F,f,M ou m).
4a Questão)Faça um programa que leia dois números inteiros A e B da entrada padrão (teclado)
e imprima o maior deles. Dê um tratamento caso estes números forem iguais.
5a Questão)Escreva um algoritmo para receber a sigla e o Estado de uma pessoa e imprimir
uma das seguintes mensagens:
44
• Carioca;
• Paulista;
• mineiro;
• Outros estados.
6a Questão)Faça um programa que leia dois inteiros A e B e imprima a soma destes valores se
eles forem iguais, senão, ou seja, se forem diferentes imprima o seu produto.
7a Questão)Leia três lados de um triângulo e diga que:
8a Questão) Escreva um algoritmo para o calcula das raízes de uma equação do segundo grau.
9a Questão)Escreva um algoritmo que leia o código de um aluno e suas três notas. Calcule a
média ponderada do aluno, considerando que o peso para a maior nota seja 4 e para as duas restantes,
3. Mostre o código do aluno, suas três notas, a média calculada e uma mensagem APROVADO se
a média for maior ou igual a 5 e "REPROVADO"se a média for menor que 5.
10a Questão) Faça um algoritmo que leia um no inteiro e mostre uma mensagem indicando se
este número é par ou ímpar, e se é positivo ou negativo.
11a Questão) Tendo como dados de entrada a altura e o sexo de uma pessoa (M masculino e F
Feminino), construa um algoritmo que calcule seu peso ideal, utilizando as seguintes fórmulas:
12a Questão)Um usuário deseja um algoritmo onde possa escolher que tipo de média deseja
calcular a partir de 3 notas. Faça um algoritmo que leia as notas, a opção escolhida pelo usuário e
calcule a média.
1 - aritmética
2 - ponderada (3,3,4)
13a Questão) Elaborar um algoritmo que lê 3 valores a,b,c e verica se eles formam ou não um
triângulo. Supor que os valores lidos são inteiros e positivos. Caso os valores formem um triângulo,
calcular e escrever a área deste triângulo. Se não formam triângulo escrever os valores lidos. ( se a >
b + c não formam triângulo algum, se a é o maior).
14a Questão) O departamento que controla o índice de poluição do meio ambiente mantém 3
grupos de indústrias que são altamente poluentes do meio ambiente. O índice de poluição aceitável
varia de 0,05 até 0,25. Se o índice sobe para 0,3 as indústrias do 1o grupo são intimadas a suspenderem
suas atividades, se o índice cresce para 0,4 as do 1o e 2o grupo são intimadas a suspenderem suas
atividades e se o índice atingir 0,5 todos os 3 grupos devem ser noticados a paralisarem suas
atividades. Escrever um algoritmo que lê o índice de poluição medido e emite a noticação adequada
aos diferentes grupos de empresas.
15a Questão) Escrever um algoritmo que leia o tempo de duração em segundos de um
determinado evento em uma fábrica e informe-o expresso no formato horas:minutos:segundos.
45
16a Questão) Escrever um algoritmo que leia a idade de uma pessoa em dias e informe-a em
anos, meses e dias. Suponha que 1 ano possua 365 dias e um mês possua 30 dias.
17a Questão)Faça um algoritmos para ler um número e imprimir se ele é igual a 5, 200 ou 400.
Se não vericar se o mesmo está no intervalo entre 500 e 1000 inclusive , ou se está fora do escopo
especicado.
18a Questão)Faça um algoritmo que leia o percurso em quilômetros, o tipo de carro e informe
o consumo estimado de combustível, sabendo-se que um carro do tipo C faz 12 Km com um litro de
gasolina, um do tipo B faz 9 Km e o do tipo A faz 8 Km por litro.
19a Questão) 19a Questão) Um endocrinologista deseja controlar a saúde de seus pacientes e,
para isso se utiliza de um índice de massa corporal (IMC). Sabendo-se que o IMC é calculado através
da fórmula abaixo:
P eso
IM C = Altura2
Onde o Peso é dado em Kg e a Altura é dada em metros. Faça um algoritmo que apresente o nome
do paciente e sua faixa de risco, baseando-se na seguinte tabela 4.2.2:
CASE expressão OF
val_1 : comando1;
val_2 : comando2;
... ...
ELSE
comandoN;
END;
O valor da expressão ordinal é avaliado e comparado com cada valor alvo val_1, val_2, ... .
Se existir algum valor alvo que coincida com o valor da expressão, então será executado apenas o
comando que estiver associado aquele valor. Se o valor da expressão não coincidir com nenhum valor
alvo, então será executado o comando que estiver associado ao ELSE, se esse comando existir. O
ELSE de um CASE é opcional. Para encerrar o CASE deveremos ter um END, mas não temos um
BEGIN para iniciar.
CASE
|
+---+ val_1 +----------+
| e |--------->----| comando1 |---->----+
| x | +----------+ |
| p | val_2 +----------+ |
| r |--------->----| comando2 |---->----+
| e | +----------+ |
| s | ... ... |
| s | |
| ã | ELSE +----------+ |
| o |--------->----| comandoN |---->----+
+---+ +----------+ |
v
Exemplo: Suponhamos que x seja uma variável inteira. Então o comando CASE abaixo executará
o comando1 quando tivermos x = 5, o comando2 quando x = 11, o comando3 quando x = -4 e o
comando4 quando x for diferente desses três valores anteriores.
CASE x OF
5 : comando1;
11 : comando2;
-4 : comando3;
ELSE
comando4;
END;
47
Em um CASE, no lugar de um único valor alvo, podemos ter um lista de valores alvo associados a
um mesmo comando. Nessa lista, os valores devem ser separados por vírgulas ou fornecidos em forma
de intervalo valor1..valor2, onde valor1 e valor2 são, respectivamente, os limites inferior e superior do
intervalo. Por exemplo, 1..1000 é uma forma abreviada de se referir aos inteiros de 1 a 1000 e 'A'..'G'
é o mesmo que 'A', 'B', 'C', 'D', 'E', 'F', 'G'.
Exemplo: Seja N inteiro que possa assumir em um programa valores de 0 a 100. Consideremos o
seguinte CASE:
CASE N OF
1, 3, 5,
7, 9 : Write('N impar, N <= 10');
2, 4, 6,
8, 10 : Write('N par, N <= 10');
11..20 : Write('11 <= N <= 20');
21..100 : Write('21 <= N <= 100');
END;
De acordo com o valor de N, será mostrada apenas uma das mensagens "N impar, N <= 10",
"N par, N <= 10", "11 <= N <= 20"ou "21 <= N <= 100".
Exemplo: Consideremos no CASE abaixo, CH como uma variável do tipo ordinal char.
CASE Ch OF
'A'..'Z', 'a'..'z' :
Writeln('E'' uma letrá);
'0'..'9':
Writeln('E'' um algarismó);
'+', '-', '/', '*':
Writeln('E'' uma operacaó);
ELSE
Writeln('E'' um caracter especial');
END;
De acordo com o valor de CH, será mostrada uma mensagem especíca, dizendo se CH é letra,
digito, operador ou símbolo especial ('<', ' ?', '[', '$', '%', ...)
Exemplo: O programa a seguir lê dois números reais A e B do teclado e mostra na tela um menu
onde o usuário poderá selecionar uma das operações A+B, A-B, A/B, A*B ou A elevado a B. Uma
vez feita a escolha da operação, seu resultado será mostrado na tela. Para ler qual foi o número da
opção do menu, poderíamos usar um READLN(opcao), mas não vamos usá-lo. Vamos usar um outro
comando de entrada chamado READKEY. Sua sintaxe é:
Variável := READKEY;
O READKEY espera que seja digitado um caracter do teclado e o associa à variável do tipo
char escrita antes do símbolo de atribuição ( := ). Além disso, READKEY não mostra o caracter
digitado na tela, nem espera ser pressionado ENTER. Os comandos CASE e READKEY são ideais
para serem usados em menus.
PROGRAM Menu;
48
USES Crt;
VAR a, b, resultado: real;
opcao, pausa: char;
BEGIN
Write('Forneca dois numeros: '); Readln(a, b);
Writeln;
ClrScr;
Writeln; (* Impressao do menu na tela *)
Writeln('=================== M E N U ==================');
Writeln('| |');
Writeln('| A = ',a:9:3,' |');
Writeln('| B = ',b:9:3,' |');
Writeln('| |');
Writeln('+--------------------------------------------+');
Writeln('| |');
Writeln('| 1. A + B 4. A/B |');
Writeln('| 2. A - B B |');
Writeln('| 3. A*B 5. A |');
Writeln('| |');
Writeln('======== Selecione uma opcao de 1 a 5 ========');
Writeln;
opcao := READKEY; { Le um caracter do teclado }
CASE opcao OF { Calcula o resultado desejado }
'1' : resultado := A + B;
'2' : resultado := A - B;
'3' : resultado := A*B;
'4' : IF (B <> 0) THEN { A/B nao será calculado }
resultado := A/B { se B = 0 }
ELSE
BEGIN
Writeln('Opcao invalida neste caso.');
Halt
END;
'5' : IF (A > 0) THEN { B }
resultado := Exp(B*Ln(A)) { A só será }
ELSE { calculado se }
BEGIN { A for positivo }
Writeln('Opcao invalida neste caso.');
Halt
END;
END; { fim do CASE }
{ Mostra o resultado na tela }
Writeln;
Writeln('Opcao = ', opcao, ' Resultado = ',
resultado:9:3);
Writeln;
Writeln('Pressione qualquer tecla para encerrar.');
pausa := READKEY
END.
49
4.4 EXERCÍCIOS
1a Questão) Em que situações é mais indicado o uso da estrutura CASE-OF ?
2a Questão) Em que situações não podemos utilizar a estrutura CASE-OF ?
3a Questão)Desenvolva um programa que leias dois números inteiros da entrada padrão com os
nomes A e B e, em seguida, implemente um menu principal com as seguintes opções:
a. A + B
b. A - B
c. A * B
d. A / B
Idade Classificação
0 até 3 Bebê
4 até 10 Criança
11 até 18 Adolescente
Acima de 18 Adulto
6a Questão) Supondo que a cobrança de imposto de renda na fonte seja feita com base na tabela
abaixo, elabore um programa que mostre na tela o valor do imposto, quando o usuário fornecer o
valor do salário (inteiro).
+------------------------+----------+-------------------+
| salario (em Cr$) | alíquota | parcela a deduzir |
+------------------------+----------+-------------------+
| até 200000 | ---- | ----- |
| de 200001 a 300000 | 5% | 10000 |
| de 300001 a 400000 | 10% | 25000 |
| de 400001 a 500000 | 15% | 45000 |
| a partir de 500001 | 20% | 70000 |
+------------------------+----------+-------------------+
Por exemplo, para um salário de 350000, temos uma alíquota de 10valor do imposto, segundo a
tabela, deverá ser de
7a Questão) Em cada caso abaixo, determine o valor do inteiro x após a execução do seguinte
CASE, sabendo que o valor do inteiro y antes da execução do CASE é:
50
a) y = 7; CASE y OF
-10..0 : x := 5;
b) y = -7; 2, 4 : x := y div 2 + Sqr(y - 1);
5..10 : BEGIN
c) y = 2; IF Odd(y) THEN y := 12;
x := Round(Sqrt(y + 5))
d) y = -2; END;
ELSE
e) y = 20 IF y > 4 THEN x := 0 ELSE x := 1;
END;
51
5 − ESTRUTURAS DE REPETIÇÃO
Observe que:
• VARIÁVEL é a variável de controle do FOR, que deve ser do tipo ordinal (integer).
• VALORINICIAL é o valor que a variável de controle assumirá na primeira iteração. Deve ser
do mesmo tipo da variável de controle.
• VALORFINAL é o valor que a variável de controle assumirá na última iteração. Deve ser do
mesmo tipo da variável de controle.
• COMANDO é o comando que será executado em cada iteração. Pode ser uma seqüência
nita de outros comandos delimitada por BEGIN-END (comando composto). Se ValorInicial
<= ValorFinal, então deve ser usado um FOR-TO. Caso contrário, deve ser usado um
FOR-DOWNTO.
ii. Antes de cada iteração subseqüente, a variável de controle recebe o próximo valor (no caso do
FOR-TO) ou o valor anterior (no caso do FOR-DOWNTO) do intervalo ValorInicial..ValorFinal
(ou ValorFinal..ValorInicial).
ii. A variável i passa a ter o valor seguinte ao anterior, ou seja, i passa a valer 2 e o comando é
executado. É mostrado, então, o quadrado de 2 na tela.
iii. A variável de controle i vai ser aumentada de uma em uma unidade e a cada acréscimo o
WRITELN é executado. Esse processo acaba quando a variável atingir o valor 5.
No entanto,
FOR i := 100 TO 50 DO
BEGIN
comando;
END;
FOR j := 1 DOWNTO 20 DO
BEGIN
comando;
END;
53
No FOR i... e no FOR j... acima, o comando escrito após o DO não será executado nenhuma vez.
Exemplo: A variável de controle do FOR, quando for numérica, terá de ser do tipo inteiro e só
poderá aumentar ou diminuir de 1 em 1. Podemos multiplicar ou dividir essa variável todas as vezes
em que ela aparecer no comando, como forma de aumentar ou diminuir o valor do incremento em
cada iteração. Por exemplo,
lista todos os pares de 0 a 100, e FOR i := 200 DOWNTO 100 DO Writeln(ArcTan(i/100)) lista os
valores de ArcTan(2), ArcTan(1.99), ArcTan(1.98),... até ArcTan(1).
Exemplo: Os tipos pré-denidos byte e char ambos têm 256 valores. As funções que estabelem
uma bijeção entre esses valores são as funções ORD e CHR, inversas uma da outra.
Os valores que o n acima podem assumir são de 0 a 255 e o x desde o primeiro ao último caracter
pré-denido do computador (de um total de 256).
CHR(n) também pode ser denotado como #n. Alguns valores particulares dessas funções são:
As tabelas de valores de CHR ou ORD costumam ser chamadas de tabelas ASCII (American
Standard Code for Information Interchange). O programa a seguir, gera na tela uma tabela ASCII.
PROGRAM TabelaASCII;
{ ---------------------------------------- }
{ TABELA ASCII }
{ ---------------------------------------- }
USES Crt;
VAR
i: byte;
BEGIN
ClrScr;
Writeln(' n Chr(n)');
Writeln('-----------');
FOR i := 0 TO 255 DO
BEGIN
54
Writeln(i:4, Chr(i):4);
IF (i MOD 10 = 0) AND (i > 0) THEN
BEGIN
Writeln;
Writeln('Pressione [ENTER] para continuar.');
Readln;
Writeln(' n Chr(n)');
Writeln('-----------');
END; { fim do IF }
END; { fim do FOR }
END. { fim do programa }
No programa acima, a variável inteira i varia de 0 a 255. Devido ao IF (i MOD 10...) , sempre
que i for maior que 0 e múltiplo de 10 , o programa fará uma pausa. Ao ser pressionado a tecla
ENTER, serão mostradas mais 10 linhas da tabela e assim o programa prossegue até chegar em i =
255. Alguns caracteres ASCII são símbolos que não podem ser impressos. Por exemplo, o #7 é um
som de bip (beep).
Ao ser executado, ele gera na tela varios trechos como esse:
n Chr(n)
-----------
61 =
62 >
63 ?
64 @
65 A
66 B
67 C
68 D
69 E
70 F
PROGRAM Somatorio;
{ ------------------------------------------- }
{ CALCULO DE UM SOMATORIO }
{ ------------------------------------------- }
VAR
S: real;
n: integer;
CONST
IndiceInicial = 1;
55
IndiceFinal = 5;
BEGIN
S := 0; { valor inicial de S }
FOR n := IndiceInicial TO IndiceFinal DO
BEGIN
S := S + 1/(Sqr(n) + 1);
END;
Writeln('Valor do somatorio = ', S:8:4);
END.
S := 0;
S := 0 + 1/2; ( n = 1 )
S := 1/2 + 1/5; ( n = 2 )
S := (1/2 + 1/5) + 1/10; ( n = 3 )
S := (1/2 + 1/5 + 1/10) + 1/17; ( n = 4 )
S := (1/2 + 1/5 + 1/10 + 1/17) + 1/26; ( n = 5 )
Exemplo: Neste exemplo, queremos calcular a soma dos 10000 primeiros termos das séries cujos
termos gerais são n1 e n12 . Não vamos nos contentar só com o resultado nal, queremos acompanhar o
valor do somatório de 1000 em 1000 termos. A série 1/n2 converge para (π 2 )/6; logo, a raiz quadrada
de 6 vezes o somatório de 1/n2 fornece uma aproximação para o valor de π .
Usaremos quatro caracteres ASCII especiais: o #227 que é um pi minúsculo, o #228 que é
um sigma maiúsculo, o #253 que é um expoente 2 e o #247 que usaremos como símbolo de
aproximadamente.
A unidade CRT dispõe de dois comandos para alterar as cores de textos da tela. São eles o
TEXTCOLOR, para alterar a cor do texto, e TEXTBACKGROUND, para alterar a cor de fundo.
Suas sintaxes são:
TextColor(Nome_da_cor)
TextBackground(Nome_da_cor)
Black = 0; Blue = 1;
Green = 2; Cyan = 3;
Red = 4; Magenta = 5;
Brown = 6; LightGray = 7;
DarkGray = 8; LightBlue = 9;
LightGreen = 10; LightCyan = 11;
LightRed = 12; LightMagenta = 13;
Yellow = 14; White = 15;
Blink = 128;
56
Em cada caso, pode ser usado o nome ou o número da cor. Deve-se somar blink ou 128 ao
nome ou número da cor do texto para se ter caracteres piscantes. Por exemplo, TextColor(Yellow) é
o mesmo que TextColor(14) e ajusta a cor do texto para amarelo. Se somarmos 128 a 14, como em
TextColor(14 + 128) teremos um amarelo piscante.
Usaremos esses comandos para alterar a cor do cabeçalho do programa; queremos vê-lo em vídeo
reverso (letras pretas em fundo branco).
PROGRAM DoisSomatorios;
{ =================================================== }
{ CALCULO SIMULTANEO DE DOIS SOMATORIOS }
{ =================================================== }
USES
Crt;
VAR
n: integer;
Soma1, Soma2: real;
BEGIN
ClrScr;
Writeln;
TextColor(Black);
TextBackground(White);
Writeln(' ', #228, ' 1/n ', #228,
' 1/n', #253, ' ');
TextColor(White);
TextBackground(Black);
Writeln;
Soma1 := 0;
Soma2 := 0; (* valores iniciais dos somatorios *)
FOR n := 1 TO 10000 DO
BEGIN
Soma1 := Soma1 + 1/n;
Soma2 := Soma2 + 1/Sqr(n);
IF (n MOD 1000 = 0) THEN (* Se n for multiplo *)
BEGIN
Writeln(Soma1:10:6, Soma2:10:6); (* de 1000, entao *)
END;
END; (* é mostrada o valor da soma parcial. *)
Writeln;
Writeln(' ', #227, ' ', #247, ' ', Sqrt(6*Soma2):8:6);
END.
Após a execução, vemos na tela a listagem a seguir. Onde escrevemos S, π e =, aparecem
na tela, respectivamente, um sigma maiúsculo, um pi minúsculo e um símbolo de aproximação.
S 1/n S 1/n^2
7.485471 1.643935
8.178368 1.644434
8.583750 1.644601
8.871390 1.644684
57
9.094509 1.644734
9.276814 1.644767
9.430953 1.644791
9.564475 1.644809
9.682251 1.644823
9.787606 1.644834
Pi = 3.141497
Vemos na última linha da tabela acima que o valor das somas dos 10000 termos das séries é
9.787606 e 1.644834.
Exemplo: Fornecido um inteiro n, vamos construir um programa que forneça o fatorial de n.
Vamos chamar a variável que vai guardar o valor do produto de P. Inicialmente, deveremos
fazer P := 1. Aliás, para calcularmos repetidamente uma determinada operação, deveremos fazer
inicialmente a variável que vai guardar o resultado nal igual ao elemento nêutro da operação. A
seguir, usamos um FOR com um comando do tipo P := P*Termo_Geral, o que, neste caso, é P :=
P*n ("n"é o termo geral do produto neste caso).
Temos então o seguinte:
PROGRAM Fatorial;
VAR
i, n: integer;
P: real;
BEGIN
Write('Valor de N? ');
Readln(n);
P := 1;
FOR i := 2 TO n DO
BEGIN
P := P * i;
END;
Writeln;
Writeln(n, '! = ', P);
END.
P := 1;
P := 1*2; ( i = 2 )
P := (1*2)*3; ( i = 3 )
P := (1*2*3)*4; ( i = 4 )
... ... ...
P := (1*2*...*(n-1))*n; ( i = n )
Valor de N? 3
58
3! = 6.00000000+E0000
Exemplo: Fornecido um inteiro N, queremos agora um programa que diga se N é primo ou não.
Nosso algoritmo será o seguinte: faremos uma variável i variar de 2 até o inteiro mais próximo da raiz
quadrada de N. Usaremos um FOR i... para isso. Para cada valor de i, calculamos o resto da divisão
de N por i, ou seja, N MOD i. Se houver algum resto nulo, isto é, se N MOD i = 0 para algum i, isto
signica que N é divisível por i e, portanto, N nesse caso não é primo. Se não acontecer de N MOD
i = 0 com i variando de 2 até ROUND(SQRT(N)), então N é primo.
PROGRAM Primo;
VAR N, i: integer;
BEGIN
Write('Forneca um inteiro N : '); Readln(N);
IF (N < 0) THEN
BEGIN
N := -N; { se N for negativo, então ele }
END;
{ terá seu sinal trocado }
IF (N <= 1) THEN { casos particulares }
BEGIN
Writeln(N, ' nao e'' primo.'); { N = 0 e N = 1 }
END
ELSE
BEGIN { caso geral }
FOR i := 2 TO Round(Sqrt(N)) DO
BEGIN
IF (N MOD i = 0) THEN
BEGIN
Writeln(N, ' nao e'' primo');
Halt; { encerra o programa }
END;
END;
{ No caso do FOR encerrar com N MOD i <> 0 para
todo i, temos que N e' primo: }
Writeln(N, ' e'' primo.');
END; { fim do IF }
END.
Forneca um inteiro N : 13
13 e' primo.
Exemplo: A variável de controle de um FOR também pode ser do tipo booleano. Neste exemplo
faremos um programa que imprime uma tabela-verdade de uma determinada expressão lógica. Para
isso, usaremos dois FOR encaixados para gerar todas as "entradas"da tabela. A expressão lógica
deste exemplo é (X OR Y) AND (NOT X OR NOT Y) que denotaremos por (X v Y) ( X v Y).
59
PROGRAM TabelaVerdade;
VAR
x, y, expressao: boolean;
BEGIN
Writeln;
Writeln('--------------------------------');
Writeln(' X Y (X v Y) ^ (~X v ~Y)');
Writeln('--------------------------------');
for x := FALSE to TRUE do
begin
for y := FALSE TO TRUE do
begin
if x then
begin
Write(' V ');
end
else
begin
Write(' F ');
end;
if y then
begin
Write(' V ');
end
else
begin
Write(' F ');
end;
expressao := (x OR y) AND (NOT x OR NOT y);
if expressao then
begin
Writeln(' V');
end;
else
begin
Writeln(' F');
end;
end; (* fim do FOR y ... *)
end; (* fim do FOR x *)
Writeln('--------------------------------')
END.
O único comando do FOR x ... é o FOR y ... . No caso de laços FOR encaixados, o FOR mais
interno varia mais rapidamente que o mais externo.
Executando-se esse programa, temos a seguinte tabela:
--------------------------------
X Y (X v Y) ^ (~X v ~Y)
--------------------------------
F F F
F V V
60
V F V
V V F
--------------------------------
Observando a tabela acima, podemos concluir que a expressão (x OR y) AND (NOT x OR NOT
y) é equivalente ao ou exclusivo x XOR y.
5.1.1 EXERCÍCIOS
1a Questão) Faça um algoritmo que um nome e imprima-o quantas vezes for a quantidade de
caracteres do seu nome.
2a Questão) Faça um Programa que leia a nota de PRI e PRII de 5 alunos. Calcule e exiba a
média e situação de cada aluno, ou seja >= 7,0 aprovado, entre 7,0 e 4,0 Prova Final e menor que 4
Reprovado.
3a Questão) Escreva um algoritmo que gere o números de 1000 a 1999 e escreva aqueles que
dividido por 11 dão resto igual a 5.
4a Questão) Apresente o quadrado de cada um dos números pares entre 1 e 1000, inclusive.
5a Questão) Leia 2 valores: X e Y. A seguir, calcule e mostre a soma dos números impares entre
eles.
6a Questão) Leia 2 valores: X e Y. A seguir, calcule e mostre a soma dos números pares entre
eles.
7a Questão) Foi feita uma pesquisa entre os habitantes de uma região. Foram coletados os dados
de idade, sexo (M/F) e salário de 10 pessoas. Faça um algoritmo que informe:
1 x N = N
2 x N = 2N
...
10 x N = 10N
1
1 2
1 2 3
1 2 3 4
61
1 2 3 4 5
1 2 3 4 5 6
1 2 3 4 5 6 7
1 2 3 4 5 6 7 8
1 2 3 4 5 6 7 8 9
12a Questão) Escreva um algoritmo que leia um número n (número de termos de uma progressão
aritmética), a1 ( o primeiro termo da progressão) e r (a razão da progressão) e escreva os n termos
desta progressão, bem como a soma dos elementos.
13a Questão)Escrever um algoritmo que leia um número n e mostre o número lido e seu fatorial.
14a Questão) Escrever um algoritmo que calcule e mostre a média aritmética dos números lidos
entre 13 e 73.
15a Questão) Escrever um algoritmo que gera e escreve os números ímpares entre 100 e 200.
16a Questão) Escreva um algoritmo que lê um valor n inteiro e positivo e que calcula a seguinte
soma:
1
S =1+ 2
+ 13 + 41 + .... + 1
n
H = 10 + 10 + 10 + ... + 10
O algoritmo deve ler um número n (inteiro e positivo) e mostrar o resultado nal de H. A soma deve
ser calculada apenas uma vez.
22a Questão) Escrever um algoritmo/programa em Pascal que lê um número e calcula e escreve
quantos divisores ele possui.
23a Questão) Escrever um algoritmo/programa em Pascal que escreve os números primos entre
100 e 200, bem como a soma destes números.
24a Questão) Faça um algoritmo que leia oito nomes e infome a quantidade de letras de cada
um deles.
1 1 1 1 1
E =1+ 1!
+ 2!
+ 3!
+ 4!
+ .... + n!
3a Questão) A série de Fibonacci tem como dados os 2 primeiros termos da série que são
respectivamente 0 e 1. A partir deles, os demais termos são construídos pela seguinte regra: tn =
tn−1 + tn−2 . Escrever um algoritmo/programa em Pascal que gera os 10 primeiros termos da Série de
Fibonacci e calcula e escreve a soma destes termos.
WHILE expressão DO
BEGIN
comando;
END;
onde expressão é uma expressão booleana e comando é uma instrução simples ou um comando
composto.
O WHILE funciona da seguinte maneira: enquanto a expressão booleana for verdadeira, o
comando após o DO será executado repetidamente. A expressão é reavaliada após cada execução
do comando. O laço WHILE só se encerra quando a expressão for falsa. Se a expressão for falsa já
quando o WHILE se inicia, então o comando não será executado nenhuma vez. No comando, deve ter
alguma instrução que possa modicar o valor da expressão booleana, senão o WHILE será executado
indenidamente.
WHILE
|
/\
FALSE / \
+--<--<cond>---<--+
| \ / |
| \/ |
v | TRUE ^
| v |
| +---------+ |
| | comando |->-+
| +---------+
v
Exemplo:
...
x := 11;
WHILE (x < 1992) DO
BEGIN
Write(x:5);
x := x + 11;
END;
...
63
i. Após a atribuição inicial (que é recomendada em todo WHILE) é avaliada a expressão booleana
x < 1992. Sendo ela verdadeira (porque 11 < 1992), o comando composto entre o BEGIN e o
END é executado. Desse modo, 11 é mostrado na tela e a atribuição x := x + 11 é executada
e x passa a valer 11 + 11 = 22.
ii. A expressão x < 1992 é reavaliada com x = 22 e é novamente verdadeira. O comando composto
então é executado mais uma vez e x passa a valer 22 + 11 = 33.
iv. Quando a expressão for falsa, o laço WHILE se encerrará e o controle do programa passará
para o comando seguinte ao WHILE.
Assim, o fragmento acima mostra na tela todos os múltiplos de 11 que são menores que 1992.
Assumimos, implicitamente, que x é inteiro. No WHILE as variáveis podem ser de qualquer tipo:
inteiro, real, string, ... .
Exemplo: O programa a seguir conta quantos termos do tipo 1/n com n inteiro e n >= 1 são
necessários somar para se obter um resultado maior do que 15.
PROGRAM ContaParcelas;
(* 1 1
Determina a quantidade de termos de 1 + --- + --- + ...
2 3
que é necessário somar para se ter uma soma > 15. *)
VAR
n: integer;
soma: real;
BEGIN
soma := 0; (* Valores iniciais das variáveis *)
n := 0; (* usadas no WHILE *)
WHILE soma <= 15 DO (* "ENQUANTO a soma não for *)
BEGIN (* maior que 15 ... *)
n := n + 1;
soma := soma + 1/n; (* ... some termos da forma 1/n" *)
END;
Writeln('Deve-se somar ', n, ' parcelas.');
END.
Neste exemplo não há possibilidade de se usar um comando como o FOR porque não se sabe
a quantidade de vezes que o comando soma := soma + 1/n deve ser executado. A "resposta"do
programa acima é que deve-se somar 1.835.421 termos do tipo 1/n para se ter uma soma maior do
que 15.
Observação: O comando FOR pode ser considerado como um caso particular de WHILE. É o
que está exemplicado nos fragmentos abaixo, onde todas as variáveis são inteiras.
i := LimInf;
FOR i := LimInf TO LimSup DO <--> WHILE i <= LimSup DO
64
comando; BEGIN
comando;
i := i + 1;
END;
5.2.1 EXERCÍCIOS
1a Questão) Chico tem 1,50 metro e cresce 2 centímetros por ano, enquanto Zé tem 1,10 metro
e cresce 3 centímetros por ano. Construa um algoritmo que calcule e imprima quantos anos serão
necessários para que Zé seja maior que Chico.
2a Questão) Construir um algoritmo que calcule a média aritmética de vários valores inteiros
positivos, lidos externamente. O nal da leitura acontecerá quando for lido um valor negativo.
3a Questão)Faça um programa que mostre um menu com as opções:
1. Cadastro
2. Consulta
3. Relatorio
4. Fim
O programa deve exibir o menu acima, mostrando a opção escolhida e, em seguida, repetindo a
exibição do mesmo até que o usuário escolha a opção 4.
4a Questão) Escreva um algoritmo que calcule a média dos números digitados pelo usuário, se
eles forem pares. Termine a leitura se o usuário digitar zero (0). OBS: O valor (zero) não entra para
o cálculo da Média.
5a Questão) Em uma eleição presidencial existem quatro candidatos. Os votos são informados
através de códigos. Os dados utilizados para a contagem dos votos obedecem à seguinte codicação:
• Número do consumidor
Os dados devem ser lidos até que o consumidor número 0 (zero) seja informado. Para cada
consumidor informar: o custo total, o total de consumo para os três tipos de consumidores e a média
de consumo para os consumidores do tipo 1 e 2.
10a Questão) Ler várias idades e imprimir:
11a Questão) Escrever um algoritmo que leia um conjunto de pedidos de compra e calcule o
valor total da compra. Cada pedido e composto pelos seguintes campos:
• Número do pedido
• Preço unitário
• Quantidade.
O algoritmos deverá processar os pedidos até que o pedidos de número 0 (zero) seja digitado pelo
usuário.
12a Questão) Escrever um algoritmo que leia um número m de valores e calcule a média
aritmética dos valores lidos, a quantidade de valores positivos, a quantidade de valores negativos
e o percentual de valores negativos e positivos. Mostre os resultados.
13a Questão) Faça um algoritmo que leia várias prossões e informar quantos são dentistas
(Considerar a palavra destista escrita de seguinte forma: DESTISTA, dentista, Dentista).
14a Questão) Faça um algoritmo que leia N Números e imprima o maior deles. O algoritmo
deve ser nalizado quando o usuário digitar 0 (zero).
15a Questão) Escrever um algoritmo que leia um conjunto de vários endereço IP de uma máquina
no formato xxx.xxx.xxx.xxx. Crie uma variável para número do formato especicado. Logo após
informe qual a classe dessa máquina: A, B, C ou D. O nal do do algoritmo deve ser quando o
usuário informar todos os valores sendo 0 (zero).
REPEAT
comando1;
comando2;
...
UNTIL expressão;
onde expressão é uma expressão booleana e comando1, comando2, ... são instruções simples ou
comandos compostos. Neste caso os delimitadores BEGIN/END não são necessários, pois as palavras
chave REPEAT e UNTIL funcionam como delimitadores. No REPEAT-UNTIL os comandos entre
o REPEAT e o UNTIL serão executados ATÉ que a expressão booleana seja verdadeira. Como a
avaliação da expressão é feita no nal do laço, os comandos serão executados pelo menos uma vez.
REPEAT
|
+---------+
| comando |--<--+
+---------+ |
| |
UNTIL ^
/\ |
/ \ FALSE |
<cond>---->----+
\ /
\/
| TRUE
v
Observação: Um REPEAT-UNTIL tem o mesmo efeito que um WHILE com a expressão booleana
que controla o laço negada:
PROGRAM Nomes;
(* Comentário:
-----------
Este programa é útil porque ele mostra que computador
também sabe contar nomes digitados. *)
VAR
nome: string;
cont: integer;
BEGIN
cont := 0;
REPEAT
Write('Nome? ');
Readln(nome); (* Cada vez que um nome for lido *)
cont := cont + 1; (* o contador de nomes CONT é *)
(* incrementado de 1 unidade *)
UNTIL (nome = 'FIM') OR (nome = 'fim');
Writeln('Foram digitados ', cont - 1, ' nomes.');
END.
A variável CONT que conta os nomes digitados ao nal da execução do REPEAT-UNTIL terá
contado a senha de parada (FIM ou m) como sendo mais um nome. Devido a isso, usamos CONT
- 1, e não CONT, no Writeln nal.
Exemplo: Neste exemplo, queremos digitar vários números maiores do que ou iguais a zero e
queremos que o programa nos dê o valor de sua média aritmética. A princípio, não temos uma
previsão da quantidade de números que será digitada. No entanto, podemos convencionar que quando
se digitar um número negativo, signicará que nossa relação de números acabou. O número negativo
que funciona como o aviso do m da relação, não deve ser considerado na média aritmética.
À medida que cada número positivo for fornecido, uma variável deverá ir sendo incrementada de
1 em 1 para se contar quantos números foram digitados. Além disso, vamos calculando o somatório
dos valores, assim que cada número for digitado.
Temos aqui algo que será executado VÁRIAS vezes. Como não temos previsão inicial exata da
quantidade de iterações temos um caso em que é receitado um WHILE ou um REPEAT- UNTIL.
Resta apenas o usuário se decidir entre um dos dois. Neste caso, excepcionalmente, vamos dar duas
versões para este programa: a versão WHILE e a versão REPEAT-UNTIL.
PROGRAM AdvinhacaoDeUmNumero;
(*
É chutado um numero inteiro entre 0 e 10000 que o
usuario deve tentar advinhar.
*)
USES Crt;
VAR n, tentativa, numero: integer;
69
BEGIN
n := 0;
Randomize;
numero := Random(10001);
Writeln('Adivinhe o numero aleatorio gerado entre 0',
' e 10000!');
REPEAT
Write('> '); Readln(tentativa);
n := n + 1;
IF tentativa > numero THEN
BEGIN
Writeln('Chute muito altó);
END
ELSE
BEGIN
IF tentativa < numero THEN
BEGIN
Writeln('Chute muito baixó);
END;
END;
UNTIL (tentativa = numero);
Writeln('Acertou! (apos ter tentado ', n, ' vezes)');
END.
Exemplo: A série
1 1 1 1
S =1− 33
+ 53
+ 73
+ 93
+ ....
GOTOXY(coluna, linha);
Por exemplo, GOTOXY(5, 2) posiciona o cursor na quinta coluna e segunda linha da tela. Em
modo texto, a tela tem 25 linhas e 80 colunas.
PROGRAM Soma_Alternada_De_1_Sobre_O_Cubo_De_2n_Menos_1;
USES
Crt;
(* ---
Calculo de S = \ n+1 -3
/ (-1) (2n - 1)
--- *)
70
VAR
t, S: real;
n: integer;
BEGIN
S := 0; (* Variável que guardará a soma desejada *)
n := 0; (* Contador de termos (índice do termo *)
ClrScr; (* geral) *)
REPEAT
n := n + 1;
t := EXP(-3*LN(2*n - 1)); (* termo geral *)
IF Odd(n) THEN
BEGIN
S := S + t; (* Se n for ímpar, então soma-se *)
END
ELSE (* t a S; caso contrário, sub- *)
BEGIN
S := S - t; (* trai-se t de S. *)
END;
GOTOXY(10, 10); (* Posiciona o cursor na 10a. coluna *)
(* e 10a. linha da tela *)
Write('n = ', n, ' ', t:13:10); (* mostra o índice *)
(* atual e o valor do termo geral *)
UNTIL t < 1E-10;
Writeln; Writeln;
Writeln('Soma = ', S:15:10);
Writeln('Foram somados ', n, ' termos');
END.
Exemplo: A função booleana KEYPRESSED da unidade CRT pode ser usada para vericar se
em determinado momento foi pressionada alguma tecla. Ela é TRUE quando for pressionada qualquer
tecla e FALSE em caso contrário. O programinha a seguir, gera aleatoriamente cores e caracteres do
intervalo #50..#250 e ca mostrando-os na tela até ser pressionado qualquer tecla. Para isso, usamos
um RANDOM(16) para gerar um número de cor de 0 a 15, um RANDOM(201) + 50 para gerar um
número inteiro de 50 a 250 e um REPEAT ... UNTIL KEYPRESSED para repetir o processo até ser
pressionada alguma tecla. A cor do texto pode ser piscante ou não, dependendo de RANDOM(2) em
cor1 gerar um 0 ou um 1.
PROGRAM UsandoKeyPressed;
USES
Crt;
VAR
ch: char;
cor1, cor2: byte;
BEGIN
ClrScr;
Randomize;
repeat
cor1 := Random(16) + 128*Random(2);
cor2 := Random(16);
TextColor(cor1);
TextBackground(cor2);
71
Exemplo: Neste último exemplo deste capítulo, vamos usar 3 comandos da unidade CRT para
gerar sons com determinadas freqüência e duração. São eles:
i. Usamos o SOUND para emitir um som cuja freqüência é a da nota desejada. Para isso, devemos
consultar antes uma tabela de freqüência de sons;
Usaremos o READKEY para vericar qual tecla foi pressionada no teclado e um CASE para
emitir um som que corresponda à nota desejada. Vamos convencionar que o "Q"emite um dó, o
"W"um ré, ... . As teclas que não constarem dos alvos do CASE não emitirão sons. Precisamos
também de um REPEAT-UNTIL para repetir o processo de "pressionar tecla e emitir som"até que
READKEY retorne o caracter #27, que corresponde à tecla ESC.
PROGRAM Piano;
USES
Crt;
CONST
TeclaESC = #27;
VAR
ch: char;
BEGIN
ClrScr;
GoToXY(18, 10);
Writeln('Toque sua musica usando as teclas QWERTYUIOP[]');
GoToXY(18, 12);
Writeln('Exemplo: QQWQRE QQWQTRR YYIYREW UUYRTRR');
GoToXY(18, 14);
Writeln('Para encerrar, pressione a tecla ESC.');
REPEAT
ch := ReadKey;
CASE ch OF
'Q', 'q' : Sound(262); { dó }
'W', 'w' : Sound(294); { ré }
'E', 'e' : Sound(330); { mi }
'R', 'r' : Sound(350); { fá }
'T', 't' : Sound(396); { sol }
'Y', 'y' : Sound(440); { lá }
72
5.3.1 EXERCÍCIOS
1a Questão) Faça um algoritmo para calcular o fatorial de um número x, dado como entrada
pelo usuário. Verique se o número é positivo. OBS: Utilize o Repeat.
2a Questão)Faça um algoritmo que leia n números e imprima somente os pares. O algoritmo
deve nalizar quando for digitado o valor 0. OBS: Utilize o Repeat.
3a Questão) Faça um algoritmo que leia n números e calcule a soma dos números pares. O
algoritmo deve nalizar quando for digitado o valor 0. OBS: Utilize o Repeat.
4a Questão) Faça um algoritmo que leia n números e calcule o produto dos números ímpares.
O algoritmo deve nalizar quando for digitado o valor 1. OBS: Utilize o Repeat.
5a Questão) Escrever um algoritmo que leia um número m de valores e calcule a média aritmética
dos valores lidos, a quantidade de valores positivos, a quantidade de valores negativos e o percentual
de valores negativos e positivos. Mostre os resultados.
6a Questão) Faça um algoritmo que leia N Números e imprima o maior deles. O algoritmo deve
ser nalizado quando o usuário digitar 0 (zero).
7a Questão) Faça um algoritmo que leia N Números e imprima o maior deles. O algoritmo deve
ser nalizado quando o usuário digitar 0 (zero).
8a Questão) Escreva um programa Pascal que apresente o menu de opções abaixo:
OPÇÕES:
1 - SAUDAÇÃO
2 - BRONCA
3 - FELICITAÇÃO
0 - FIM
O programa deve ler a opção do usuário e exibir, para cada opção, a respectiva mensagem:
Enquanto a opção for diferente de 0 (zero) deve-se continuar apresentando as opções. OBS: Use como
estrutura de repetição o comando REPEAT e como estrutura condicional o comando CASE.
73
6 − FUNÇÕES E PROCEDIMENTOS
6.1 FUNÇÕES
O Pascal oferece muitas facilidades para a confecção de programas modularizados. A
modularização consiste na divisão de um programa longo em várias partes, chamadas subprogramas,
cada uma funcionando de forma independente das outras, cada uma realizando tarefas especícas
controladas por um núcleo comum, chamado programa principal.
+--------------------------+
| Programa principal |
+--------------------------+
^ ^ ^
/ | \
v v v
+------------+ +------------+ +------------+
| Subprogr_1 | | Subprogr_2 | | Subprogr_3 |
+------------+ +------------+ +------------+
^
|
v
+------------+
| Subprogr_4 |
+------------+
Cada subrotina funciona como se fosse um pequeno programa, com suas próprias variáveis, suas
próprias denições de tipos, seus próprios subrotinas, etc. Cada vez que um subrotina é chamado,
ele é executado, e após o término de sua execução, o controle do programa volta ao comando que
vier depois do ponto de onde o subrotina foi chamado. Em Pascal podemos ter subrotinas de dois
tipos: as funções (FUNCTIONS) e os procedimentos (PROCEDURES).
i. Um cabeçalho (ou protótipo) identicado pela palavra chave FUNCTION, seguida do nome
da função, da lista de parâmetros e tipos entre parênteses e separados entre si por vírgulas, de
um sinal de dois pontos e do tipo do valor que será retornado pela função. Parâmetros de tipos
diferentes devem ser separados por ponto-e-vírgula.
ii. Uma área de declarações de tipos, variáveis, constantes, rótulos, funções ou procedimentos.
74
iii. A denição da função delimitada pelas palavras chave BEGIN e END, com um ponto-e-vírgula
no nal. O valor de retorno da função é denida por uma atribuição do tipo:
Nome_da_função := Valor;
O valor retornado por uma função pode ser do tipo inteiro, real, boolean, string, char, entre
outros.
Exemplo: O cabeçalho de uma função F com parâmetro x inteiro e que retorne um valor inteiro
(ou seja, F : Z > Z) deve ser declarado como:
Uma função G com três parâmetros a, b, c do tipo shortint e que retorne um valor real, deve ser
declarada como:
No caso da função F deste exemplo, ela será chamada para ser executada sempre que aparecer
no programa uma expressão do tipo F(expr), onde "expr"é qualquer constante, variável ou expressão
do tipo inteiro. Já a função G, ela pode ser chamada colocando-se em qualquer lugar do programa
algo como G(expr1, expr2, expr3), onde "expr1", "expr2", "expr3"são expressão do tipo shortint.
Exemplo: Neste exemplo, deniremos uma função logaritmo decimal Log10(x) que, por denição,
será igual ao quociente Ln(x)/Ln(10). Como queremos que o argumento x da função seja sempre um
número real, então na linha do cabeçalho da função colocamos FUNCTION Log10(x: real). Para que
ela retorne um valor real, nalizamos a linha do cabeçalho com ": real; "Dessa forma, o cabeçalho
da função dene seu domínio e contradomínio.
A seguir, entre os delimitadores BEGIN/END, denimos o valor que a função deve retornar.
Neste caso, a atribuição é feita ao nome da função, e não ao nome seguido do parâmetro. Uma
atribuição como Log10(x) := Ln(x)/Ln(10) está errada.
Uma versão mais elaborada, deveria vericar se o argumento x é válido ou não. Temos então:
end;
END;
Todo programa que queira usar essa função LOG10, deverá tê-la denida na sua área de
declarações:
PROGRAM LogaritmoDecimal;
VAR
num: real;
FUNCTION Log10(x: real): real;
BEGIN
Log10 := Ln(x)/Ln(10);
END; (* fim da definição da função *)
BEGIN
Write('Forneca um numero real positivo: '); Readln(num);
Writeln('O logaritmo decimal de ', num, ' é' ',
Log10(num):8:4);
END. (* fim do programa *)
Exemplo: Se os parâmetros da função forem de tipos diferentes, então a lista de parâmetros deve
separar os tipos por ponto-e-vírgula. Por exemplo, uma função TESTE que tenha os parâmetros x, y
do tipo real e m, n do tipo integer e que retorne um valor do tipo integer deverá ter como cabeçalho:
Uma função F que tenha parâmetros a real, n inteiro e c1, c2, c3 do tipo char e que retorne um
string:
Exemplo: Neste exemplo vamos construir um programa que use duas funções: MAX(x, y) e
MIN(x, y).
PROGRAM MaxMin;
VAR
a, b: real;
FUNCTION Max(x, y: real): real;
(* Função MAX ---> retorna o maior valor entre x e y *)
BEGIN
if (x >= y) then
begin
Max := x;
end
else
begin
Max := y;
end;
76
for i := 2 to n do
begin
prod_aux := prod_aux * i;
end;
Fat := prod_aux
end;
end;
END; (* fim da definição da função *)
Precisamos de uma variável auxiliar (prod_aux) para guardar o valor do fatorial, porque uma
atribuição como Fat := Fat * i não é permitida (só seria possível se Fat fosse uma variável).
Um exemplo de um programa que use esta função é:
PROGRAM UsandoFat;
(* Lista os valores de n!, com 0 <= n <= 12 *)
VAR
i: integer; (* este "i" não tem nenhuma relação com o "i"
da função FAT *)
(* Nesta área, suponhamos que esteja escrita a FAT acima. *)
BEGIN
Writeln(' n n!');
for i := 0 to 12 do
begin
Writeln(i:2, Fat(i):12);
end;
END.
Exemplo: Neste exemplo deniremos uma função CURSO que associa a alguns números inteiros,
nomes de cursos da UFPB.
Suponhamos que esta função esteja denida em um arquivo do disco chamado CURSOS.PAS
(basta digitá-la, pressionar F2, digitar CURSOS e pressionar ENTER). Para incluí-la em qualquer
programa em Pascal, basta usar uma diretiva de inclusão, cuja sintaxe é,
78
{$I NomeDoArquivo.Extensao}
Todo programa que contiver uma diretiva como essa, na hora em que o programa for compilado,
o Pascal incluirá no lugar da diretiva o referido arquivo. Para que uma diretiva de inclusão não seja
confundida com um comentário, não deve haver espaços em branco entre a chave e o $I.
PROGRAM CursosDaUFPB;
{$I CURSOS.PAS} (* inclui o arquivo CURSOS.PAS *)
VAR
n: integer;
BEGIN
Write('Forneca o numero do curso: ');
Readln(n);
Writeln('---> O curso ', n, ' e '' ', Curso(n))
END.
Exemplo: Neste exemplo, construiremos uma função do tipo string que, dado um inteiro n e
um caracter x, então o valor da função no ponto (n, x) deverá ser o caracter x repetido n vezes.
Chamaremos a função de REPETE. Para as variáveis do tipo string está denida uma operação
de soma, que na verdade é uma concatenação. Se X, Y são strings, X + Y = string formado pela
junção de X com Y. Por exemplo, 'Para' + 'iba' = 'Paraiba', '19' + '92' = '1992', 'Jose' + 'Maria'
= 'JoseMaria', etc. Toda variável char, pode ser considerada um string de comprimento 1. Assim,
temos também, 'Á + 'B' = 'AB', etc. Para repetir o caracter x por n vezes, faremos um somatório
de strings:
Str_aux := ''
Str_aux := '' + 'x' = 'x' (n = 1)
Str_aux := 'x' + 'x' = 'xx' (n = 2)
Str_aux := 'xx' + 'x' = 'xxx' (n = 3)
Str_aux := 'xxx' + 'x' = 'xxxx' (n = 4)
... ... ...
VAR
i: integer;
Str_aux: string;
BEGIN
Str_aux := '';
for i := 1 to n do
begin
Str_aux := Str_aux + x;
end;
Repete := Str_aux;
END;
Para uso futuro, grave no disco esta função sob o nome de REPETE.PAS. Por exemplo,
REPETE(6, '*') = '******', REPETE(10, '%') = '%%%%%%%%%%', REPETE(0, 'A') = , etc.
Um exemplo de uso dessa função é:
79
PROGRAM Testando_a_funcao_Repete;
VAR
i: integer;
ch: char;
{$I REPETE.PAS}
BEGIN
Write('Caracter a ser repetido? '); Readln(ch);
Write('Quantidade de vezes? '); Readln(i);
Writeln;
Writeln('REPETE (', i, ', ', ch, ') = ', Repete(i, ch))
END.
PROGRAM Testando_a_funcao_Repete_2;
USES
Crt;
VAR
i: integer;
ch: char;
{$I REPETE.PAS}
BEGIN
Randomize;
repeat
i := Random(50); (* i é um inteiro qualquer de 0 a 49 *)
ch := Chr(Random(255));
Writeln;
Writeln('REPETE (', i, ', ', ch, ') = ', Repete(i, ch));
Delay(1000); (* pausa de 1 segundo *)
until 1 > 2
END.
{ ======================================================== }
{ FUNCOES TRIGONOMETRICAS }
{ ======================================================== }
function Tg(x: real): real; { Tangente }
begin
if Cos(x) = 0 then
begin
Halt; { parametro invalido }
end;
Tg := Sin(x)/Cos(x)
end;
{ -------------------------------------------------------- }
80
{ -------------------------------------------------------- }
{ ======================================================== }
{ FUNCOES HIPERBOLICAS }
{ ======================================================== }
function Senh(x: real): real; { Seno hiperbolico }
begin
Senh := (Exp(x) - Exp(-x))/2
end;
{ -------------------------------------------------------- }
function Cosh(x: real): real; { Cosseno hiperbolico }
begin
Cosh := (Exp(x) + Exp(-x))/2
end;
{ -------------------------------------------------------- }
function Tgh(x: real): real; { Tangente hiperbolica }
begin
Tgh := (Exp(x) - Exp(-x))/(Exp(x) + Exp(-x))
end;
{ -------------------------------------------------------- }
function ArcSenh(x: real): real; { Arco-seno hiperbolico }
begin
ArcSenh := Ln(x + Sqrt(Sqr(x) + 1))
end;
{ -------------------------------------------------------- }
function ArcCosh(x: real): real; { Arco-cosseno hiperbolico}
begin
if (x < 1) then
begin
82
Exemplo: Deniremos neste exemplo uma função booleana chamada PRIMO(n) que será TRUE
se n for primo e FALSE em caso contrário.
END;
Gravando-se esta função no disco sob o nome de PRIMO.PAS, podemos usar o seguinte programa
que lista todos os primos de 1 a 1000000:
PROGRAM ListagemDePrimos;
{$I PRIMO} (* ---> A extensão .PAS pode ser omitida *)
VAR
i: integer;
BEGIN
for i := 1 to 10000 do
if Primo(i) then Writeln(i:8, ' e'' primo.')
END.
Exemplo: Vamos construir agora nossa função potência POT(x, y) = x y. Para uso posterior,
vamos salvá-la em disco sob o nome de POT.PAS. Identicaremos com 0 todo número que, em
módulo, seja menor do que 10−10 .
begin
Pot := Exp(y*Ln(x));
end
else (* Caso geral com x < 0 *)
begin
if (Frac(y) > epsilon) and (1 - Frac(Abs(y)) > epsilon) then
begin
Writeln('ERRO: Base negativa e expoente ', 'fracionario.');
Halt;
end
else
begin
if Odd(Round(y)) then (* y impar, x < 0 *)
begin
Pot := -Exp(y*Ln(-x));
end
else (* y par, x < 0 *)
begin
Pot := Exp(y*Ln(-x));
end;
end;
end;
end;
end;
end;
END;
A função POT assim denida não é conveniente para o cálculo de raízes. Como exercício,
desenvolva uma função Raiz(n, x) = raiz n-ésima de x. Como um programa-exemplo do uso de
POT, temos:
PROGRAM Potencias;
{$I POT.PAS}
VAR
x, y: real;
BEGIN
repeat
Write('x = '); Readln(x);
Write('y = '); Readln(y);
Writeln;
Writeln('x^y = ', Pot(x, y):8:3);
Writeln;
until 1 > 2
END.
Exemplo: Este último exemplo desta seção, testa se um número inteiro positivo é potência de dois
ou não. Construímos a função boolean POTENCIADEDOIS(n) que é TRUE se n for uma potência
de 2 e é FALSE em caso contrário. Grave no disco esta função sob o nome de POT_2.PAS para ser
usada futuramente. O algoritmo usado foi o seguinte: são feitas sucessivas divisões de n por 2 até se
encontrar um número ímpar. Se o número ímpar assim encontrado for 1, então o n é potência de 2;
caso contrário, n não é potência de 2.
85
Como exemplo de utilização dessa função, temos o programa abaixo que lista as potências de 2
de 1 a 100000.
PROGRAM Potencia_de_2;
{$I POT_2}
VAR
x: integer;
BEGIN
for x := 1 to 100000 do
begin
if PotenciaDeDois(x) then
begin
Writeln(x, ' e'' potencia de dois');
end;
end;
END.
BEGIN
aux := 0;
for k := 1 to n do
begin
aux := aux + sin(k*x)/k;
end;
FSerie := aux
END;
Exemplo: A função a seguir é uma aproximação para a função exponencial de base E. Trata-se
da função denida pelos 11 primeiros termos da série de Taylor de EXP(x).
Usamos na sua denição duas funções denidas anteriormente: FAT e POT.
6.2 PROCEDIMENTOS
6.2.1 DEFINIÇÃO, PROCEDIMENTOS SEM PARÂMETROS
Um procedimento (procedure) é um trecho de programa que possui seus próprios objetos
(variáveis, constantes, tipos, funções, outros procedimentos, ...) . Juntamente com as funções,
os procedimentos formam o que se chama genericamente de subrotinas (ou subprogramas). Os
procedimentos diferem das funções apenas pelo fato das funções retornarem sempre um único valor,
enquanto que os procedimentos não retornam valor algum. A criação de um procedimento em Pascal
é feita através de sua declaração na área de declarações do programa. Um procedimento possui um
cabeçalho, identicado pela palavra reservada PROCEDURE seguida do nome do procedimento e
uma lista opcional de parâmetros. Segue-se ao cabeçalho um bloco de declarações dos objetos locais
do procedimento, e um bloco de comandos delimitados pelas palavras chave BEGIN e END com um
ponto-e-vírgula no nal:
comando2;
...
END;
PROGRAM Teste;
VAR x, y, z: real;
BEGIN
comando1;
comando2;
x := função1;
y := função2;
comando3;
comando1;
comando2;
x := função1;
z := Cos(x);
comando4;
comando1;
comando2;
x := função1;
comando5;
END.
comando1;
comando2;
x := função1;
se repete no programa. Neste caso, seria mais prático se declarar esse trecho como sendo
um procedimento, digamos que com nome REPETE, e assim, toda vez que o trecho aparecesse,
simplesmente colocaríamos a palavra REPETE no seu lugar:
PROGRAM Teste;
VAR x, y, z: real;
PROCEDURE REPETE;
BEGIN (* inicio do procedimento *)
comando1;
88
comando2;
x := função1;
END; (* fim do procedimento *)
i. Ler os inteiros;
ii. Calcular sua soma;
iii. Mostrar seu resultado.
PROGRAM SomaDeInteiros;
VAR
x, y, soma: integer;
PROCEDURE LerNumeros;
BEGIN
Writeln;
Write('Forneca o valor de x : '); Readln(x);
Write('Forneca o valor de y : '); Readln(y);
END; (* fim de LerNumeros *)
PROCEDURE CalcularSoma;
BEGIN
soma := x + y;
END; (* fim de CalcularSoma *)
PROCEDURE MostrarResultado;
BEGIN
Writeln;
Writeln('Soma = ', soma);
Writeln;
Write('Pressione ENTER para encerrar.');
Readln;
END; (* fim de MostrarResultado *)
89
Neste exemplo, as variáveis X, Y, SOMA são do conhecimento de todo o programa pois elas foram
denidas fora de qualquer procedimento ou função. Dizemos que variáveis assim são globais. O uso de
variáveis globais deve globais ser evitado, pois pode levar a erros difíceis de serem detectados. O uso
de parâmetros evita o uso abusivo de variáveis globais. O programa cou grande, mas ca mais fácil de
se ler uma vez que cada parte do programa executa uma tarefa especíca. Podemos estar interessado
apenas na saída dos resultados, e aí, bastaríamos olhar o procedimento MOSTRARRESULTADO e
ignorar os demais. O programa ca também mais fácil de se consertar ou de se fazer mudanças.
Cada variável listada no cabeçalho de um procedimento será considerada uma variável local.
Portanto, outras partes do programa nem ao menos têm conhecimento dessas variáveis, mesmo que
tenham o mesmo nome. Um "x"usado no cabeçalho de um procedimento normalmente não tem
nenhuma relação com um outro "x"do programa principal.
Um procedimento que tenha este cabeçalho, está preparado para aceitar exatamente 3 inteiros
quando ele for ativado. Um comando no programa como TESTE(1, 2, 3), forçará a execução do
procedimento TESTE com os valores dos parâmetros a = 1, b = 2 e c = 3. TESTE parece uma
função de 3 variáveis inteiras, mas observe a grande diferença de que nenhum valor é retornado, ou
seja, não há nada que possa servir de contradomínio para TESTE.
Estão erradas as seguindes chamadas a TESTE: TESTE(3,5), TESTE(6, 5, 2, -1) e TESTE(3.2,
-1.0, 7).
Exemplo: PROCEDURE TesteDois(nome: string; mat: integer); Com esta declaração, uma
chamada a TESTEDOIS pode ser feita como
ou como
No último caso, a execução do procedimento TESTEDOIS está sendo chamada com os parâmetros
mat = 92101234 e nome = 'Antonio A Bragá.
Exemplo: Uma chamada ao procedimento a seguir pode ser usada no lugar dos dois comandos
TEXTCOLOR e TEXTBACKGROUND que compõem o procedimento.
Por exemplo, o comando Cor(7, 3) faz o mesmo efeito que o par de comandos TextColor(7) e
TextBackground(3).
Quando um procedimento é chamado, o Pascal faz uma cópia na memória de cada argumento
para que a cópia seja usada pelo procedimento. As operações executadas com as cópias não alteram
os valores dos argumentos originais. Para evitar que o Pascal faça cópia de variável e passe para
o procedimento a própria variável para ser usada, deve-se colocar a palavra chave VAR antes do
nome da variável na lista de parâmetros no cabeçalho. Neste caso, qualquer modicação feita com o
parâmetro durante a execução do procedimento afetará o valor da variável original que foi passada
como parâmetro. É de fundamental importância saber quando se deve usar ou não a palavra VAR
antes de um parâmetro no cabeçalho de um procedimento. O uso do VAR onde não for necessário
não constitui erro, mas não é recomendado.
Exemplo:
IncrementaUm(a, b, c);
teremos a = 10, b = 12 e c = 12. Observe que apenas o valor de b é alterado, pois é o único parâmetro
precedido por um VAR no cabeçalho.
Se o cabeçalho fosse
o que é equivalente a
IncrementaUm(a, b, c);
Troca(x, y);
teremos x = 2 e y = 1.
Se não houver o VAR no cabeçalho do procedimento, então os valores de x e y não serão alterados
após Troca(x, y).
Exemplo: Toda função pode ser substituída por um procedimento:
PROGRAM CalculandoMaisUmaVezOFatorialDeN;
USES
Crt;
VAR
n: integer; (* variaveis *)
m: integer; (* globais *)
PROCEDURE Encerrar;
92
BEGIN
Writeln;
Writeln('Valor de n invalido.');
Writeln;
Halt;
END;
Exemplo: Um procedimento pode chamar outro (como é o caso do exemplo anterior, em que
LERN pode chamar ENCERRAR) e também pode ter suas próprias funções e procedimentos
internos:
PROCEDURE Externo;
PROCEDURE Interno1;
begin
...
end;
PROCEDURE Interno2;
begin
...
end;
FUNCTION f_interna(x: real): real;
begin
...
end;
VAR
(* variáveis locais do procedimento EXTERNO *)
BEGIN (* início do procedimento EXTERNO *)
...
(* comandos *)
...
END; (* fim do procedimento EXTERNO *)
Neste caso, toda parte do programa que seja exterior ao procedimento EXTERNO não tem
conhecimento da existência dos procedimentos INTERNO1 e INTERNO2 e da função F_INTERNA.
Esses procedimentos e função internos podem fazer referência entre si. Por exemplo, INTERNO2 pode
usar o INTERNO1.
6.2.3 EXERCÍCIOS
1a Questão) Escreva um programa que tenha uma rotina que receba como parâmetro um valor
"N"e retorne TRUE caso um número seja par, FALSE caso contrário
2a Questão) Escreva um programa que tenha uma rotina que receba como parâmetro um valor
"N"e retorne TRUE caso um número seja ímpar, FALSE caso contrário.
3a Questão) Dado um vetor com n elementos numéricos, faça um programa que tenha uma
rotina que receba como parâmetro um número e verique se o valor existe neste vetor. A rotina deve
retornar TRUE se o elemento existir e FALSE caso contrário.
4a Questão) Escreva um programa que tenha uma rotina para acrescentar N caracteres "$"a
esquerdade uma STRING qualquer.
5a Questão) Escreva um programa que tenha uma rotina para acrescentar N caracteres "$"em
branco a direita de uma STRING qualquer.
6a Questão) Escreva um programa que tenha uma rotina que receba como parâmetro o raio de
uma circunferência e calcule a área.
7a Questão) Escreva um programa que tenha uma rotina que receba como parâmetro o raio de
uma circunferência e calcule o seu comprimento.
8a Questão) Escreva um programa que tenha uma rotina que receba como parâmetro dois
valores inteiros A e B para calcular A elevado a um expoente B.
94
9a Questão) Escreva um programa que tenha uma rotina que receba como parâmetro uma valor
inteiro "N"e retorne o seu fatorial.
10a Questão) Faça um PROGRAMA que tenha uma rotina para calcular a seguinte expressão
matemática:
X2 2X 3 3X 4 4X 5 nX (n+1)
Y = 2!
+ 3!
+ 4!
+ 5!
+ ... + (n+1)!
11a Questão) Escreva um programa que tenha uma rotina que leia um vetor de caracteres e
informe se o caracteres nesse vetor formam uma palavra que é políndrome.
12a Questão) Escreva um programa que tenha uma rotina para calcular a seguinte expressão
até o n-ésimo. (N deve ser passado com parâmetro).
Y = X − X 2 + X 3 − X 4 + X 5 − ......
13a Questão) Escreva um programa que tenha uma rotina para calcular:
X10
1
i=1
n!
14a Questão) Escreva um programa que tenha uma rotina para calcular:
50
X 1
i=
2n
15a Questão) Escreva um programa que tenha uma rotina que receba como parâmetro um
inteiro e informe se um número é ou não primo. O valor a ser retornado será um booleano.
16a Questão) Escreva um programa que tenha uma rotina que receba duas string como
parâmetro e escreva um string que corresponde a concatenação das duas strings.
17a Questão) Escreva um programa que tenha uma rotina que limpe a tela do micro e exiba o
seu nome.
18a Questão) Escreva um programa que tenha uma rotina que receba um valor string S e um
valor inteiro positivo N e exiba o string S por N vezes seguidas na tela.
19a Questão) Escreva um programa que tenha uma rotina chamada CUBO que receba um valor
do tipo real e retorne a potência elevado a 3 do mesmo.
20a Questão) 20a Questão) Escreva um programa que tenha uma rotina chamada TROCA que
receba 2 variáveis inteiras (X e Y) e troque o conteúdo entre elas;
21a Questão) Escreva um programa que tenha uma rotina chamado SINAL que receba como
parâmetro um valor N inteiro e escreva a palavra POSITIVO se N for um número maior que zero,
NEGATIVO se N for menor que zero, ou ZERO se N for igual a zero. Escreva um programa que leia
um número inteiro e, usando o procedimento SINAL, mostre se ele é maior, menor ou igual a zero.
22a Questão) Escreva um programa que tenha uma rotina que receba com parâmetro um número
n e retorne a quantidade de divisores que ele possui.
23a Questão) Escreva um programa que tenha uma rotina chamada METADE que divida um
valor do tipo real (passado como parâmetro) pela metade.
95
Parte 2 - Escreva um programa que leia um vetor A de 30 elementos reais e, usando a rotina
METADE, divida todos seus elementos pela metade.
24a Questão) Escreva um programa que tenha uma rotina chamada MEDIA que retorne a
média de 3 valores reais (X, Y e Z) passados como parâmetros. Escreva um programa que, para um
número indeterminado de alunos, faça para cada uma deles:
i. ler o nome e as 3 notas do aluno (a leitura do nome FIM indica o m dos dados - ag);
ii. calcule a média do aluno (usando a função MEDIA);
iii. exiba o nome e a média do aluno.
25a Questão) Escreva um programa Pascal que leia as 3 notas e o número de faltas de um
aluno, calcule a sua média e determine e exiba a sua situação. Caso a aluno tenha mais de 10 faltas,
ele está REPROVADO POR FALTA. Caso contrário, estará REPROVADO se sua média for menor
que 5.0 ou APROVADO se sua média for superior a 5.0. Observações:
i. utilize uma função para calcular a média e um procedimento para determinar e exibir a situação
do aluno;
26a Questão) Escreva um programa em Pascal que calcule o valor do coseno de X através de
20 termos da série abaixo:
x2 x4 x6 x8
1− 2!
+ 4!
− 6!
+ 8!
+ ....
Observações:
27a Questão) Escreva uma função chamada SEG para receber uma medida de tempo expressa
em Horas, Minutos e Segundos e retornar esta medida convertida apenas para segundos.
28a Questão) Escreva um procedimento chamado HMS para receber uma medida de tempo
expressa apenas em segundos em retornar esta medida convertida para horas, minutos e segundos.
Faça um programa que leia 2 medidas de tempo (expressas em horas, minutos e segundos) e, usando
a função SEG e o procedimento HMS, calcule e exiba a diferença (também em horas, minutos e
segundos) entre elas.
29a Questão) Escreva uma função chamada NOME_MES que receba um valor inteiro N (de
1 a 12) e retorne um string contendo o nome do mês correspondente a N. Faça um programa que
leia uma data (no formato dia, mês e ano) e, usando a função NOME_MES, exiba a data lida no
formato abaixo:
Entrada: 23 11 1998
Saída: 23 de novembro de 1998
96
Escreva uma função chamada DIAS_ANO que receba 3 valores inteiros (DIA, MES, ANO) e
retorne o número de dias decorridos no ano até o dia/mês/ano fornecido.
Escreva um função booleana chamada DATA_VALIDA que receba uma data (DIA, MÊS, ANO)
e verique se a data é válida (considerando os anos bissextos).
Faça um programa que leia 2 datas, no formato dia, mês e ano (as datas devem ter o mesmo
ano) vericando se as mesmas são válidas (através da função DATA_VALIDA), calcule e exiba a
diferença de dias entre elas (usando a função DIAS_ANO).
97
7 − VETORES E MATRIZES
TYPE
Identificador_de_tipo_1 = Tipo1;
Identificador_de_tipo_2 = Tipo2;
... ...
Pela a nomenclatura acima o Identicador_de_tipo_1, ... são identicadores e Tipo1, Tipo2, ...
são nomes de tipos pré-denidos.
Uma vez denido o tipo é possível declarar uma variável desse tipo utlizando o VAR.
7.2 VETORES
Um vetor é um conjunto formado por uma quantidade xa de dados de um mesmo tipo. Sua
declaração é feita com a palavra reservada ARRAY, seguida de seus limites inferior e superior entre
colchetes e separados entre si por .., da palavra reservada OF e o tipo de cada componente do vetor.
Os limites inferior e superior devem ser do tipo ordinal.
TYPE
Vetor = ARRAY[LimInf..LimSup] of TipoBase;
Um vetor também costuma ser chamado de variável indexada ou variável composta homogênea.
Para se ter acesso à n-ésima componente de um vetor V, deve-se fazer referência a V[n]. A denição
de um vetor pode ser feita atribuindo-se valores a cada componente individualmente ou lendo-se cada
componente de um dispositivo de entrada. Nestes casos é comum o uso de um FOR:
ou
Exemplo: As declarações a seguir denem os vetores i = (1, 0, 0), j = (0, 1, 0) e k = (0, 0, 1), a
base canônica do R3 .
TYPE
VetorDoR3 = ARRAY[1..3] OF real;
VAR
i, j, k: VetorDoR3;
...
i[1] := 1; i[2] := 0; i[3] := 0;
j[1] := 0; j[2] := 1; j[3] := 0;
k[1] := 0; k[2] := 0; k[3] := 1;
Exemplo: Denir um vetor V do R10 , cuja n-ésima componente seja igual ao quadrado de n.
TYPE
Vetor10 = ARRAY [1..10] OF real;
VAR
V: Vetor10;
n: byte;
...
for n := 1 to 10 do
begin
V[n] := Sqr(n);
end;
Exemplo: A única desvantagem dos vetores do Pascal, é que seu tamanho (dimensão) precisa ser
xado na sua declaração e o programa NÃO pode alterar esse tamanho. Para um programa manusear
vetores de diferentes tamanhos, um truque bastante comum é se declarar o tipo vetor usando o maior
tamanho que será necessário. Desse modo o programa poderá trabalhar com vetores de tamanhos
menores do que o tamanho máximo declarado, bastando para isso desperdiçar algumas coordenadas,
o que corresponde a desperdiçar memória do computador.
Neste exemplo, deniremos uma função VMAX que calcula o maior elemento de um vetor real
de tamanho no máximo 100. A função VMax deve ter dois parâmetros: o vetor V e seu respectivo
tamanho n. Se o leitor cou pensando que íamos dizer que a denição de uma função VMIN seria
análoga, ele acertou.
TYPE
Vetor = ARRAY [1..100] OF real;
FUNCTION VMax(V: Vetor; n: byte): real;
(* Determina o maior dos n primeiros elementos do vetor V *)
VAR
i: integer;
maximo: real;
BEGIN
maximo := V[1]; (* Chutamos inicialmente que o maior *)
(* elemento de V é o primeiro. *)
(* Comparamos, MAXIMO com todos os elementos V[i] de V. *)
(* Sempre que MAXIMO < V[i], redefinimos MAXIMO := V[i] *)
for i := 1 to n do
begin
99
7.2.1 EXERCÍCIOS
1a Questão) Implemente um programa que tenha duas subrotinas: uma que leia e e outra que
imprima o conteúdo de um vetor de números reais chamado Y com 10 posições.
2a Questão) Implemente um programa que tenha duas subrotinas: uma que leia um vetor de
tamanho 10 e outra que imprima somente o conteúdo dos vetores que receberam valores maiores que
4.
3a Questão) Implemente um programa que tenha duas subrotinas: uma que leia um vetor de
tamanho 15 e outra que imprima somente o conteúdo dos vetores que receberam valores negativos.
4a Questão) Implemente um programa que tenha duas subrotinas: uma que leia um vetor de
tamanho 10 e outra imprima somente o conteúdo dos vetores que receberam valores pares.
5a Questão) Escreva um programa que tenha três subrotinas: uma que leia dois vetores
unidimensionais A e B, de dimensão 8, e outra que realize a troca dos elementos destes vetores;
ou seja, após a execução do programa o vetor B deverá conteros valores fornecidos para o vetor A,
e vice-versa. E nalmente escreva a rotina que receba como parâmetro um vetor unidimensional de
tamanho 8 e imprima o seu conteúdo na tela.
6a Questão) Faça uma função que recebe um vetor X(20) de reais, por parâmetro, e retorna a
soma dos elementos de X.
7a Questão) Faça um procedimento que recebe, por parâmetro, um vetor A(25) de inteiros e
substitui todos os valores negativos de A por zero. O vetor A deve retornar alterado.
8a Questão) Faça um procedimento que gera os 10 primeiros primos acima de 100 e retorna-os
em um vetor X(10), por parâmetro.
9a Questão) Faça um procedimento que recebe 2 vetores A e B de tamanho 10 de inteiros, por
parâmetro. O procedimento deve retornar um vetor C, por parâmetro, que contém os elementos de
A e B em ordem decrescente.
10a Questão) Faça um procedimento que recebe, por parâmetro, 2 vetores de 10 elementos
inteiros e que calcule e retorne, também por parâmetro, o vetor intersecção dos dois primeiros.
11a Questão) Faça um procedimento que recebe, por parâmetro, 2 vetores de 10 elementos
inteiros e que calcule e retorne, também por parâmetro, o vetor diferença dos dois primeiros.
12a Questão) Faça um procedimento que recebe, por parâmetro, 2 vetores de 20 elementos
inteiros e que calcule e retorne, também por parâmetro, o vetor soma dos dois primeiros.
13a Questão) Faça um procedimento que recebe, por parâmetro, 2 vetores de 15 elementos
inteiros e que calcule e retorne, também por parâmetro, o vetor produto dos dois primeiros.
14a Questão) Faça um procedimento que receba, por parâmetro, um vetor K(15) e retorna,
também por parâmetro, um vetor P contendo apenas os valores primos de K.
15a Questão) Faça um procedimento que receba um vetor A(100) de inteiros e retorna esse
mesmo vetor compactado, ou seja, sem os seus valores nulos(zero) e negativos.
100
16a Questão) Faça um procedimento que receba, por parâmetro um vetor B(50) de reais e
calcula o maior valor do vetor. A seguir, o procedimento deve dividir todos os elementos de B pelo
maior encontrado. O vetor deve retornar alterado.
7.3 MATRIZES
Uma matriz pode ser considerada como um vetor de vetores:
TYPE
vetor = ARRAY [1..3] OF real;
matriz = ARRAY [1..3] OF vetor; (* matriz 3 x 3 *)
No entanto, é possível se declarar os intervalo de variação dos índices de uma só vez, bastando
para isso se separar cada intervalo do outro por uma vírgula:
TYPE
matriz3x3 = ARRAY [1..3, 1..3] of real;
matriz2x5 = ARRAY [1..2, 1..5] of real;
matriz4x6 = ARRAY [1..4, 1..6] of integer;
O elemento (i, j) de uma matriz M pode ser referenciado como M[i, j] ou como M[i][j].
Exemplo: Para se denir os elementos de uma matriz, são necessárias leituras ou atribuições para
cada elemento. Normalmente, essas atribuições são feitas com 2 laços FOR encaixados, um FOR para
cada índice:
FOR i := 1 TO m DO
BEGIN
FOR j := 1 TO n DO
BEGIN
Readln([i, j]);
END;
END;
Se a matriz for pequena, o usuário pode preferir denir a matriz elemento por elemento (sem
usar laços FOR). Abaixo estão denidas 2 matrizes M e N 2 x 2, ambas iguais à matriz identidade:
TYPE
matriz2x2 = ARRAY [1..2, 1..2] OF integer;
VAR
M: matriz2x2;
CONST
N: matriz2x2 = ((1, 0), (0, 1));
...
M[1, 1] := 1; M[1, 2] := 0;
M[2, 1] := 0; M[2, 2] := 1;
Exemplo: Neste exemplo, denimos uma matriz A 5 x 6 cujo elemento ai j é dado por
101
TYPE
matriz5x6 = ARRAY [1..5, 1..6] OF integer;
VAR
i, j: integer;
A: matriz5x6;
BEGIN
for i := 1 to 5 do
begin
for j := 1 to 6 do
begin
A[i, j] := 2*i*i*i - j*j + 1;
end;
end;
END.
Observações: Podemos ter variáveis indexadas de dimensões maiores que 2. Por exemplo, o TYPE
a seguir dene variáveis de dimensões 3 e 4:
TYPE
Paralepipedo = ARRAY [1..3, 1..4, 1..5] OF real;
Dimensao4 = ARRAY[1..3, 1..3, 1..3, 1..3] OF integer;
Nestes casos, para se ter acesso aos elementos das variáveis desses tipos (X, Y, ...), deve-se fazer
referências a elementos como X[i, j, k], Y[1, 2, 3, 1], etc.
Os elementos de uma matriz podem ser de quaisquer tipos: boolean, string, etc. Por exemplo, a
tipo MATRIZCHAR abaixo é uma matriz de caracteres e o tipo MATRIZDEBLOCOS é uma matriz
de matrizes:
TYPE
MatrizChar = ARRAY [1..4, 1..6] OF char;
MatrizDeBlocos = ARRAY [1..3, 1..3] OF
ARRAY [1..3, 1..3] OF real;
As variáveis indexadas, como os vetores e as matrizes, podem ser declaradas sem o uso do bloco
TYPE. No entanto, acreditamos que esta não é uma prática muito vantajosa para o usuário.
VAR
i, j, k: ARRAY [1..3] OF integer;
Mat1, Mat2: ARRAY [1..2, 1..2] of real;
Os índices de uma matriz podem ser de qualquer tipo ordinal, inclusive inteiros negativos.
TYPE
MatrizEstranha = ARRAY ['a'..'e', -4..-1] OF string;
102
TYPE
string = ARRAY [0..255] OF char;
7.3.1 EXERCÍCIOS
1a Questão) Dada as matraizes M e S da gura 7.1:
....
for I:= 1 to 4 do
begin
for J:=1 to 4 do
begin
R[J,I] := M[I,J];
end;
end;
AUX := R[1,1];
R[1,1] := R[4,4];
R[4,4] := AUX;
AUX := R[2,2];
R[2,2] := R[3,3];
R[3,3] := AUX;
....
2a Questão) Faça uma função que recebe, por parâmetro, uma matriz A(5,5) e retorna a soma
dos seus elementos.
3a Questão) Faça uma função que recebe, por parâmetro, uma matriz A(6,6) e retorna a soma
dos elementos da sua diagonal principal e da sua diagonal secundária.
4a Questão) Faça uma função que recebe, por parâmetro, uma matriz A(7,6) e retorna a soma
dos elementos da linha 5 e da coluna 3.
5a Questão) Faça uma função que recebe, por parâmetro, uma matriz A(6,6) e retorna o menor
elemento da sua diagonal secundária.
6a Questão) Faça um procedimento que recebe, por parâmetro, uma matriz A(8,8) e calcula o
maior elemento da sua diagonal principal. A seguir, o procedimento deve dividir todos os elementos
de A pelo maior encontrado. O procedimento deve retornar a matriz alterada.
7a Questão) Faça um procedimento que receba, por parâmetro, duas matrizes A(4,6) e B(6,4)
e retorna uma matriz C, também por parâmetro, que seja o produto matricial de M por N.
103
8a Questão) Faça um procedimento que receba, por parâmetro, duas matrizes A(4,6) e B(6,4)
e retorna uma matriz C, também por parâmetro, que seja a soma de M com N.
9a Questão) Faça um procedimento que receba, por parâmetro, duas matrizes A(4,6) e B(6,4)
e retorna uma matriz C, também por parâmetro, que seja a diferença de M com N.
10a Questão) Faça um procedimento que recebe, por parâmetro, uma matriz M(6,6) e um valor
A . O procedimento deve multiplicar cada elemento de M por A e armazenar em um vetor V(36). O
vetor V deve retornar por parâmetro.
11a Questão) Faça um procedimento que receba uma matriz A(10,10), por parâmetro, e realize
as seguintes trocas: