Você está na página 1de 106

INTRODUO LINGUAGEM DE PROGRAMAO

/######
| ### /###
| ###| ###
| ######_/
| ###__/
| ###
| ###
|/__/

/###
/#####
/### ###
/###__/###
/###_/ ### | #### \/_/
| ### | ### \ / ####
| #########
\ / ####
| ###__/### /###\ ###
| ### | ### |/ ##### /
|/__/ |/__/
\ /____/

/#####
/###
/ ###__/##
/### ###
| ### |/_/
/###_/ ###
| ###
| ### | ###
| ###
| #########
|/ ### /## | ###__/###
\ ##### / | ### | ###
\/____/
|/__/ |/__/

SEMESTRE
2008/1

/###
| ###
| ###
| ###
| ###
| ###
| #######
|/______/

SUMRIO
1 - FUNDAMENTOS DE PROGRAMAO ............................................
1.1

1.2

1.3
1.4
1.5
1.6

O QUE SO ALGORITMOS ?..................................................................


1.1.1 POR QUE PRECISAMOS DE ALGORITMOS ?....................................
1.1.2 MTODO PARA CONSTRUIR UM ALGORITMO ................................
1.1.3 EXERCCIOS .............................................................................
TIPOS DE INFORMAO ......................................................................
1.2.1 TIPOS INTEIROS (NUMRICOS) ....................................................
1.2.2 TIPOS REAIS (NUMRICOS) .........................................................
1.2.3 TIPOS CARACTERES ..................................................................
1.2.4 TIPOS LGICOS .........................................................................
VARIVEIS ........................................................................................
1.3.1 ARMAZENAMENTO DE DADOS NA MEMRIA .................................
1.3.2 CONCEITO E UTILIDADE DE VARIVEIS ........................................
INSTRUES PRIMITIVAS ....................................................................
REPRESENTAO DE ALGORITMOS ATRAVS DE FLUXOGRAMAS.............
1.5.1 EXERCCIOS .............................................................................
INTRODUO A LINGUAGEM PASCAL ...................................................
1.6.1 PROGRAMAS FONTE, OBJETO E EXECUTVEL ..............................
1.6.2 NOMES DOS ARQUIVOS EM DISCO................................................

1
2
2
3
3
3
3
4
4
4
4
4
5
6
6
7
8
9

2 - FUNDAMENTOS DA PROGRAMAO EM PASCAL .......................... 11


2.1

2.2

ESTRUTURA DE UM PROGRAMA EM PASCAL .........................................


2.1.1 IDENTIFICADORES ....................................................................
2.1.2 TIPOS DEFINIDOS DO PASCAL .....................................................
2.1.2.1 TIPO INTEIRO ................................................................
2.1.2.2 TIPO BOOLEAN ..............................................................
2.1.2.3 TIPO CHAR....................................................................
2.1.2.4 TIPO REAL ....................................................................
2.1.2.5 TIPO STRING .................................................................
2.1.3 DECLARAO DE VARIVEIS ......................................................
2.1.4 DECLARAO DE CONSTANTES ..................................................
2.1.5 COMANDO DE ATRIBUIO ........................................................
2.1.6 COMENTRIOS ..........................................................................
2.1.7 EXPRESSES ARITMTICAS ........................................................
2.1.8 FUNES MATEMTICAS PR-DEFINIDAS .....................................
2.1.9 EXPRESSES LGICAS ...............................................................
EXERCCIOS ......................................................................................

11
12
13
14
14
14
14
14
15
15
16
17
17
18
19
20

3 - ENTRADA E SADA DE DADOS ..................................................... 23


3.1
3.2
3.3
3.4
3.5

COMANDOS DE ENTRADA ...................................................................


COMANDOS DE SADA.........................................................................
FORMATAO ...................................................................................
O COMANDO CLRSCR .........................................................................
3.4.1 EXERCCIOS .............................................................................
EXERCCIOS AVANADOS ....................................................................

23
24
27
29
30
32

4 - ESTRUTURAS DE DECISO .......................................................... 33


4.1
4.2

COMANDOS COMPOSTOS .................................................................... 33


A ESTRUTURA DE DECISO IF ............................................................. 33

4.3
4.4

4.2.1 EXERCCIOS DE FIXAO ...........................................................


4.2.2 EXERCCIOS .............................................................................
4.2.3 EXERCCIOS OPCIONAIS .............................................................
A ESTRUTURA DE DECISO CASE.........................................................
EXERCCIOS ......................................................................................

41
43
45
46
49

5 - ESTRUTURAS DE REPETIO ...................................................... 51


5.1
5.2
5.3

A ESTRUTURA DE REPETIO FOR ......................................................


5.1.1 EXERCCIOS .............................................................................
5.1.2 EXERCCIOS OPCIONAIS .............................................................
A ESTRUTURA DE REPETIO WHILE ..................................................
5.2.1 EXERCCIOS .............................................................................
5.2.2 EXERCCIOS OPCIONAIS .............................................................
A ESTRUTURA DE REPETIO REPEAT-UNTIL .......................................
5.3.1 EXERCCIOS .............................................................................

51
60
61
62
64
65
66
72

6 - FUNES E PROCEDIMENTOS ..................................................... 73


6.1
6.2

FUNES ..........................................................................................
6.1.1 ESTRUTURA DE UMA FUNO ....................................................
6.1.2 FUNES DEFINIDAS POR SOMATRIOS .......................................
PROCEDIMENTOS...............................................................................
6.2.1 DEFINIO, PROCEDIMENTOS SEM PARMETROS .........................
6.2.2 PROCEDIMENTOS COM PARMETROS ..........................................
6.2.3 EXERCCIOS .............................................................................

73
73
85
86
86
89
93

7 - VETORES E MATRIZES ................................................................ 97


7.1
7.2
7.3

DECLARAO DE TIPOS ..................................................................... 97


VETORES .......................................................................................... 97
7.2.1 EXERCCIOS ............................................................................. 99
MATRIZES ......................................................................................... 100
7.3.1 EXERCCIOS ............................................................................. 102

1 FUNDAMENTOS DE PROGRAMAO

1.1 O QUE SO ALGORITMOS ?


O uso de algoritmos quase to antigo quanto a matemtica. Com o passar do tempo, entretanto,
ele foi bastante esquecido pela matemtica. Com o advento das mquinas de calcular e mais tarde
os computadores, o uso de algoritmos ressurgiu com grande vigor, como uma forma de indicar o
caminho para a soluo dos mais variados problemas.
Algoritmo no a soluo do problema, pois, se assim fosse, cada problema teria um nico
algoritmo. Algoritmo o caminho para a soluo de um problema, e em geral, os caminhos que
levam a uma soluo so muitos.
Ao longo dos anos surgiram muitas formas de representar os algoritmos, alguns utilizando
linguagens semelhantes s linguagens de programao e outras utilizando formas grcas. O
aprendizado de algoritmos no se consegue a no ser atravs de muitos exerccios.
Algoritmos no se aprende:

especicao da seqncia ordenada de passos que deve ser seguida para a realizao de uma
tarefa, garantindo a sua repetibilidade, d-se o nome de algoritmo. Embora esta denio de algoritmo
seja correta, podemos denir algoritmo, de maneira informal e completa como:

Algoritmos um conjunto de regras, bem denidas, para a soluo de um problema


em um tempo nito e com um nmero nto de passos.
Algoritmo pode ser denido tambm como um conjunto de valores como entrada e produz algum
valor ou conjunto de valores como sada. Um algoritmo deve sempre possuir pelo menos um resultado,
normalmente chamado de sada, e satisfazer a propriedade da efetividade, isto , todas as operaes
especicadas no algoritmo devem ser sucientemente bsicas para que possam ser executadas de
maneira exata e num tempo nito.

Na prtica no importante ter-se apenas um algoritmo, mas sim, um bom algoritmo. O mais
importante de um algoritmo a sua correo, isto , se ele resolve realmente o problema proposto e
o faz exatamente.
Para se ter um algoritmo, necessrio:

i. Que se tenha um nmero nito de passos;


ii. Que cada passo esteja precisamente denido, sem possveis ambigidades;
iii. Que existam zero ou mais entradas tomadas de conjuntos bem denidos;
iv. Que existam uma ou mais sadas;
v. Que exista uma condio de m sempre atingida para quaisquer entradas e num tempo nito.
Para que um computador possa desempenhar uma tarefa necessrio que esta seja detalhada
passo a passo, numa forma compreensvel pela mquina, utilizando aquilo que se chama de programa.
Neste sentido, um programa de computador nada mais que um algoritmo escrito numa forma
compreensvel pelo computador.

1.1.1 POR QUE PRECISAMOS DE ALGORITMOS ?


Vejamos o que algumas pessoas importantes, para a Cincia da Computao, disseram a respeito
de algoritmo: A noo de algoritmo bsica para toda a programao de computadores. [KNUTH
- Professor da Universidade de Stanford, autor da coleo The art of computer programming]
O conceito central da programao e da cincia da computao o conceito de algoritmo.
[WIRTH - Professor da Universidade de Zurique, autor de diversos livros na rea e responsvel pela
criao de linguagens de programao como ALGOL, PASCAL e MODULA-2].
A importncia do algoritmo est no fato de termos que especicar uma seqncia de passos
lgicos para que o computador possa executar uma tarefa qualquer, pois o mesmo por si s no tem
vontade prpria, faz apenas o que mandamos. Com uma ferramenta algortmica, podemos conceber
uma soluo para um dado problema, independendo de uma linguagem especca e at mesmo do
prprio computador.

1.1.2 MTODO PARA CONSTRUIR UM ALGORITMO


Utilizando os conceitos j desenvolvidos, esquematizaremos um mtodo para construir um
algoritmo logicamente correto:

i. Ler atentamente o enunciado: Deve-se reler o enunciado de um exerccio quantas vezes for
necessrio, at compreend-lo completamente. A maior parte da resoluo de um exerccio
consiste na compreenso completa do enunciado.

ii. Retirar a relao das entradas de dados do enunciado Atravs do enunciado, descobrimos

quais so os dados que devem ser fornecidos ao programa, via teclado, a partir dos quais
so desenvolvidos os clculos. Obs. Pode haver algum algoritmo que no necessite da entrada
de dados (pouco comum).

iii. Retirar do enunciado as informaes de sada Atravs do enunciado podemos descobrir quais so

as informaes que devem ser mostradas para compor o resultado nal, objetivo do algoritmo.
4. Determinar o que deve ser feito para transformar as entradas em sadas Nessa fase que
teremos a construo do Algoritmo propriamente dito. Devemos determinar qual sequncia de
passos ou aes capaz de transformar um conjunto de dados nas informaes de resultado.
Para isso, utilizamos os fatores descritos anteriormente, tais como legibilidade, portabilidade,
mtodo cartesiano e planejamento reverso, e nalmente podemos construir o algoritmo.

1.1.3 EXERCCIOS
1a Questo) Elabore um algoritmo que mova 3 discos de uma torre de Hani, que consiste em

3 hastes (a-b-c), uma das quais serve de suporte para os trs 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 trs discos da
haste A para haste C.

Figura 1.1: Torres de Hanoi


Mova <disco n> da haste <n1> para haste <n2>
-

1.2 TIPOS DE INFORMAO


Todo o trabalho realizado por um computador baseado na manipulao das informaes
contidas em sua memria. Estas informaes podem ser classicadas em dois tipos:

As instrues, que comandam o funcionamento da mquina e determinam a maneira como


devem ser tratados os dados.
Os dados propriamente ditos, que correspondem poro das informaes a serem processadas
pelo computador.
A classicao apresentada a seguir no se aplica a nenhuma linguagem de programao
especca; pelo contrrio, ela sintetiza os padres utilizados na maioria das linguagens.

1.2.1 TIPOS INTEIROS (NUMRICOS)


So caracterizados como tipos inteiros, os dados numricos positivos ou negativos. Excluindo-se
destes qualquer nmero fracionrio. Como exemplo deste tipo de dado, tem-se os valores: 35, 0, -56,
1024 entre outros.

1.2.2 TIPOS REAIS (NUMRICOS)


So caracterizados como tipos reais, os dados numricos positivos e negativos e nmeros
fracionrios. Como exemplo deste tipo de dado, tem-se os valores: 35, 0, -56, 1.2, -45.987 entre
outros.

1.2.3 TIPOS CARACTERES


So caracterizados como tipos caracteres, as seqncias contendo letras, nmeros e smbolos
especiais. Uma seqncia de caracteres deve ser indicada entre aspas (). Este tipo de dado tambm
conhecido como string, alfanumrico, string, literal ou cadeia. Como exemplo deste tipo de dado,
tem-se os valores: Programao, Rua Alfa, 52 Apto 1, Fone 574-9988, 04387-030,  , 7 entre
outros.

1.2.4 TIPOS LGICOS


So caracterizados como tipos lgicos os dados com valor verdadeiro e falso, sendo que este tipo
de dado poder representar apenas um dos dois valores. Ele chamado por alguns de tipo booleano,
devido contribuio do lsofo e matemtico ingls George Boole na rea da lgica matemtica.

1.3 VARIVEIS
Na programao, uma varivel um objeto (uma posio, freqentemente localizada na memria)
capaz de reter e representar um valor ou expresso. Enquanto as variveis s existem em
tempo de execuo, elas so associadas a nomes, chamados identicadores, durante o tempo de
desenvolvimento.

1.3.1 ARMAZENAMENTO DE DADOS NA MEMRIA


Para armazenar os dados na memria, imagine que a memria de um computador um grande
arquivo com vrias gavetas, onde cada gaveta pode armazenar apenas um nico valor (seja ele
numrico, caractere ou lgico). Se um grande arquivo com vrias gavetas, necessrio identicar
com um nome a gaveta que se pretende utilizar. Desta forma o valor armazenado pode ser utilizado
a qualquer momento.

1.3.2 CONCEITO E UTILIDADE DE VARIVEIS


Tm-se como denio de varivel tudo aquilo que sujeito a variaes, que incerto, instvel
ou inconstante. E quando se fala de computadores, temos que ter em mente que o volume de
informaes a serem tratadas grande e diversicado. Desta forma, os dados a serem processados
sero bastante variveis. Como visto anteriormente, informaes correspondentes a diversos tipos de
dados so armazenadas nas memrias dos computadores. Para acessar individualmente cada uma
destas informaes, em princpio, seria necessrio saber o tipo de dado desta informao (ou seja,
o nmero de bytes de memria por ela ocupados) e a posio inicial deste conjunto de bytes na
memria.
Percebe-se que esta sistemtica de acesso a informaes na memria bastante ilegvel e difcil
de se trabalhar. Para contornar esta situao criou-se o conceito de varivel, que uma entidade
destinada a guardar uma informao.
Basicamente, uma varivel possui trs atributos: um nome, um tipo de dado associado mesma
e a informao por ela guardada. Toda varivel possui um nome que tem a funo de diferenci-la
das demais.
Cada linguagem de programao estabelece suas prprias regras de formao de nomes de
variveis. Adotaremos para os algoritmos, as seguintes regras:

i. um nome de varivel deve necessariamente comear com uma letra;


ii. um nome de varivel no deve conter nenhum smbolo especial, exceto a sublinha ( _ ) e
nenhum espao em branco;

iii. Um nome de varivel no poder ser uma palavra reservada a uma instruo de programa.

Exemplos de nomes de variveis:

Salario - correto
1ANO - errado (no comeou uma letra)
ANO1 - correto
SAL/HORA - errado (contm o caractere /)
SAL_HORA - correto
_DESCONTO - errado (no comeou com uma letra)
Obviamente interessante adotar nomes de variveis relacionados s funes que sero exercidas
pela mesmas dentro de um programa. Outro atributo caracterstico de uma varivel o tipo de dado
que ela pode armazenar. Este atributo dene a natureza das informaes contidas na varivel. Por
ltimo h o atributo informao, que nada mais do que a informao til contida na varivel.
Uma vez denidos, os atributos nome e tipo de dado de uma varivel no podem ser alterados
e assim permanecem durante toda a sua existncia, desde que o programa que a utiliza no seja
modicado. Por outro lado, o atributo informao est constantemente sujeito a mudanas de acordo
com o uxo de execuo do programa. Em resumo, o conceito de varivel foi criado para facilitar a
vida dos programadores, permitindo acessar informaes na memria dos computadores por meio de
um nome, em vez do endereo de uma clula de memria.
Exemplo: Suponha que fosse atribudo os seguintes valores s seguintes variveis: A = mesa, B
= 0, C = 2, D = -5.4, E = Joo e E = 5.656.
A gura 1.2 mostra como estas variveis cam armazendas na memria.

Figura 1.2: Armazenamento de variveis na Memria


1.4 INSTRUES PRIMITIVAS
Como o prprio nome diz, instrues primitivas so os comandos bsicos que efetuam tarefas
essenciais para a operao dos computadores, como entrada e sada de dados (comunicao com
o usurio e com dispositivos perifricos), e movimentao dos mesmos na memria. Estes tipos de
instruo esto presentes na absoluta maioria das linguagens de programao.
Antes de passar descrio das instrues primitiva, necessria a denio de alguns termos
que sero utilizados:

Dispositivo de entrada o meio pelo qual as informaes (mais especicamente os dados) so


transferidos pelo usurio ou pelos nveis secundrios de memria ao computador. Os exemplos
mais comuns so o teclado, o mouse, leitora tica, leitora de cdigo de barras, as tas e discos
magnticos.

Dispositivo de sada o meio pelo qual as informaes (geralmente os resultados da execuo


de um programa) so transferidos pelo computador ao usurio ou aos nveis secundrios
de memria. Os exemplos mais comuns so o monitor de vdeo, impressora, tas e discos
magnticos.
Sintaxe a forma como os comandos devem ser escritos, a m de que possam ser entendidos
pelo tradutor de programas. A violao das regras sintticas considerada um erro sujeito
pena do no reconhecimento por parte do tradutor;
Semntica o signicado, ou seja, o conjunto de aes que sero exercidas pelo computador
durante a execuo do referido comando. Daqui em diante, todos os comando novos sero
apresentados por meio de sua sintaxe e sua semntica, isto , a forma como devem ser escritos
e a(s) ao(es) que executam.

1.5 REPRESENTAO DE ALGORITMOS ATRAVS DE FLUXOGRAMAS


Fluxograma uma representao grca de algoritmos onde formas geomtricas diferentes
implicam aes distintas. Tal propriedade facilita o entendimento das idias contidas nos
algoritmos. Nota-se que os uxogramas convencionais preocupam-se com detalhes de nvel fsico
da implementao do algoritmo. Por exemplo, guras geomtricas diferentes so adotadas para
representar operaes de sada de dados realizadas em dispositivos distintos, como uma unidade
de armazenamento de dados ou um monitor de vdeo. A gura 1.3 mostra as principais formas
geomtricas usadas em uxogramas.
De modo geral, o uxograma se resume a um nico smbolo inicial, por onde a execuo do
algoritmo comea, e um ou mais smbolos nais, que so pontos onde a execuo do algoritmo
se encerra. Partindo do smbolo inicial, h sempre um nico caminho orientado a ser seguido,
representando a existncia de uma nica seqncia de execuo das instrues. Isto pode ser melhor
visualizado pelo fato de que, apesar de vrios caminhos poderem convergir para uma mesma gura
do diagrama, h sempre um nico caminho saindo desta. Excees a esta regra so os smbolos nais,
dos quais no h nenhum uxo saindo, e os smbolos de deciso, de onde pode haver mais de um
caminho de sada (normalmente dois caminhos), representando uma bifurcao no uxo.
Um diagrama de blocos uma forma de uxograma usada e desenvolvida por prossionais da
programao, tendo como objetivo descrever o mtodo e a seqncia do processo dos planos num
computador. Pode ser desenvolvido em qualquer nvel de detalhe que seja necessrio. Quando se
desenvolve um diagrama para o programa principal, por exemplo, seu nvel de detalhamento pode
chegar at as instrues. Esta ferramenta usa diversos smbolos geomtricos, os quais, estabelecero as
seqncias de operaes a serem efetuadas em um processamento computacional. Aps a elaborao
do diagrama de bloco, realizada a codicao do programa. A gura abaixo mostra o exemplo de
um diagrama de blocos ou uxogramas.
A gura 1.4 mostra como caria a representao de um algoritmo que calcula a mdia.

1.5.1 EXERCCIOS
1a Questo) Dena, com suas palavras, o que algoritmo.
2a Questo) Cite alguns algoritmos que podemos encontrar na vida quotidiana.
3a Questo)De acordo com seu entendimento, qual a caracterstica mais importante em um

algoritmo? Justique a sua resposta.

4a Questo) Um algoritmo no pode conter um comando como Escreva todos os nmeros

inteiros positivos. Por qu?

5a Questo) Suponha que temos um rob a nossa disposio. Esse rob chama-se MANNY

e precisa ser ensinado a fazer determinadas tarefas. Para ensinar o MANNY, vamos fazer uso do

Figura 1.3: Simbologia dos Fluxogramas


portugus para passar-lhe as instrues necessrias execuo de cada atividade. Escreva os passos
necessrios para o nosso rob executar:

encher uma bacia com gua;


trocar uma lmpada no teto de sua casa;
trocar o pneu de um carro;
calcular a sua idade daqui a 20 anos;
calcular a mdia de um aluno com 3 notas.

6a Questo) comum ouvirmos programadores experimentados armarem: algoritmos ...

aprendi e nunca usei na prtica ... no vejo necessidade.... Discuta esse tipo de armativa.

1.6 INTRODUO A LINGUAGEM PASCAL


A linguagem Pascal se destina programao de computadores. Foi desenvolvida no nal dos
anos 60 na Sua e seu nome uma homenagem ao criador da primeira calculadora mecnica, o
matemtico francs do sculo XVII Blaise Pascal.

Figura 1.4: Fluxograma Clcula Mdia


Um dos principais fatores que motivaram o surgimento da linguagem foi a obteno de uma
linguagem simples, capaz de incentivar a edio de programas claros e facilmente legveis, favorecendo
a utilizao das boas tcnicas de programao.
Assim como as outras linguagens de programao, o Pascal possui vrias verses. Cada fabricante
cria sua prpria verso com suas particularidades. As verses mais famosas so o Turbo Pascal, da
Borland International, e o MS-Pascal, da Microsoft. Existem verses 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 verses de seus
programas. O mesmo acontece com as linguagens de programao. Em 1983, a Borland criou o Turbo
Pascal, verso 1. Essa verso inicial passou por sucessivas atualizaes at que em 1991 tnhamos o
Turbo Pascal, verso 6. Neste texto, onde nos referirmos simplesmente linguagem Pascal, estamos
nos referindo verso 5 do Turbo Pascal, lanada em 1988.

1.6.1 PROGRAMAS FONTE, OBJETO E EXECUTVEL


Normalmente, quando pensamos em elaborar um programa, estamos pensando em fazer um
texto com palavras do tipo "read", "write", "function", "end", etc. Neste texto, cada palavra
escrita obedece a uma gramtica rigorosa ditada pela linguagem de programao. Queremos que
o computador execute cada comando associado a cada palavra que escrevemos. Este texto a que
estamos nos referindo chamado programa fonte.
Internamente, todo computador s entende uma linguagem chamada linguagem de mquina,
formada exclusivamente por nmeros binrios, cujos nicos algarismos so 0 e 1. Logo, o programa
fonte deve passar por algum processo de traduo para que o computador possa entend-lo. Essa
traduo chamada compilao. O programa fonte, aps a compilao, recebe o nome de programa
objeto.
Apesar do programa objeto estar na linguagem do computador, ele ainda no pode ser executado
pois, sob um certo aspecto, est ainda incompleto. Faltam instrues nele que ensinem o computador a

executar os comandos bsicos da linguagem. Por exemplo, voc pode usar uma funo trigonomtrica
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 funo trigonomtrica? A resposta a essa pergunta
simples: toda linguagem de programao possui um conjunto de instrues bsicas pronto para
ser adicionado a qualquer programa objeto. Esse conjunto de instrues a biblioteca padro da
linguagem. O ato de ligar (link) o programa objeto biblioteca padro chamado ligao (que
algumas pessoas chamam de "linkagem", talvez pelo hbito de usar neologismos). O programa objeto
aps a ligao com a biblioteca padro torna-se um programa executvel.

+------------+
+------------+
| Programa | COMPILAO | Programa |
| fonte
|----------->| objeto
|
+------------+
+------------+
+-------------+
|----------->| Programa |
+-------------+
| executvel |
| Biblioteca |
+-------------+
| padro
|
+-------------+

1.6.2 NOMES DOS ARQUIVOS EM DISCO


Os nomes com os quais os programas de qualquer linguagem de programao so gravados no
disco, obedecem s regras de formao de nomes do sistema operacional: todo arquivo do disco
especicado por um nome obrigatrio com no mximo 8 caracteres e uma extenso opcional com no
mximo 3 caracteres. O nome e a extenso so separados por um
ponto. Os caracteres que podem aparecer no nome ou extenso so letras, algarismos e alguns
caracteres especiais como:

) -

_ $

! @

No podem fazer parte donome ou extenso os seguintes caracteres:

\ /

<

>

comum um programa fonte em Pascal ter extenso PAS. Se voc no mencionar a extenso
de um arquivo, o Pascal incluir automaticamente a extenso PAS, sempre que for feito algum uso
do mesmo. Neste caso, dizemos que PAS a extenso "default"( = omisso, falta) do Pascal. A
extenso, geralmente, classica o tipo do arquivo. Algumas extenses bastante comuns so:

PAS
BAS
C
FOR
PRO
ASM
BAK
BAT
EXE

--->
--->
--->
--->
--->
--->
--->
--->
--->

Programa fonte em Pascal


Programa fonte em BASIC
Programa fonte em C
Programa fonte em FORTRAN
Programa fonte em PROLOG
Programa fonte em Assembly
Arquivo cpia (back up) de outro
Arquivo de lote (batch)
Programa executvel

10

COM
OBJ
SYS
DOC
TXT
TPU

--->
--->
--->
--->
--->
--->

Programa executvel
Programa objeto
Arquivo usado pelo sistema operacional
Texto
Texto
Unidade do Turbo Pascal

Por exemplo, para um programa que trate da resoluo de sistemas lineares, um nome natural
poderia ser SISTEMA.PAS. No entanto, o usurio poderia cham-lo de @##!.)$$ se quisesse. Ambos
so nomes vlidos para o Pascal, alis, para o DOS. Se no disco aparecer tambm um SISTEMA.BAK
e um SISTEMA.EXE, ento muito provvel que o SISTEMA.BAK seja apenas uma cpia do
SISTEMA.PAS e o SISTEMA.EXE seja sua verso executvel. Outras verses de Pascal, bem como
outras linguagens de programao, costumam criar arquivos OBJ no disco, correspondentes aos
programas objeto, mas no esse o caso do Turbo Pascal. Logo, o programa objeto correspondente
a SISTEMA.PAS ser mantido apenas na memria e voc no ter em disco um SISTEMA.OBJ.

11

2 FUNDAMENTOS DA PROGRAMAO EM PASCAL

2.1 ESTRUTURA DE UM PROGRAMA EM PASCAL


Um programa em Pascal um conjunto de palavras e smbolos especiais (comandos, variveis,
funes, algarismos, parnteses, ...) escritos segundo as regras de uma sintaxe pr-xada e possui a
seguinte estrutura:

Cabealho;
Especicao das unidades usadas pelo programa;
Declaraes de tipos, constantes, variveis, rtulos, funes e procedimentos;
Seo principal.
O cabealho usado para dar nome ao programa e possui a forma:

PROGRAM Nome_do_programa;
O cabealho identicado pela palavra chave PROGRAM, seguida de um nome que identicar
o programa, e encerra-se com um ponto-e-vrgula. Ele serve apenas para orientao do usurio.
Exemplo:

PROGRAM Teste;
Uma linha como essa, atribui o nome Teste a um programa. A especicao das unidades
usadas feita com um comando USES, seguido dos nomes das unidades a serem usadas separadas
por vrgula, com um ponto-e-vrgula no nal da linha:

USES unidade1, unidade2, ... ;


Em Pascal, diversos comandos podem ser agrupados em conjuntos denominados unidades (units).
Temos assim uma unidade para vdeo, outra para manipulao de arquivos em disco, outra com os
comandos grcos, etc. Exemplo:

USES Crt, Graph;


Esta declarao permite que sejam usados no programa comandos, funes, constantes, ... das
unidades CRT e GRAPH.
A seo 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.
A seo principal a nica parte obrigatria de um programa em Pascal. No entanto, em todo
programa, tudo que vier a ser usado dever ter sido declarado antecipadamente de forma adequada.
A execuo de todo programa inicia-se pela seo principal.
No sero diferenciadas letras minsculas de maisculas e sero ignorados os espaos em branco.
O nal de um comando ou declarao sinalizado por um ponto-e-vrgula. As quatro expresses a
seguir sero consideradas idnticas:

(1) X := A + B + C;

(2) x:=a+b +

(3) x := a +
b +
c;

(4) X :=

C;

a + B

2.1.1 IDENTIFICADORES
Um identicador um conjunto de caracteres usado para dar nome a um programa, unidade,
rtulo, varivel, tipo, constante, funo 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 sero considerados signicativos. Exemplo:

Identificadores permitidos:
Valor_Maximo_de_F, MIN2P3.

X, a1,

Nota, NomeDoAluno,

Identificadores invlidos: 1a, _Nota_Um, A+B, A(2).

O comprimento do nome de um identicador no tem efeito negativo sobre o desempenho de


um programa. Assim, o usurio est livre para criar nomes longos para variveis, funes, etc. sem o
risco de tornar o programa lento. De preferncia, os nomes dos identicadores devem sugerir alguma
relao com o que estiver sendo identicado.
Alguns identicadores especiais s podem ser usados pela linguagem com um signicado j
pr-xado. Esses identicadores so chamados palavras reservadas ou palavras chave e so os
seguintes:

ABSOLUTE
AND
ARRAY
BEGIN
CASE
CONST

GOTO
IF
IMPLEMENTATION
IN
INLINE
INTERFACE

RECORD
REPEAT
SET
SHL
SHR
STRING

13

DIV
DO
DOWNTO
ELSE
END
EXTERNAL
FILE
FOR
FORWARD
FUNCTION

INTERRUPT
LABEL
MOD
NIL
NOT
OF
OR
PACKED
PROCEDURE
PROGRAM

THEN
TO
TYPE
UNIT
UNTIL
USES
VAR
WHILE
WITH
XOR

Existem, ainda, alguns identicadores que, apesar de terem um signicado pr-denido para o
Pascal, no so palavras reservadas, como por exemplo: REAL, INTEGER, READ, WRITE, PI,
SIN, COS. O signicado ou a funo desses identicadores podem ser redenidos e alterados pelo
usurio.

2.1.2 TIPOS DEFINIDOS DO PASCAL


O diagrama a seguir, classica os tipos pr- denidos do Pascal que sero mais utilizandos no
curso.

+---------------------+
| TIPOS PR-DEFINIDOS |
+---------------------+
|
+-------------------------+
|
|
+-----------+
+--------------+
| SIMPLES |
| ESTRUTURADOS |
+-----------+
+--------------+
|
|
|
+---+
|
|
|
Array
+-----------------------+
|
|
|
string ordinal
real
|
|
+---------------+
+------------+
|
|
|
|
boolean char inteiro
+-----+
|
|
|
real
+----+
|
integer
Vale ressaltar que a linguagem no possui apenas os tipos abaixo, mas estes que aparecero em
99% dos problemas. Em resumo vamos trabalhar com o seguintes tipos:

14

- Integer
- String
- Boolean (Lgico)

2.1.2.1

- Real
- Char
- Array

TIPO INTEIRO

O tipo inteiro formado pelo subconjunto de inteiros, de acordo com a seguinte tabela:

Tipo
Domnio
Tamanho
-------------------------------------------------integer
[-32768, 32767]
2 bytes
--------------------------------------------------

2.1.2.2

TIPO BOOLEAN

O tipo boolean formado pelas constantes TRUE (verdadeiro) e FALSE (falso) e usado para
se avaliar expresses lgicas. um dos tipos mais usados do Pascal.

2.1.2.3

TIPO CHAR

O tipo caracter (char) formado pelo conjunto dos 256 caracteres ASCII (letras, algarismos e
smbolos especiais como +, =, %, $, #, <, etc.). As constantes deste tipo so escritas entre apstrofos:
'A', 'B', '3', etc.

2.1.2.4

TIPO REAL

O tipo real possui o seguinte domnio e tamanho:

Tipo
Domnio
Dgitos
Tamanho
-------------------------------------------------------real
[2.9E-39, 1.7E38]
11-12
6 bytes
-------------------------------------------------------Em Pascal, as potncias de 10 so 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 domnios anteriores referem-se aos valores absolutos das constantes. Com isso, temos que
o tipo real da tabela acima corresponde aos nmeros que esto na unio dos intervalos [2.9E-39,
1.7E38] e [-1.7E38, -2.9E-39]. Est sendo indicada tambm a quantidade de dgitos signicativos de
cada tipo.

2.1.2.5

TIPO STRING

O tipo string uma seqncia de caracteres de comprimento variando de 0 a 255. Escrevendo


string[N], estamos denindo N como tamanho mximo da seqncia (neste caso N deve ser menor
ou igual a 255). As constantes do tipo string devem estar entre apstrofos.

Exemplo: TYPE
Nome = string[40];

15

Neste exemplo est sendo declarado o tipo Nome que uma seqncia 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 captulos posteriores.

2.1.3 DECLARAO DE VARIVEIS


Todas as variveis usadas por um programa em Pascal devem obrigatoriamente ser declaradas
com antecedncia em um bloco de declaraes VAR da seguinte forma:

VAR
Identificador, ..., Identificador: Tipo1;
Identificador, ..., Identificador: Tipo2;
...
...
Seguem alguns exemplos de declarao de variveis na linguagem Pascal:

VAR

x, y, z: real;
i, j, k: integer;
Inicio, Fim: boolean;
Tamanho: integer
Nome_do_arquivo: string[15];

Neste bloco VAR esto sendo declaradas as variveis x, y, z como sendo do tipo real, uma varivel
Tamanho do tipo integer, alm de outras variveis (i, j, ...). Os tipos das variveis no podem ser
mudados durante a execuo do programa e os valores que elas podem assumir devem ser compatveis
com o seu tipo declarado. Por exemplo, a varivel i acima pode assumir o valor 2309, mas no pode
assumir um valor fracionrio como 0.71.

2.1.4 DECLARAO DE CONSTANTES


As constantes de um programa Pascal devem ser declaradas em um bloco CONST na forma:

CONST
Identificador = Expresso;
Identificador = Expresso;
...
...
Identificador: tipo = Valor;
Identificador: tipo = Valor;
...
...
Seguem alguns exemplos de declarao de constantes:

CONST

16

Pi = 3.1415926;
NumeroMaximoDeLinhas = 1024 + 253 + 5;
Mensagem: string[20] = 'Hello world!';
X: integer = 7;

As constantes que so declaradas sem a especicao de tipo no podem ser alteradas durante
a execuo do programa. Aquelas cujas declaraes contiverem o tipo base, chamadas constantes
tipadas, desempenham um papel parecido com o das variveis e podem ser alteradas durante a
execuo do programa. A diferena entre uma varivel e uma constante tipada que a varivel no
pode ter nenhum "valor inicial"na sua declarao.

2.1.5 COMANDO DE ATRIBUIO


A atribuio de um valor ou de uma expresso a um identicador feita atravs do operador de
atribuio := . A sintaxe de uma operao de atribuio :

Identificador := expresso;
Neste tipo de operao, a expresso e o identicador devem ser do mesmo tipo, exceto no caso em
que o identicador for do tipo real e a expresso do tipo inteiro (pois, neste caso, o valor inteiro da
expresso ser automaticamente transformado em real). Exemplo: Considere a seguinte declaraco
de variveis:

VAR
a, b, c: integer;
x, y: real;
teste: boolean;
data: string;

Neste caso, so vlidas as atribuies:

a := -17;
x := y + 3.14;
teste := false;
data := '5/12/1991'

Mas no so vlidas as atribuies:

teste := a + b + 1;
c := 6.02E23;
Em caso de vrias atribuies a um mesmo identicador, ser considerada apenas a ltima
atribuio efetuada.

17

2.1.6 COMENTRIOS
Comentrios so usados para aumentar a clareza de um programa. Todos os comentrios so
desprezados na hora da compilao, logo, eles no tm inuncia no desempenho e nem no tamanho
do programa objeto. Um comentrio colocado entre chaves ou entre (* e *).

{ Este um exemplo de comentrio... }


(* e este tambm um comentrio! *)
Para o Pascal, as declaraes VAR abaixo sero consideradas equivalentes. Para o usurio, o
segundo bloco de declaraes VAR oferece mais clareza.

VAR mat, nota, cod: string;


VAR
mat,
nota,
cod:

{ matrcula
}
{ nota final
}
{ codigo do curso }
string;

2.1.7 EXPRESSES ARITMTICAS


As operaes aritmticas pr-denidas do Pascal so:

+ Adio
/ Diviso
DIV Quociente da diviso
inteira
9/2 = 4.5
9 DIV 2 = 4
10 DIV 2 = 5

- Subtrao
* Multiplicao
MOD Resto da diviso
inteira
-3*7 = -21
9 MOD 2 = 1
10 MOD 2 = 0

Estas operaes podem ser utilizadas com operandos reais ou inteiros, exceto DIV e MOD que
exigem operandos inteiros. A prioridade entre as operaes a mesma da Matemtica:

i. Primeiramente, so efetuadas as multiplicaes e divises (/, DIV e MOD);


ii. por ltimo, so efetuadas as adies e subtraes. Temos ento dois nveis de prioridades.
Dentro de um mesmo nvel, so efetuadas as operaes da esquerda para a direita.

Exemplo: Na expresso 5 - 2/3*7 + 1 as operaoes so efetuadas na seguinte ordem: diviso,


multiplicao, subtrao e adio.
Se uma expresso contiver parnteses, ento ser executado primeiramente o que estiver entre
parnteses. Exemplo:

18

Expresso
Valor
-----------------------5 + 2*4
13
(5 + 2)*4
28
7 DIV 2*3
9
7 DIV (2*3)
1
-----------------------Observaes:

i. No existe operador pr-denido para a potenciao.


ii. O sinal de multiplicao nunca poder ser omitido.
iii. A diviso / sempre fornece um resultado real, mesmo que os operandos sejam inteiros.
iv. Se todos os operandos forem inteiros e as operaes envolvidas forem +, -, *, MOD ou DIV,
ento o resultado ser inteiro.

2.1.8 FUNES MATEMTICAS PR-DEFINIDAS


so:

Entre as muitas funes pr-denidas do Pascal, as que esto relacionadas com valores numricos

Funo
Descrio
Tipo do resultado
------------------------ -----------------------------LN
Logaritmo natural
real
EXP
Exponencial de base e
real
ABS
Valor absoluto
real ou inteiro
SQR
Quadrado
real ou inteiro
SQRT
Raiz quadrada
real
SIN
Seno
real
COS
Cosseno
real
ARCTAN
Arco-tangente
real
ROUND
Arredondamento
inteiro
TRUNC
Parte inteira
inteiro
INT
Parte inteira
real
FRAC
Parte fracionria
real
ODD
Testa se mpar
booleano
------------------------------------------------------Em todas elas deve-se acrescentar um argumento entre parnteses frente do nome da funo,
como em COS(x) ou SQRT(y). O Pascal no tem pr-denidas funes como tangente, secante,
arco-seno, ... . Em breve ser mostrado como o usurio poder denir essas funes, bem como
outras com domnio e contradomnio mais complexos.
Exemplo: O modulo do seno do quadrado de x e codicado como ABS(SIN(SQR(x))). Neste tipo
de expresso, obrigatrio que a quantidade de parnteses 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 parnteses fundamental.

19

Exemplo: A derivada do arco-seno de x, ou seja, 1 sobre a raiz quadrada da diferena entre 1 e


o quadrado de x, se escreve como 1/SQRT(1 - SQR(x)).
Exemplo: O cubo de x pode ser codicado como x*x*x, ou como EXP(3*LN(x)). Em geral, x
elevado a y pode ser codicado como EXP(y*LN(x)).
Exemplo: A funo booleana ODD testa se um inteiro n e impar ou no. ODD(n) fornece um
valor TRUE se n for mpar e FALSE em caso contrrio. Desse modo, ODD(5) = TRUE e ODD(4)
= FALSE. Exemplo:

TRUNC(1.35) = 1 (inteiro)
INT(1.35) = 1 (real)
ROUND(1.35) = 1
FRAC(1.35) = 0.35

TRUNC(1.97) = 1 (inteiro)
INT(1.97) = 1 (real)
ROUND(1.97) = 2
FRAC(1.97) = 0.97

As funes INT e TRUNC so numericamente equivalentes. A diferena entre elas est apenas
no tipo do valor retornado.

2.1.9 EXPRESSES LGICAS


Expresso lgica (ou expresso booleana) uma expresso cujos operadores so operadores lgicos
e cujos operandos so relaes ou variveis do tipo booleano. Os operadores lgicos so AND (e),
OR (ou), NOT (no) e XOR (ou exclusivo). Se X e Y so variveis ou constantes booleanas, ento:

i. X AND Y TRUE somente quando X e Y forem ambas TRUE.


ii. X OR Y FALSE somente quando X e Y forem ambas FALSE.
iii. NOT X TRUE quando X for FALSE e FALSE quando X for TRUE.
Uma relao uma comparao realizada entre valores do mesmo tipo, cujo resultado TRUE
ou FALSE. A comparao indicada por um dos operadores relacionais a seguir:

= igual
< menor
<= menor ou igual

<> diferente
>
maior
>= maior ou igual

No caso de variveis do tipo CHAR ou STRING, ser usada a ordem alfabtica para comparar
duas constantes ou variveis.
Exemplo: Sejam a, b, c, d variaveis booleanas cujos valores so:

a
b
c
d

:=
:=
:=
:=

1
3
a
a

< 2;
>= 5;
OR b;
AND b;

Como 1 < 2 uma relao 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;
Considere tambm as seguintes atribuies:

x := 3;
y := 10;
z := 4;
nome1 := 'Guizinha';
nome2 := 'Olezinho';
teste := false;

Temos ento:

Expresso
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 operaes aritmticas, lgicas e relacionais est denida na seguinte tabela:

Prioridade
Operadores
------------------------------------1 (alta)
NOT
2
*. /, DIV, MOD, AND
3
+, -, OR, XOR
4 (baixa)
=, <=, >=, <, >, <>
-------------------------------------

2.2 EXERCCIOS
1a Questo) Escreva as seguintes expresses de acordo com a sintaxe do Pascal:
a) sen(2x) = 2.sen(x).cos(x)

3
2
b) x + 5x - 2x + 4

21

1
c) ------------------Ln(x + Ln(x)) + 1

d) e

arctg(x) + |x|

1a Questo) Considere as constantes e as variveis denidas abaixo:


CONST
x: real = -3.2; y: real = 4.00;
m: integer = 7;
n: integer = 11;
p: integer = -5;
VAR
a: integer;
z: real;
a) Calcule os valores de a ou z aps as seguintes atribuies:

i)
ii)
iii)
iv)
v)

a
a
a
z
z

:=
:=
:=
:=
:=

m MOD 2 + n DIV (m + p);


TRUNC(x)*ROUND(SQRT(2))
SQR(p + 1) MOD (m MOD ABS(p));
SQRT(2*m + p)/ROUND(EXP(1));
INT(11/7) - FRAC(1/(1 + n + 2*p));

b) Detecte o que est errado com as atribuies abaixo:

i) a := 1 + 3*y;
ii) a := ((n - 1)/2) MOD 3;
iii) z := SIN(1 - COS(ARCTAN(2));
iv) z + 5 := x - y;

3a Questo) Sejam a, b, c trs variveis que, em determinado momento da execuo de um

programa, valem respectivamente 1, 2 e 3. Avalie o valor das seguintes expresses lgicas:

a)
b)
c)
d)

Odd(a) OR Odd(b) AND Odd(c);


NOT (b <> (a + c) DIV 2) AND NOT (a = 0)
(a = b + c) XOR (b = c + a)
(c >= a) AND (NOT (a = 5*b - 3*c) OR (c <= a + b))

4a Questo) X e Y so duas constantes com valores -3 e 5, e CLASSIFICA uma varivel

booleana com valor FALSE em determinado momento. Determine o valor que est sendo atribudo
varivel booleana TESTE em cada um dos casos:

22

a)
b)
c)
d)

TESTE
TESTE
TESTE
TESTE

:=
:=
:=
:=

X > Y;
NOT (Abs(X*Y) >= 5e20);
(X > 0) OR (Y > 10*Abs(X)) OR Classifica;
(X + Y > 1) AND (Sqrt(Y) < 1.2E-9);

23

3 ENTRADA E SADA DE DADOS

Os comandos de entrada ou sada fazem a comunicao entre o programa que est sendo executado
e os perifricos de entrada (teclado, disco) ou os de sada (vdeo, disco, impressora). A entrada ou
sada de dados para um disco ser tratada em captulo posterior.

3.1 COMANDOS DE ENTRADA


Um comando de entrada, tambm chamado de comando de leitura, transfere dados do dispositivo
de entrada (teclado) para uma ou mais variveis na memria, funcionando como um comando de
atribuio. Os dados que entram devem ser compatveis com os tipos das variveis. Dois dos comandos
de entradas do Pascal so READ e READLN, cujas sintaxes so:

READ(Var1, Var2, ...);

---> Transfere
variveis

READLN(Var1, Var2, ...); ---> Transfere


variveis
e, aps a
posiciona
da prxima

dados
Var1,

para
as
Var2, ...

dados
para as
Var1, Var2,
...
leitura dos dados,
o cursor no incio
linha da tela.

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 espao em
branco.
Exemplo: Suponhamos que A e B sejam duas variaveis reais de um programa. Quando a execuo
do programa chegar em um comando como

Read(A, B);
Ento o computador car esperando que sejam digitados dois nmeros reais para que sejam
atribudos s variveis A e B. Por exemplo, digitando-se uma linha como

3.05

-5.17

Pressionando-se ENTER ao nal da digitao dos nmeros, sero atribudos os valores 3.05 a A
e -5.17 a B. como se o programa contivesse as atribuies:

A := 3.05; B := -5.17;

24

3.2 COMANDOS DE SADA


Um comando de sada transfere dados para um dispositivo de sada (vdeo, impressora). Os
dados que podem ser transferidos so valores ou expresses envolvendo constantes ou variveis. Dois
comandos de sada bastante usados so WRITE e WRITELN que tm sintaxes:

WRITE(v1, v2, ...);

---> Mostra na tela os valores de v1,


v2, ...

WRITELN(v1, v2, ...); ---> Mostra na tela os valores de v1,


v2, ... e posiciona o cursor no
incio da prxima linha na tela.

Onde v1, v2, ... acima podem ser expresses envolvendo variveis 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:

WRITELN('O valor encontrado foi ', X);

Neste caso, o computador mostrar na tela algo como:

O valor encontrado foi 15

Depois posicionar o cursor no incio 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
sada mostra os valores de uma constante e de uma varivel.
Exemplo: Suponhamos que X, Y, Z, A, B e C sejam variaveis com valores respectivamente iguais
a ' Antonio ', ' Jose ', ' Maria ', 60, 75 e 90. Ento, o comando:

WRITELN(x, a, y, b, z, c);

Exibir na tela algo como:

Antonio 60 Jose 75 Maria 90

A seqncia de comandos:

WRITELN(x); WRITELN(a); WRITELN(y);


WRITELN(b); WRITELN(z); WRITELN(c);

Mostrar algo como:

25

Antonio
60
Jose
75
Maria
90
Enquanto que

WRITELN(x, y, z); WRITELN(a, b, c);

Exibir:

Antonio Jose Maria


607590
Em cada um desses casos, o cursor car posicionado no incio de uma nova linha.
Exemplo: Vamos elaborar agora nosso primeiro programa completo. Queremos digitar dois
nmeros inteiros no teclado e desejamos que o computador mostre sua soma no vdeo. Sejam Num1
e Num2 os nomes das variveis que vo guardar na memria os valores dos nmeros digitados no
teclado. A atribuio 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, trs ou mais nmeros. Tampouco indicar o tipo de dado
que est sendo esperado, se um dado numrico ou no. 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 usurio.
Neste caso, colocaremos um comando WRITE para mostrar a mensagem Forneca dois numeros
inteiros : .

WRITE('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 expresso Num1 + Num2 em um comando de sada:

WRITELN('Soma = ', Num1 + Num2);

26

Observe que neste WRITELN temos uma constante do tipo string 'Soma = ' e uma expresso
aritmtica Num1 + Num2.
Nosso programa ca, ento, com o seguinte aspecto:

PROGRAM SomaDeDoisInteiros;
VAR
Num1, Num2: integer;
BEGIN
WRITE('Forneca dois numeros inteiros : ');
READLN(Num1, Num2);
WRITELN('Soma = ', Num1 + Num2);
END.

Estamos atribuindo o nome SomaDeDoisInteiros ao programa. Observe que os comandos do


programa (WRITE..., READLN..., ...) devem car na seo principal do programa delimitados pelas
palavras BEGIN e END. No pode ser omitido o ponto aps o END. O bloco VAR de declarao de
variveis deve vir antes da seo principal.
comum se deslocar para a direita as linhas de comandos compreendidas entre um BEGIN e um
END. Esse tipo de deslocamento chamado endentao. Uma vez digitado este programa, pressione
simultaneamente as teclas CTRL e F9 para que ele seja executado.No caso deste programa, voc
ver em uma parte da tela algo parecido com:

Forneca dois numeros inteiros : 11


Soma = 38
_

27

O caracter de sublinhado _ acima representa a posio do cursor na tela. Qualquer outra sada
de dado posterior execuo do programa seria feita a partir dessa posio. Se a seo principal
deste programa fosse:

BEGIN
WRITELN('Forneca dois numeros inteiros : ');
READLN(Num1, Num2);
WRITE('Soma = ', Num1 + Num2);
END.

Ento teramos uma tela como:

Forneca dois numeros inteiros :


11 27
Soma = 38_

Observe a diferena na posio nal do cursor.


Observao: sem parmetros, ou seja, s o nome do comando seguido imediatamente de um ponto
e vrgula. Um WRITELN sem parmetros causa a impresso de uma linha em branco. Por exemplo:

27

WRITELN; WRITELN; WRITELN;


Isso causa a impresso de trs linhas em branco.
Um READLN sem parmetros faz o computador car esperando que se pressione a tecla ENTER
para poder continuar. Temos assim, uma maneira de causar uma pausa na execuo de um programa.
Durante a execuo do fragmento de programa a seguir, o computador coloca uma mensagem na tela
(Para continuar...), e pra temporariamente a execuo at ser pressionado ENTER.

...
...
WRITE('Para continuar, pressione [ENTER]');
READLN;
...
...

3.3 FORMATAO
A impresso dos valores a serem impressos por um WRITE ou WRITELN pode ser formatada
atravs da especicao da largura do campo de impresso ou do nmero de casas decimais.
Para valores do tipo inteiro, booleano, string ou char, basta colocar o tamanho do campo de
impresso direita do valor a ser impresso. Neste caso, o valor e o tamanho do campo devem estar
separados por dois pontos (:).

WRITE(V:n)

ou

WRITELN(V:n) ---> Imprime o valor de V em um


campo de n espaos

Se o valor de n for maior do que a quantidade necessria para a impresso do valor de V, ento
a largura do campo ser completada com espaos em branco adicionados esquerda.
Exemplo: Consideremos x1, x2, s1, s2 variaveis com valores denidos pelas atribuies

x1 := 8; s1 := 'A';
x2 := 19; s2 := '*';
Para cada comando WRITE abaixo, temos as seguintes sadas mostradas na tela:

Comando
Sada
--------------------------------------------------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

O smbolo  na tabela acima assinala os espaos em branco. Em um comando WRITE ou


WRITELN, a impresso de n espaos em branco pode ser feita acrescentando-se lista de valores a
serem impressos uma expresso da forma ' ':n, como no ltimo exemplo da tabela acima. O tamanho
do campo de impresso pode ser uma expresso aritmtica. Por exemplo, WRITE(dado:5) o mesmo
que WRITE(dado:(11 - 9 + 3)).
Para se formatar a impresso de um valor real, devem ser fornecidos dois inteiros que
correspondem ao tamanho do campo de impresso e quantidade de casas decimais a serem
impressas.

WRITE(x:M:N) ou WRITELN(x:M:N) ---> Imprime o valor de x em


um campo de largura M,
com N casas decimais.
Se o valor de M for maior do que a quantidade necessria para a impresso do valor de x, ento a
largura do campo ser completada com espaos em branco adicionados esquerda. O ponto decimal
ou o sinal negativo ocupam um espao do campo de impresso. O tamanho do campo de impresso
e a quantidade de casas decimais podem ser fornecidos em forma de expresso aritmtica. Valores
reais sem formatao so impressos em forma de potncias 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 sadas geradas pelo respectivo comando
WRITE. Denotamos os espaos em branco por .

Comando
Sada
------------------------------------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 usurio a medida de um ngulo
em graus (um nmero inteiro) e mostra na tela o seno, o cosseno e a tangente do ngulo fornecido.
As funes trigonomtricas 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
usurio, para um valor equivalente em radianos. Isto feito atravs de uma multiplicao por Pi/180.
O Pascal tem o valor de Pi pr-denido com 19 casas decimais. Vamos usar trs variveis reais "seno",
"cosseno"e "tangente"para guardar os valores desejados. Vamos exigir que a impresso dos valores
seja em um campo com 8 espaos e 4 casas decimais.

PROGRAM Sen_Cos_Tg;
{ Calculo do seno,
VAR

cosseno

tangente de um angulo }

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 (aps a digitao correta deve-se pressionar CTRL-F9 e ALT-F5),
vemos na tela algo parecido com:

Forneca a medida de um angulo (em graus) : 50

<----------+
Seno de 50 = 0.7660
|
Cosseno de 50 = 0.6428
|
Tangente de 50 = 1.1918
|
|
Linha em branco gerada pelo WRITELN; -----------------+

3.4 O COMANDO CLRSCR


A partir da verso 4, o Pascal passou a agrupar os comandos em unidades. Todos os comandos que
usamos at agora (READ, WRITE, SIN, COS, ...) fazem parte da unidade padro chamada SYSTEM.
A unidade SYSTEM no precisa ser mencionada no programa; podemos usar seus comandos
vontade. Sempre que algum comando de uma outra unidade for usado, o nome da unidade precisa
ter sido declarado em um comando USES, que deve car logo abaixo do cabealho do programa. A
sintaxe do USES

USES Nome_da_unidade_1, Nome_da_unidade_2, ...;


Um comando que faz parte da unidade CRT e que bastante usado, o comando CLRSCR (Clear
Screen) cuja nalidade, como o prprio nome sugere, limpar a tela. Muitos dos livros sobre Pascal
disponveis em Portugus, referem-se s verses anteriores 4. Nesses livros, no feita referncia
unidade CRT.
Exemplo: Queremos fornecer tres numeros reais a, b e c ao computador e queremos que ele nos
fornea, com trs casas decimais, o valor da rea do tringulo cujos lados medem a, b e c. Vamos
querer tambm que o computador se d ao trabalho de limpar a tela antes de pedir os valores de a,
b, c. Vamos usar a frmula 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 nmeros reais a, b, fornecida o valor
da rea do tringulo cujos lados tm essas medidas.
}
USES CRT; { Permite o uso de comandos da unidade CRT, como
o CLRSCR. Deve ser colocado nesta posio, logo
abaixo do cabealho }
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.
A impresso de um apstrofo obtida colocando-se dois apstrofos consecutivos como parte da
constante string. Assim, WRITELN(' e  ') tem como sada na tela um "", que no chega a ser
um "e"acentuado, mas ajuda na leitura. No lugar dos trs READLN acima, poderamos ter colocado
apenas um READLN(a, b, c). Este programinha no inteligente o suciente para rejeitar na entrada
valores negativos ou valores invlidos como a = 3, b = 5, c = 11. Aps sua execuo com os valores
a = 5, b = 7 e c = 8,4, temos as seguintes mensagens na tela:

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 EXERCCIOS
1a Questo) Escreva um programa em Pascal que leia duas variveis A e B e depois calcule e

imprima a mdia dos valores lidos.

2a Questo) Crie um programa que leia quatro nmeros do teclado e imprima a mdia deles na

tela.

3a Questo)Elabore um programa que leia cinco nmeros do teclado e imprima o produto deles.
4a Questo)Escreva um programa que leia seis nmeros inteiros do teclado e imprima a soma

deles.

5a Questo)Apresente o seguinte algoritmo:


i. Ler 2 valores, no caso variveis A e B.

31

ii. Efetuar a soma das variveis A e B colocado seu resultado na varivel X;


iii. Apresentar o valor da varivel X aps a soma dos dois valores indicados.
6a Questo)Elabore um programa que leia a quantidade de chuva em polegadas e imprima a

equivalente em milmetros (25,4 mm = 1 polegada).

7a Questo)Dados dois lados de um tringulo retngulo, faa um programa para calcular a

hipotenusa.

8a Questo) Leia 2 variveis A e B, que correspondem a 2 notas de um aluno. A seguir, calcule

a mdia do aluno, sabendo que a nota A tem peso 3 e a nota B tem peso 7.

9a Questo) Leia 3 variveis A e B e C, que so as notas de um aluno. A seguir, calcule a mdia

do aluno, sabendo que a nota A tem peso 2, a nota B tem peso 3 e a nota C tem peso 5.

10a Questo) Leia 4 variveis A,B,C e D. A seguir, calcule e mostre a diferena do produto de

A e B pelo produto de C e D (A*B-C*D).

11a Questo) O custo ao consumidor de um carro novo a soma do custo de fbrica com

a percentagem do distribuidor e dos impostos (aplicados ao custo de fbrica). Supondo que a


percentagem do distribuidor seja de 12% e os impostos 45%, preparar um programa para ler o
custo de fbrica do carro e imprimir o custo ao consumidor.

12a Questo) Escreva um programa que leia uma temperatura em graus Celsius e converta para

graus fahrenheit.

C=

5(F 32)
9

13a Questo) Escrever um algoritmo para calcular o volume de uma esfera sendo fornecido o

valor de seu raio.

V olume = 43 ..R3
Onde e uma constante que vale 3.1415 e R o raio da esfera.

14a Questo)Leia 4 variveis A,B,C e D. A seguir, calcule e mostre a diferena do produto de A

e B pelo produto de C e D (A*B-C*D).

15a Questo)Entrar com dois nmeros inteiros e exibir a seguinte sada:


Dividendo:
Divisor:
Quociente:
Resto:

16a Questo)Entrar com um ngulo em graus e exibi-lo em radianos.


17a Questo) Entrar com um ngulo em graus e exibir o valor do seno, co-seno e tangente.
18a Questo)Faa um programa que entre com o saldo e aplique um percentual de 10%. Mostre

o valor com o reajuste.

19a Questo) Leia um nmero com trs dgitos e imprima-o na ordem inversa, ou seja, se o

nmero for 453 imprima 354.

20a Questo) Uma pessoa resolveu fazer uma aplicao em uma poupana programada. Para

calcular rendimento, ela dever fornecer o valor constante da aplicao mensal, a taxa e o nmero de
meses. Sabendo-se que a frmula usada nesse clculo e:

32

V alorCalculado = P

(1+i)2 1
i

Onde:

i. i = Taxa;
ii. P = Aplicao Mensal
iii. n = nmero de meses
Faa um algoritmo que calcule o valor da aplicao.

3.5 EXERCCIOS AVANADOS


1a Questo) Preparar um programa para ler os comprimentos dos trs lados de um tringulo

(S1, S2 e S3) e calcular a rea do tringulo de acordo com a frmula:

Area =

p
T (T S1)(T S2)(T S3)

Onde,

T =

S1+S2+S3
2

33

4 ESTRUTURAS DE DECISO

Para resolver problemas complexos, um programa deve ser capaz de tomar decises e escolher
uma entre vrias possibilidades. Nestes casos, so necessrias avaliaes bem sucedidas de condies
lgicas. O Pascal dispe de duas estruturas que podem determinar uma direo especca para um
programa: o comando IF-THEN-ELSE e o comando CASE.

4.1 COMANDOS COMPOSTOS


Chamaremos de comando composto a toda seqncia nita de instrues separadas entre si por
um ponto-e-vrgula e delimitadas pelas palavras chave BEGIN e END.
Exemplo: A seqncia de comandos a seguir um comando composto:

BEGIN
ClrScr;
Write('Valor de x? ');
Readln(x)
END
Todo ponto-e-vrgula escrito antes de um END opcional. por isso que omitimos o
ponto-e-vrgula do Readln(x) acima. Tambm comum se acrescentar alguns espaoes em branco
nas linhas de comandos entre o BEGIN e o END (esse acrscimo de espaos em branco costuma ser
chamado endentao ou indentao). Onde a sintaxe do Pascal permitir uma instruo simples,
tambm permitir um comando composto.

4.2 A ESTRUTURA DE DECISO IF


A estrutura de deciso IF seleciona para execuo um entre dois comandos, ou decide se um
determinado comando ser executado ou no. A estrutura consiste das clusulas obrigatrias IF (se)
e THEN (ento) seguidas, opcionalmente, de uma clusula ELSE (seno). Sua sintaxe :

ou

IF condio THEN
BEGIN
comando1;
END
ELSE
BEGIN
comando2;
END;
IF condio THEN
BEGIN
comando1;

34

END;
onde condio uma expresso booleana. Se a condio for verdadeira, isto , for avaliada
em TRUE, ento ser executado o comando1; se a condio for falsa (FALSE), ser executado o
comando2. Na sua segunda forma (sem o ELSE), o IF no executar nenhuma ao se a condio
for falsa.

IF
|
/\
TRUE / \ FALSE
+-----<cond>-----+
|
\ /
|
|
\/
|
v
v
+----------+ +----------+
| comando1 | | comando2 |
+----------+ +----------+
|
|
+--->---+---<----+
|

IF
|
/\
TRUE / \ FALSE
+-----<cond>-----+
|
\ /
|
|
\/
|
v
|
+----------+
|
| comando1 |
|
+----------+
|
|
|
+-------<--------+
|

O comando1 ou comando2 acima podem ser comandos compostos ou outras estruturas de deciso.
Exemplo: Consideremos a seguinte estrutura de deciso:

IF (x > 0) THEN
BEGIN
WRITE(Sqrt(x));
END
ELSE
BEGIN
x := 1;
END;
Neste caso, se x for um valor numrico positivo, ento ser mostrado o valor da sua raiz quadrada.
Em caso contrrio, ser atribudo a x o valor constante 1. A condio neste caso a expresso lgica
x > 0, o comando1 o WRITE(Sqrt(x)) e o comando2 a atribuio x := 1. A condio lgica deste
exemplo no precisaria estar entre parnteses.

OBSERVAO IMPORTANTE:

No deve haver ponto-e-vrgula antes do ELSE. Se


houvesse, o ponto-e-vrgula seria considerado o nal do IF e, neste caso, o ELSE seria considerado o
comando seguinte ao IF e seria rejeitado.
IF:

Exemplo: Suponhamos que x seja uma varivel real de um programa e consideremos o seguinte

IF (x > -1) AND (x < 1) THEN


BEGIN
Writeln('X tem modulo menor do que 1');

35

END
ELSE
BEGIN
Writeln('X tem modulo >= 1');
END;

Se x em determinado momento valer 2, ento a expresso booleana (x > -1) AND (x < 1)
ser falsa e, assim, ser mostrada na tela a mensagem X tem modulo >= 1. Os parnteses dessa
expresso booleana so essenciais. Sem eles, teramos

x > -1 AND x < 1


Veja que o AND tem prioriade sobre os operadores de comparao > e < , caramos com uma
expresso sem sentido equivalente a x > (-1 AND x) < 1.
Exemplo: Consideremos o seguinte fragmento de um programa, no qual esto denidas a varivel
booleana CONTINUAR, a varivel do tipo char RESPOSTA, e as variveis 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, maisculo ou minsculo *)
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-vrgula 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 *)
...
No IF acima, se CONTINUAR for verdadeira, ento sero solicitados valores para A e B. Em
caso contrrio, o programa esperar ser pressionado a tecla ENTER para encerrar. Nas constantes
do tipo char ou string, feita distino entre letras minsculas e maisculas. Logo, 'S' considerado
diferente de 's'.
Exemplo: Queremos, neste exemplo, elaborar um programa que solicite do usurio um nmero
real qualquer x e que seja mostrado na tela a sua raiz quadrada. Se, por exemplo, x for igual a 4,
queremos ver na tela uma mensagem como:

A raiz quadrada de

4.000

2.000

36

Se x for negativo, por exemplo -9, queremos ver algo como

A raiz quadrada de -9.000

3.000 i

A funo 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 situao em que o programa deve decidir se calcula SQRT(x) ou se
calcula SQRT(-x), um caso tpico de uma estrutura de deciso 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 extenso
da ordem alfabtica. As letras maisculas so diferenciadas das minsculas e ocupam uma posio
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 so duas variveis 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 variveis s possvel com a ajuda de uma varivel
intermediria, que neste caso ser aux.

...
IF (nome1 > nome2) THEN
BEGIN
aux := nome1;
(* Troca nome1 *)
nome1 := nome2;
(* por nome2 *)
nome2 := aux;
END;

Se tivssemos, por exemplo, nome1 = 'Joa e nome2 = 'An, aps a execuo do IF anterior
passaramos a ter nome1 = 'An e nome2 = 'Joa. Observe que um fragmento como

37

...
IF (nome1 > nome2) THEN
BEGIN
nome1 := nome2;
nome2 := nome1;
END;
...
no 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 trs nmeros reais fornecidos pelo usurio podem ser
usados como medidas dos lados de um tringulo retngulo. Exige-se que os valores sejam todos
positivos e fornecidos em ordem crescente. Uma vez fornecido os nmeros, o teste para saber se
eles formam um tringulo retngulo ou no 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 nmeros 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
condies 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 nmeros 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.
Observe a ausncia do ponto-e-vrgula em muitas das linhas acima.
Exemplo: Resolver uma equao do segundo grau, sendo fornecidos seus coecientes a, b e c.
Nosso roteiro na elaborao do programa ser o seguinte:

Ler os valores dos coecientes a, b, c;


Vericar se a = 0. Se for, rejeitar os valores fornecidos. Neste caso, usaremos o comando HALT
para encerrar a execuo do programa;
Calcular o valor do discriminante = b2 4 a c;
Se o Delta for maior ou igual a zero, calcular as razes x1 e x2 usando a conhecidssima frmula;
Se o Delta for negativo, calcular as razes complexas.
x1 =
x2 =

b+
2a

b
2a

Estamos colocando o mdulo na parte imaginria simplesmente porque queremos que x1 tenha
parte imaginria positiva e x2 a parte imaginria negativa, independentemente de a ser positivo ou
no.

39

Limpar a tela;
Mostrar a equacao;
Imprimir as razes.
Seguindo esse roteiro, temos o seguinte programa:

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.
Aps a execuo desse programa, temos na tela mensagens como:

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 usurios com uma disposio maior de trabalho o exerccio de melhorar a sada
desses resultados, fazendo-a mais prxima 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.

Observao: Um dos aspectos que mais causam confuso com relao ao IF em qualquer

linguagem de programao o IF encaixado (tambm chamado de IF aninhado). O problema consiste


na diculdade de se indenticar que ELSE est relacionado com qual IF. Nestes casos uma boa
endentao pode ajudar. Observe o seguinte IF:

IF condio1 THEN
BEGIN
IF condio2 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 prximo. Assim, uma forma melhor de escrever
o fragmento acima :

IF condio1 THEN
BEGIN
IF condio2 THEN
BEGIN
comando1;
END
ELSE
BEGIN
comando2;
END;
END;

41

Se quisssemos realmente que o ELSE estivesse relacionado com o primeiro IF, ento a forma
correta de se escrever seria:

IF condio1 THEN
BEGIN
IF condio2 THEN
BEGIN
comando1;
END;
END
ELSE
BEGIN
comando2;
END;
Este tipo de erro lgico em um programa, em geral, difcil de se detectar. Ele costuma ser
chamado de "armadilha dos IF's encaixados".

4.2.1 EXERCCIOS DE FIXAO


1a Questo) Escreva o programa referente ao uxograma da gura 4.1.

Figura 4.1: Fluxograma A


2a Questo) Para os valores (a=5) (b=7) e (c=9), assinale com X a seqncia de execuo dos

Algoritmos abaixo:

a)
SE a = 5 E b = 7 Entao
c: c + 1
seno
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

(
(
(
(
(
(
(
(
(

)
)
)
)
)
)
)
)
)

3a Questo) Escreva o programa referente ao uxograma da gura 4.2.2.

Figura 4.2: Fluxograma B


4a Questo) Para as sadas, considere os seguintes valores: A=2, B=3, C=5, D=9 e E=6.
a) Resposta: _______
Se no 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 EXERCCIOS
1a Questo) Faa um programa que leia dois nmeros inteiros A e B da entrada padro (teclado)

e retorne o quociente da diviso entre A e B. O programa deve vericar, previamente diviso, se o


valor de B diferente de zero.

2a Questo) Leia um valor inteiro X e diga se ele par ou mpar.


3a Questo) 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 contrrio,
imprimir o nome e a mensagem no aceita. (Considerar para o Sexo as letras F,f,M ou m).

4a Questo)Faa um programa que leia dois nmeros inteiros A e B da entrada padro (teclado)

e imprima o maior deles. D um tratamento caso estes nmeros forem iguais.

5a Questo)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 Questo)Faa um programa que leia dois inteiros A e B e imprima a soma destes valores se

eles forem iguais, seno, ou seja, se forem diferentes imprima o seu produto.

7a Questo)Leia trs lados de um tringulo e diga que:


i. O tringulo equiltero se todos os lados forem iguais;
ii. O tringulo escaleno se todos os lados forem diferentes;
iii. O tringulo isceles se apenas dois lados forem iguais.
8a Questo) Escreva um algoritmo para o calcula das razes de uma equao do segundo grau.
9a Questo)Escreva um algoritmo que leia o cdigo de um aluno e suas trs notas. Calcule a

mdia ponderada do aluno, considerando que o peso para a maior nota seja 4 e para as duas restantes,
3. Mostre o cdigo do aluno, suas trs notas, a mdia calculada e uma mensagem APROVADO se
a mdia for maior ou igual a 5 e "REPROVADO"se a mdia for menor que 5.

10a Questo) Faa um algoritmo que leia um no inteiro e mostre uma mensagem indicando se

este nmero par ou mpar, e se positivo ou negativo.

11a Questo) 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 frmulas:

para homens: (72.7*h)-58


para mulheres: (62.1*h)-44.7

12a Questo)Um usurio deseja um algoritmo onde possa escolher que tipo de mdia deseja

calcular a partir de 3 notas. Faa um algoritmo que leia as notas, a opo escolhida pelo usurio e
calcule a mdia.

1 - aritmtica
2 - ponderada (3,3,4)

13a Questo) Elaborar um algoritmo que l 3 valores a,b,c e verica se eles formam ou no um

tringulo. Supor que os valores lidos so inteiros e positivos. Caso os valores formem um tringulo,
calcular e escrever a rea deste tringulo. Se no formam tringulo escrever os valores lidos. ( se a >
b + c no formam tringulo algum, se a o maior).

14a Questo) O departamento que controla o ndice de poluio do meio ambiente mantm 3

grupos de indstrias que so altamente poluentes do meio ambiente. O ndice de poluio aceitvel
varia de 0,05 at 0,25. Se o ndice sobe para 0,3 as indstrias do 1o grupo so intimadas a suspenderem
suas atividades, se o ndice cresce para 0,4 as do 1o e 2o grupo so 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 poluio medido e emite a noticao adequada
aos diferentes grupos de empresas.

15a Questo) Escrever um algoritmo que leia o tempo de durao em segundos de um

determinado evento em uma fbrica e informe-o expresso no formato horas:minutos:segundos.

45

16a Questo) 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 ms possua 30 dias.

17a Questo)Faa um algoritmos para ler um nmero e imprimir se ele igual a 5, 200 ou 400.

Se no vericar se o mesmo est no intervalo entre 500 e 1000 inclusive , ou se est fora do escopo
especicado.

18a Questo)Faa um algoritmo que leia o percurso em quilmetros, o tipo de carro e informe

o consumo estimado de combustvel, 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 Questo) 19a Questo) Um endocrinologista deseja controlar a sade de seus pacientes e,

para isso se utiliza de um ndice de massa corporal (IMC). Sabendo-se que o IMC calculado atravs
da frmula abaixo:

IM C =

P eso
Altura2

Onde o Peso dado em Kg e a Altura dada em metros. Faa um algoritmo que apresente o nome
do paciente e sua faixa de risco, baseando-se na seguinte tabela 4.2.2:

4.2.3 EXERCCIOS OPCIONAIS


1a Questo) Escrever um algoritmo que l a hora de incio e hora de trmino de um jogo,

ambas subdivididas em dois valores distintos : horas e minutos. Calcular e escrever a durao do
jogo, tambm em horas e minutos, considerando que o tempo mximo de durao de um jogo de
24 horas e que o jogo pode iniciar em um dia e terminar no dia seguinte.

2a Questo) Escrever um algoritmo que l um valor em reais e calcula qual o menor nmero

possvel de notas de 100, 50, 10, 5 e 1 em que o valor lido pode ser decomposto. Escrever o valor lido
e a relao de notas necessrias.

3a Questo) Ler trs nmeros do teclado e imprimi-los em ordem crescente.


4a Questo)Escrever um algoritmo que l um conjunto de 4 valores i, a, b, c, onde i um valor

inteiro e positivo e a, b, c, so quaisquer valores reais e os escreva. A seguir:

i. Se i=1 escrever os trs valores a, b, c em ordem crescente.


ii. Se i=2 escrever os trs valores a, b, c em ordem decrescente.
iii. Se i=3 escrever os trs valores a, b, c de forma que o maior entre a, b, c que dentre os dois.

46

4.3 A ESTRUTURA DE DECISO CASE


O comando IF-THEN-ELSE permite que um entre dois comandos seja executado. O comando
CASE permite que seja selecionado um entre vrios comandos. Desse modo, o CASE funciona como
uma generalizao do IF com a seguinte restrio: a expresso que usada para selecionar os comandos
deve ser do tipo ordinal. Sua sintaxe :

CASE expresso OF
val_1 : comando1;
val_2 : comando2;
...
...
ELSE
comandoN;
END;
O valor da expresso ordinal avaliado e comparado com cada valor alvo val_1, val_2, ... .
Se existir algum valor alvo que coincida com o valor da expresso, ento ser executado apenas o
comando que estiver associado aquele valor. Se o valor da expresso no coincidir com nenhum valor
alvo, ento 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 no 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 varivel inteira. Ento 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 trs 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 vrgulas ou fornecidos em forma
de intervalo valor1..valor2, onde valor1 e valor2 so, 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 varivel 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 especca, dizendo se CH letra,
digito, operador ou smbolo especial ('<', ' ?', '[', '$', '%', ...)
Exemplo: O programa a seguir l dois nmeros reais A e B do teclado e mostra na tela um menu
onde o usurio poder selecionar uma das operaes A+B, A-B, A/B, A*B ou A elevado a B. Uma
vez feita a escolha da operao, seu resultado ser mostrado na tela. Para ler qual foi o nmero da
opo do menu, poderamos usar um READLN(opcao), mas no vamos us-lo. Vamos usar um outro
comando de entrada chamado READKEY. Sua sintaxe :

Varivel := READKEY;
O READKEY espera que seja digitado um caracter do teclado e o associa varivel do tipo
char escrita antes do smbolo de atribuio ( := ). Alm disso, READKEY no mostra o caracter
digitado na tela, nem espera ser pressionado ENTER. Os comandos CASE e READKEY so 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 EXERCCIOS
1a Questo) Em que situaes mais indicado o uso da estrutura CASE-OF ?
2a Questo) Em que situaes no podemos utilizar a estrutura CASE-OF ?
3a Questo)Desenvolva um programa que leias dois nmeros inteiros da entrada padro com os

nomes A e B e, em seguida, implemente um menu principal com as seguintes opes:

a.
b.
c.
d.

A
A
A
A

+
*
/

B
B
B
B

Em seguida, efetue e mostre o resultado da operao determinada pela opo escolhida.

4a Questo) Faa um programa em Pascal que leia um nmero que represente um ms do ano.

Aps a leitura, imprima o ms correspondente por extenso. Caso o nmero entrado no esteja na
faixa de 1 at 12, imprima uma mensagem informando ao usurio que o ms invlido.

5a Questo) Faa um programa em pascal que leia a idade de uma pessoa e informe o seu grau

de maturidade de acordo com a tabela abaixo:

Idade
0 at 3
4 at 10
11 at 18
Acima de 18

Classificao
Beb
Criana
Adolescente
Adulto

6a Questo) Supondo que a cobrana 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 usurio fornecer o
valor do salrio (inteiro).

+------------------------+----------+-------------------+
|
salario (em Cr$)
| alquota | 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 salrio de 350000, temos uma alquota de 10valor do imposto, segundo a
tabela, dever ser de

350000 * 0.10 - 25000

10000 cruzeiros.

7a Questo) Em cada caso abaixo, determine o valor do inteiro x aps a execuo do seguinte

CASE, sabendo que o valor do inteiro y antes da execuo do CASE :

50

a) y = 7;
b) y = -7;
c) y = 2;
d) y = -2;
e) y = 20

CASE y OF
-10..0 : x := 5;
2, 4 : x := y div 2 + Sqr(y - 1);
5..10 : BEGIN
IF Odd(y) THEN y := 12;
x := Round(Sqrt(y + 5))
END;
ELSE
IF y > 4 THEN x := 0 ELSE x := 1;
END;

51

5 ESTRUTURAS DE REPETIO

A repetio a essncia de muitas aplicaes em computadores. Uma estrutura de repetio


uma estrutura que comanda os processos de repetio, por mais complexos e complicados que sejam.
Uma tarefa essencial no projeto de qualquer estrutura de repetio (tambm chamada de
"loop"ou "lao") como decidir quando as repeties (ou iteraes) devem terminar. O Pascal
oferece trs estruturas de repetio diferentes, cada uma com um esquema prprio para o controle
do processo de repetio: os comandos FOR, WHILE e REPEAT.

5.1 A ESTRUTURA DE REPETIO FOR


O FOR especica explicitamente a faixa de iteraes. A quantidade de iteraes controlada por
uma varivel de controle que deve ser do tipo ordinal, cujo valor aumenta ou diminui medida que
cada repetio executada. Sua sintaxe :

ou

FOR Varivel := ValorInicial TO ValorFinal DO


BEGIN
comando;
END;
FOR Varivel := ValorInicial DOWNTO ValorFinal DO
BEGIN
comando;
END;

Observe que:

VARIVEL a varivel de controle do FOR, que deve ser do tipo ordinal (integer).
VALORINICIAL o valor que a varivel de controle assumir na primeira iterao. Deve ser
do mesmo tipo da varivel de controle.
VALORFINAL o valor que a varivel de controle assumir na ltima iterao. Deve ser do
mesmo tipo da varivel de controle.
COMANDO o comando que ser executado em cada iterao. Pode ser uma seqncia
nita de outros comandos delimitada por BEGIN-END (comando composto). Se ValorInicial
<= ValorFinal, ento deve ser usado um FOR-TO. Caso contrrio, deve ser usado um
FOR-DOWNTO.
Um esboo da execuo do FOR o seguinte:

i. No incio da execuo, a varivel de controle recebe o valor correspondente ao VALORINICIAL.


Se o VALORINICIAL for menor do que ou igual ao VALORFINAL, no caso do FOR-TO, ou se
o VALORINICIAL for maior do que ou igual ao VALORFINAL, no caso do FOR-DOWNTO,
ento a primeira iterao executada, isto , o comando escrito aps o DO executado.

52

ii. Antes de cada iterao subseqente, a varivel de controle recebe o prximo valor (no caso do

FOR-TO) ou o valor anterior (no caso do FOR-DOWNTO) do intervalo ValorInicial..ValorFinal


(ou ValorFinal..ValorInicial).

iii. O lao assim criado termina aps a iterao corresponde ao ValorFinal.


Exemplo: FOR i := 1 TO 5 DO Writeln(Sqr(i)); onde i do tipo inteiro, funciona da seguinte
forma:

i. atribudo o valor 1 a i e, como 1 < 5, executado o comando escrito aps o DO, o


Writeln(Sqr(i)). Assim, mostrado o quadrado de 1 na tela;

ii. A varivel i passa a ter o valor seguinte ao anterior, ou seja, i passa a valer 2 e o comando
executado. mostrado, ento, o quadrado de 2 na tela.

iii. A varivel de controle i vai ser aumentada de uma em uma unidade e a cada acrscimo o
WRITELN executado. Esse processo acaba quando a varivel atingir o valor 5.

Quando esse FOR for completamente executado, teremos os valores 1, 4, 9, 16 e 25 mostrados


na tela, um em cada linha.
Exemplo: FOR i := 5 DOWNTO 1 DO Writeln(Sqr(i));
Este exemplo funciona de forma semelhante ao anterior mas com uma diferena: os valores de i
vo variar de 5 at 1, diminuindo de 1 em 1. mostrado na tela os valores 25, 16, 9, 4 e 1, nessa
ordem, um em cada linha.
Exemplo: Seja x uma varivel do tipo char. O FOR a seguir mostra na tela todas as letras
maisculas ABC...XYZ.

FOR x := 'A' TO 'Z' DO


BEGIN
Write(x);
END;
No entanto,

FOR x := 'z' DOWNTO 'a' DO Write(x);


mostra o conjunto de todas as letras minsculas: zyxv...cba. Veja o exemplo abaixo:

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 aps o DO no ser executado nenhuma vez.
Exemplo: A varivel de controle do FOR, quando for numrica, ter de ser do tipo inteiro e s
poder aumentar ou diminuir de 1 em 1. Podemos multiplicar ou dividir essa varivel todas as vezes
em que ela aparecer no comando, como forma de aumentar ou diminuir o valor do incremento em
cada iterao. Por exemplo,

FOR i := 0 TO 100 DO Writeln(2*i)

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 tm 256 valores. As funes que estabelem
uma bijeo entre esses valores so as funes ORD e CHR, inversas uma da outra.

CHR(n) ---> n-simo caracter do tipo char;


ORD(x) ---> Ordinal do caracter x.

Os valores que o n acima podem assumir so de 0 a 255 e o x desde o primeiro ao ltimo caracter
pr-denido do computador (de um total de 256).
CHR(n) tambm pode ser denotado como #n. Alguns valores particulares dessas funes so:

ORD('$')
ORD('+')
ORD('7')
ORD('A')
ORD('B')
ORD('C')
ORD('Z')
ORD('\')
ORD('a')
ORD('z')

= 36
= 43
= 55
= 65
= 66
= 67
= 90
= 92
= 97
= 122

CHR(36)
CHR(43)
CHR(55)
CHR(65)
CHR(66)
CHR(67)
CHR(90)
CHR(92)
CHR(97)
CHR(122)

=
=
=
=
=
=
=
=
=
=

'$'
'+'
'7'
'A'
'B'
'C'
'Z'
'\'
'a'
'z'

ou
ou
ou
ou
ou
ou
ou
ou
ou
ou

#36
#43
#55
#65
#66
#67
#90
#92
#97
#122

=
=
=
=
=
=
=
=
=
=

'$'
'+'
'7'
'A'
'B'
'C'
'Z'
'\'
'a'
'z'

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 varivel inteira i varia de 0 a 255. Devido ao IF (i MOD 10...) , sempre
que i for maior que 0 e mltiplo de 10 , o programa far uma pausa. Ao ser pressionado a tecla
ENTER, sero mostradas mais 10 linhas da tabela e assim o programa prossegue at chegar em i =
255. Alguns caracteres ASCII so smbolos que no 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
Pressione [ENTER] para continuar.
Exemplo: Neste exemplo, vamos calcular o valor de um somatrio. Em particular, consideraremos
a soma dos 5 primeiros termos da srie cujo termo geral n21+1 Chamaremos a varivel que vai guardar
o valor do somatrio de S. Em todo clculo de somatrio, a varivel que ir guardar o valor da soma
dever ter um valor inicial nulo. A seguir, usamos um FOR com varivel de controle fazendo o papel
do ndice do termo geral do somatrio para atuar no comando S := S + Termo_Geral, o que neste
caso, S := S + 1/(n2 + 1). Ao nal da execuo do FOR, temos em S o valor da soma desejada.

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.
Neste exemplo, so feitas as seguintes atribuies de valores a S:

S
S
S
S
S
S

:=
:=
:=
:=
:=
:=

0;
0 + 1/2;
1/2 + 1/5;
(1/2 + 1/5) + 1/10;
(1/2 + 1/5 + 1/10) + 1/17;
(1/2 + 1/5 + 1/10 + 1/17) + 1/26;

(
(
(
(
(

n
n
n
n
n

=
=
=
=
=

1
2
3
4
5

)
)
)
)
)

Exemplo: Neste exemplo, queremos calcular a soma dos 10000 primeiros termos das sries cujos
termos gerais so n1 e n12 . No vamos nos contentar s com o resultado nal, queremos acompanhar o
valor do somatrio de 1000 em 1000 termos. A srie 1/n2 converge para ( 2 )/6; logo, a raiz quadrada
de 6 vezes o somatrio de 1/n2 fornece uma aproximao para o valor de .
Usaremos quatro caracteres ASCII especiais: o #227 que um pi minsculo, o #228 que
um sigma maisculo, o #253 que um expoente 2 e o #247 que usaremos como smbolo de
aproximadamente.
A unidade CRT dispe de dois comandos para alterar as cores de textos da tela. So eles o
TEXTCOLOR, para alterar a cor do texto, e TEXTBACKGROUND, para alterar a cor de fundo.
Suas sintaxes so:

TextColor(Nome_da_cor)
e

TextBackground(Nome_da_cor)
onde Nome_da_cor pode ser uma das seguintes constantes:

Black
Green
Red
Brown
DarkGray
LightGreen
LightRed
Yellow
Blink

=
=
=
=
=
=
=
=
=

0;
2;
4;
6;
8;
10;
12;
14;
128;

Blue
Cyan
Magenta
LightGray
LightBlue
LightCyan
LightMagenta
White

=
=
=
=
=
=
=
=

1;
3;
5;
7;
9;
11;
13;
15;

56

Em cada caso, pode ser usado o nome ou o nmero da cor. Deve-se somar blink ou 128 ao
nome ou nmero 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 cabealho do programa; queremos v-lo em vdeo
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.

Aps a execuo, vemos na tela a listagem a seguir. Onde escrevemos S,   e =, aparecem
na tela, respectivamente, um sigma maisculo, um pi minsculo e um smbolo de aproximao.

S 1/n

S 1/n^2

7.485471
8.178368
8.583750
8.871390

1.643935
1.644434
1.644601
1.644684

57

9.094509
9.276814
9.430953
9.564475
9.682251
9.787606

1.644734
1.644767
1.644791
1.644809
1.644823
1.644834

Pi = 3.141497

Vemos na ltima linha da tabela acima que o valor das somas dos 10000 termos das sries
9.787606 e 1.644834.
Exemplo: Fornecido um inteiro n, vamos construir um programa que fornea o fatorial de n.
Vamos chamar a varivel que vai guardar o valor do produto de P. Inicialmente, deveremos
fazer P := 1. Alis, para calcularmos repetidamente uma determinada operao, deveremos fazer
inicialmente a varivel que vai guardar o resultado nal igual ao elemento nutro da operao. 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 ento 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.
Neste exemplo, sero executadas as seguintes atribuies:

P :=
P :=
P :=
P :=
...
P :=

1;
1*2;
( i = 2
(1*2)*3;
( i = 3
(1*2*3)*4;
( i = 4
...
...
(1*2*...*(n-1))*n; ( i = n

Um exemplo de execuo desse programa:

Valor de N? 3

)
)
)
)

58

3! =

6.00000000+E0000

Exemplo: Fornecido um inteiro N, queremos agora um programa que diga se N primo ou no.
Nosso algoritmo ser o seguinte: faremos uma varivel i variar de 2 at o inteiro mais prximo da raiz
quadrada de N. Usaremos um FOR i... para isso. Para cada valor de i, calculamos o resto da diviso
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 divisvel por i e, portanto, N nesse caso no primo. Se no acontecer de N MOD
i = 0 com i variando de 2 at ROUND(SQRT(N)), ento 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, ento 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.

Como um exemplo de execuo, temos:

Forneca um inteiro N : 13
13 e' primo.

Exemplo: A varivel de controle de um FOR tambm pode ser do tipo booleano. Neste exemplo
faremos um programa que imprime uma tabela-verdade de uma determinada expresso lgica. Para
isso, usaremos dois FOR encaixados para gerar todas as "entradas"da tabela. A expresso lgica
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 laos 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 expresso (x OR y) AND (NOT x OR NOT
y) equivalente ao ou exclusivo x XOR y.

5.1.1 EXERCCIOS
1a Questo) Faa um algoritmo que um nome e imprima-o quantas vezes for a quantidade de

caracteres do seu nome.

2a Questo) Faa um Programa que leia a nota de PRI e PRII de 5 alunos. Calcule e exiba a

mdia e situao de cada aluno, ou seja >= 7,0 aprovado, entre 7,0 e 4,0 Prova Final e menor que 4
Reprovado.

3a Questo) Escreva um algoritmo que gere o nmeros de 1000 a 1999 e escreva aqueles que

dividido por 11 do resto igual a 5.

4a Questo) Apresente o quadrado de cada um dos nmeros pares entre 1 e 1000, inclusive.
5a Questo) Leia 2 valores: X e Y. A seguir, calcule e mostre a soma dos nmeros impares entre

eles.

6a Questo) Leia 2 valores: X e Y. A seguir, calcule e mostre a soma dos nmeros pares entre

eles.

7a Questo) Foi feita uma pesquisa entre os habitantes de uma regio. Foram coletados os dados

de idade, sexo (M/F) e salrio de 10 pessoas. Faa um algoritmo que informe:

i. a mdia de salrio do grupo;


ii. maior e menor idade do grupo;
iii. quantidade de mulheres com salrio at R$100,00.
8a Questo)Faa um programa que mostre na sada padro (vdeo) o nmeros mltiplos de 3

entre 0 e 50.

9a Questo) Faa um algoritmo que leia 2 valores inteiros e positivos: X e Y. O algoritmo deve

calcular e escrever a funo potncia X elevado a Y.


N:

10a Questo) Faa um algoritmo que leia 1 valores para uma N. A seguir, mostre a tabuada de
1 x N = N
2 x N = 2N
...
10 x N = 10N

11a Questo) Faa um programa que mostre a seguinte sada:


1
1 2
1 2 3
1 2 3 4

61

1
1
1
1
1

2
2
2
2
2

3
3
3
3
3

4
4
4
4
4

5
5
5
5
5

6
6 7
6 7 8
6 7 8 9

12a Questo) Escreva um algoritmo que leia um nmero n (nmero de termos de uma progresso

aritmtica), a1 ( o primeiro termo da progresso) e r (a razo da progresso) e escreva os n termos


desta progresso, bem como a soma dos elementos.

13a Questo)Escrever um algoritmo que leia um nmero n e mostre o nmero lido e seu fatorial.
14a Questo) Escrever um algoritmo que calcule e mostre a mdia aritmtica dos nmeros lidos

entre 13 e 73.

15a Questo) Escrever um algoritmo que gera e escreve os nmeros mpares entre 100 e 200.
16a Questo) Escreva um algoritmo que l um valor n inteiro e positivo e que calcula a seguinte

soma:

S =1+

1
2

+ 13 + 41 + .... +

1
n

O algoritmo deve escrever cada termo gerado e o valor nal de S.

17a Questo) Escrever um algoritmo que diz se um nmero X fornecido pelo usurio ou no

primo.

18a Questo) Escreva um algoritmo que leia 10 valores, um de cada vez. Mostre ento o maior

valor lido.

19a Questo) Faa um algoritmo que gere e mostre os valores primos entre 1 e 1000. Mostre

tambm a soma destes valores.

20a Questo) Escreva um algoritmo que calcula e mostra a soma dos nmeros primos entre 92

e 1478.

21a Questo) Faa um algoritmo que calcule a seguinte soma:


H = 10 + 10 + 10 + ... + 10
O algoritmo deve ler um nmero n (inteiro e positivo) e mostrar o resultado nal de H. A soma deve
ser calculada apenas uma vez.

22a Questo) Escrever um algoritmo/programa em Pascal que l um nmero e calcula e escreve

quantos divisores ele possui.

23a Questo) Escrever um algoritmo/programa em Pascal que escreve os nmeros primos entre

100 e 200, bem como a soma destes nmeros.

24a Questo) Faa um algoritmo que leia oito nomes e infome a quantidade de letras de cada

um deles.

5.1.2 EXERCCIOS OPCIONAIS


1a Questo) Escrever um algoritmo que l um nmero no determinado de valores para m,

todos inteiros e positivos, um de cada vez. Se m for par, vericar quantos divisores possui e escrever
esta informao. Se m for impar e menor do que 10 calcular e escrever o fatorial de m. Se m for impar
e maior ou igual a 10 calcular e escrever a soma dos inteiros de 1 at m.

2a Questo) Escrever um algoritmo que l um valor N inteiro e positivo e que calcula e escreve

o valor de E.

62

E =1+

1
1!

1
2!

1
3!

1
4!

+ .... +

1
n!

3a Questo) A srie de Fibonacci tem como dados os 2 primeiros termos da srie que so

respectivamente 0 e 1. A partir deles, os demais termos so construdos pela seguinte regra: tn =


tn1 + tn2 . Escrever um algoritmo/programa em Pascal que gera os 10 primeiros termos da Srie de
Fibonacci e calcula e escreve a soma destes termos.

5.2 A ESTRUTURA DE REPETIO WHILE


Um lao WHILE deve ser usado sempre que se desejar executar um comando um nmero varivel
ou desconhecido de vezes. Sua sintaxe :

WHILE expresso DO
BEGIN
comando;
END;
onde expresso uma expresso booleana e comando uma instruo simples ou um comando
composto.
O WHILE funciona da seguinte maneira: enquanto a expresso booleana for verdadeira, o
comando aps o DO ser executado repetidamente. A expresso reavaliada aps cada execuo
do comando. O lao WHILE s se encerra quando a expresso for falsa. Se a expresso for falsa j
quando o WHILE se inicia, ento o comando no ser executado nenhuma vez. No comando, deve ter
alguma instruo que possa modicar o valor da expresso booleana, seno 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

Este fragmento de programa funciona da seguinte forma:

i. Aps a atribuio inicial (que recomendada em todo WHILE) avaliada a expresso 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 atribuio x := x + 11 executada
e x passa a valer 11 + 11 = 22.

ii. A expresso x < 1992 reavaliada com x = 22 e novamente verdadeira. O comando composto
ento executado mais uma vez e x passa a valer 22 + 11 = 33.

iii. A seqncia AVALIAR EXPRESSO -> EXECUTAR COMANDO -> AVALIAR


EXPRESSO -> EXECUTAR COMANDO -> ... se repete vrias vezes at que x assuma
um valor maior do que ou igual a 1992 e a expresso passe a ser falsa.

iv. Quando a expresso for falsa, o lao WHILE se encerrar e o controle do programa passar
para o comando seguinte ao WHILE.

Assim, o fragmento acima mostra na tela todos os mltiplos de 11 que so menores que 1992.
Assumimos, implicitamente, que x inteiro. No WHILE as variveis 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 so
necessrios somar para se obter um resultado maior do que 15.

PROGRAM ContaParcelas;
(*
1
1
Determina a quantidade de termos de 1 + --- + --- + ...
2
3
que necessrio somar para se ter uma soma > 15. *)
VAR
n: integer;
soma: real;
BEGIN
soma := 0;
(* Valores iniciais das variveis *)
n := 0;
(* usadas no WHILE
*)
WHILE soma <= 15 DO
(*
"ENQUANTO a soma no 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 no h possibilidade de se usar um comando como o FOR porque no 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.
Observao: O comando FOR pode ser considerado como um caso particular de WHILE. o
que est exemplicado nos fragmentos abaixo, onde todas as variveis so inteiras.

FOR i := LimInf TO LimSup DO

<-->

i := LimInf;
WHILE i <= LimSup DO

64

comando;

BEGIN
comando;
i := i + 1;
END;

5.2.1 EXERCCIOS
1a Questo) Chico tem 1,50 metro e cresce 2 centmetros por ano, enquanto Z tem 1,10 metro

e cresce 3 centmetros por ano. Construa um algoritmo que calcule e imprima quantos anos sero
necessrios para que Z seja maior que Chico.

2a Questo) Construir um algoritmo que calcule a mdia aritmtica de vrios valores inteiros

positivos, lidos externamente. O nal da leitura acontecer quando for lido um valor negativo.

3a Questo)Faa um programa que mostre um menu com as opes:


1.
2.
3.
4.

Cadastro
Consulta
Relatorio
Fim

O programa deve exibir o menu acima, mostrando a opo escolhida e, em seguida, repetindo a
exibio do mesmo at que o usurio escolha a opo 4.

4a Questo) Escreva um algoritmo que calcule a mdia dos nmeros digitados pelo usurio, se

eles forem pares. Termine a leitura se o usurio digitar zero (0). OBS: O valor (zero) no entra para
o clculo da Mdia.

5a Questo) Em uma eleio presidencial existem quatro candidatos. Os votos so informados

atravs de cdigos. Os dados utilizados para a contagem dos votos obedecem seguinte codicao:

1,2,3,4 = voto para os respectivos candidatos;


5 = voto nulo;
6 = voto em branco;
Elabore um algoritmo que leia o cdigo do candidado em um voto. Calcule e escreva:

i. total de votos para cada candidato;


ii. total de votos nulos;
iii. total de votos em branco;
Como nalizador do conjunto de votos, tem-se o valor 0.

6a Questo) Faa um algoritmo que leia vrios nmeros inteiros e positivos e calcule o produtrio

dos nmeros pares. O m da leitura ser indicado pelo nmero 0.

7a Questo) Faa um algoritmos que leia n nmeros e imprima somente os pares. O algoritmo

deve nalizar quando for digitado o valor 0.

8a Questo) Faa um algoritmo que leia vrios nomes e depois imprima-os na tela. O nal deve

ser quando a palavra FIM for digitada.

9a Questo) Uma empresa de fornecimento de energia eltrica faz a leitura mensal dos medidores

de consumo. Para cada consumidor so digitados os seguintes dados:

65

Nmero do consumidor
Quantidade de Kwh consumidos durante o ms.
Tipo (cdigo do consumidor).

i. residencial, preo em reais por Kwh = 0,3;


ii. comercial, preo em reais por Kwh = 0,5;
iii. industrial, preo em reais por Kwh = 0,7.
Os dados devem ser lidos at que o consumidor nmero 0 (zero) seja informado. Para cada
consumidor informar: o custo total, o total de consumo para os trs tipos de consumidores e a mdia
de consumo para os consumidores do tipo 1 e 2.

10a Questo) Ler vrias idades e imprimir:


O total de pessoas com menos de 21 anos;
O total de pessoas com mais de 50 anos.

11a Questo) 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:

Nmero do pedido
Data do pedido (dia, ms, ano)
Preo unitrio
Quantidade.
O algoritmos dever processar os pedidos at que o pedidos de nmero 0 (zero) seja digitado pelo
usurio.

12a Questo) Escrever um algoritmo que leia um nmero m de valores e calcule a mdia

aritmtica 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 Questo) Faa um algoritmo que leia vrias prosses e informar quantos so dentistas

(Considerar a palavra destista escrita de seguinte forma: DESTISTA, dentista, Dentista).

14a Questo) Faa um algoritmo que leia N Nmeros e imprima o maior deles. O algoritmo

deve ser nalizado quando o usurio digitar 0 (zero).

15a Questo) Escrever um algoritmo que leia um conjunto de vrios endereo IP de uma mquina

no formato xxx.xxx.xxx.xxx. Crie uma varivel para nmero do formato especicado. Logo aps
informe qual a classe dessa mquina: A, B, C ou D. O nal do do algoritmo deve ser quando o
usurio informar todos os valores sendo 0 (zero).

5.2.2 EXERCCIOS OPCIONAIS


1a Questo) Escreva um programa que onde o computador gere um nmero entre 0 e 100 e faa

com que o usurio tente adivinhar o nmero escolhido. Um exemplo da sada do programa :

66

Pensei em nmero tente advinha-lo?


14
Errado !!! O nmero que pensei est entre 14 e 100. Tente Adivinh-lo?
12
Nmero fora da faixa. O nmero que pensei est entre 14 e 100. Tente Adivinh-lo?
34
Muito bem !!! voc acertou em 3 tentativas.

5.3 A ESTRUTURA DE REPETIO REPEAT-UNTIL


A estrutura REPEAT-UNTIL, assim como o WHILE, usada quando no for conhecida a priori
o nmero de vezes em que uma seqncia de comandos vai ser repetidamente executada. Sua sintaxe
:

REPEAT
comando1;
comando2;
...
UNTIL expresso;
onde expresso uma expresso booleana e comando1, comando2, ... so instrues simples ou
comandos compostos. Neste caso os delimitadores BEGIN/END no so necessrios, pois as palavras
chave REPEAT e UNTIL funcionam como delimitadores. No REPEAT-UNTIL os comandos entre
o REPEAT e o UNTIL sero executados AT que a expresso booleana seja verdadeira. Como a
avaliao da expresso feita no nal do lao, os comandos sero executados pelo menos uma vez.

REPEAT
|
+---------+
| comando |--<--+
+---------+
|
|
|
UNTIL
^
/\
|
/ \ FALSE
|
<cond>---->----+
\ /
\/
| TRUE
v
Observao: Um REPEAT-UNTIL tem o mesmo efeito que um WHILE com a expresso booleana
que controla o lao negada:

REPEAT
comando;
UNTIL expresso;

<--->

WHILE NOT expresso DO


BEGIN
comando;
END;

67

Uma diferena signicativa entre o REPEAT-UNTIL e o WHILE que no REPEAT-UNTIL o


comando sempre executado pelo menos uma vez e no WHILE, o comando pode nem ser executado,
dependendo da avaliao inicial da expresso.
Exemplo: Nosso primeiro programa-exemplo com o REPEAT-UNTIL espera que o usurio digite
vrios nomes. O aviso do usurio para que o programa encerre a solicitao de nomes ser a senha
(ag) FIM ou m. O programa ainda tem a "sosticao"de contar quantos nomes foram digitados.
Temos ento uma situao que se repetir (o programa pedir nomes) at que outra (o usurio
digitar FIM ou m) acontea, um caso tpico de REPEAT-UNTIL.

PROGRAM Nomes;
(* Comentrio:
----------Este programa til porque ele mostra que computador
tambm 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 varivel CONT que conta os nomes digitados ao nal da execuo do REPEAT-UNTIL ter
contado a senha de parada (FIM ou m) como sendo mais um nome. Devido a isso, usamos CONT
- 1, e no CONT, no Writeln nal.
Exemplo: Neste exemplo, queremos digitar vrios nmeros maiores do que ou iguais a zero e
queremos que o programa nos d o valor de sua mdia aritmtica. A princpio, no temos uma
previso da quantidade de nmeros que ser digitada. No entanto, podemos convencionar que quando
se digitar um nmero negativo, signicar que nossa relao de nmeros acabou. O nmero negativo
que funciona como o aviso do m da relao, no deve ser considerado na mdia aritmtica.
medida que cada nmero positivo for fornecido, uma varivel dever ir sendo incrementada de
1 em 1 para se contar quantos nmeros foram digitados. Alm disso, vamos calculando o somatrio
dos valores, assim que cada nmero for digitado.
Temos aqui algo que ser executado VRIAS vezes. Como no temos previso inicial exata da
quantidade de iteraes temos um caso em que receitado um WHILE ou um REPEAT- UNTIL.
Resta apenas o usurio se decidir entre um dos dois. Neste caso, excepcionalmente, vamos dar duas
verses para este programa: a verso WHILE e a verso REPEAT-UNTIL.

PROGRAM MediaAritmetica;
VAR
x, soma, media: real;
cont: integer;
BEGIN

(* versao REPEAT-UNTIL *)

68

cont := 0; (* Quantidade inicial de nmeros digitados *)


soma := 0; (* Soma inicial dos nmeros digitados
*)
REPEAT
Readln(x);
if x >= 0 then
begin
cont := cont + 1;
soma := soma + x;
end;
UNTIL x < 0;
media := soma/cont;
Writeln('Media aritmetica dos numeros digitados = ',
media:8:4);
END. (* fim do programa *)
PROGRAM MediaAritmetica;
(* versao WHILE *)
VAR
x, soma, media: real;
cont: integer;
BEGIN
cont := 0; (* Quantidade inicial de nmeros digitados *)
soma := 0; (* Soma inicial dos nmeros digitados
*)
x := 0;
(* Valor inicial de x. No WHILE recomen- *)
(* dado se inicializar as variveis.
*)
WHILE x >= 0 DO (* a condio do WHILE a negao da *)
BEGIN
(* condio do REPEAT-UNTIL
*)
Readln(x);
if x >= 0 then
begin
cont := cont + 1;
soma := soma + x;
end;
END;
media := soma/cont;
Writeln('Media aritmetica dos numeros digitados = ',
media:8:4);
END. (* fim do programa *)

Exemplo: No presente exemplo, queremos que o computador gere aleatoriamente um nmero de


0 a 10000. O usurio dever tentar advinhar o nmero chutado pelo computador. A cada tentativa do
usurio, o programa dever informar se o chute do usurio foi maior ou menor que o nmero chutado
no incio do programa. O progama tambm deve contar a quantitade de tentativas do usurio.

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 srie

S =1

1
33

1
53

1
73

1
93

+ ....

converge para ( 3 )/32.


Neste exemplo, vamos elaborar um programa que some todos os termos dessa srie que, em
mdulo, so maiores ou iguais a 10 10. O resultado dessa soma, pode ser usado para se calcular Pi
com 10 decimais exatas.
Como no sabemos quantos termos devemos somar, temos um caso de REPEAT-UNTIL ou,
equivalentemente, de WHILE.
Usaremos um comando da unidade CRT chamado GOTOXY cuja funo posicionar o cursor
em determinada coluna e determinada linha da tela. Sua sintaxe :

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;
(* Varivel 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, ento soma-se *)
END
ELSE
(* t a S; caso contrrio, 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 funo 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 contrrio. 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 nmero de cor de 0 a 15, um RANDOM(201) + 50 para gerar um
nmero 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 no, 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

ch := Chr(Random(201) + 50);
Write(ch);
until KEYPRESSED
END.

(* #50 <= ch <= #250 *)

Exemplo: Neste ltimo exemplo deste captulo, vamos usar 3 comandos da unidade CRT para
gerar sons com determinadas freqncia e durao. So eles:

SOUND(n) ---> Emite continuamente um som de n MHz


NOSOUND ---> Encerra a emisso do som
DELAY(t) ---> Pausa de t milisegundos
A execuo de uma determinada nota musical feita da seguinte forma:

i. Usamos o SOUND para emitir um som cuja freqncia a da nota desejada. Para isso, devemos
consultar antes uma tabela de freqncia de sons;

ii. Usamos o DELAY para determinar a durao da nota;


iii. Encerramos a emisso do som com o NOSOUND.
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 no constarem dos alvos do CASE no emitiro sons. Precisamos
tambm 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

'U', 'u; : Sound(494);


'I', 'i' : Sound(524);
'O', 'o' : Sound(558);
'P', 'p' : Sound(660);
'[', '{' : Sound(700);
']', '}' : Sound(784);
END;
DELAY(50);
NOSOUND;
(*
UNTIL (ch = TeclaESC) (*
(*
END.

{
{
{
{
{
{

si }
d }
r }
mi }
f }
sol }

Descubra que diferena faz *)


se forem trocadas estas duas *)
linhas. *)

5.3.1 EXERCCIOS
1a Questo) Faa um algoritmo para calcular o fatorial de um nmero x, dado como entrada

pelo usurio. Verique se o nmero positivo. OBS: Utilize o Repeat.

2a Questo)Faa um algoritmo que leia n nmeros e imprima somente os pares. O algoritmo

deve nalizar quando for digitado o valor 0. OBS: Utilize o Repeat.

3a Questo) Faa um algoritmo que leia n nmeros e calcule a soma dos nmeros pares. O

algoritmo deve nalizar quando for digitado o valor 0. OBS: Utilize o Repeat.

4a Questo) Faa um algoritmo que leia n nmeros e calcule o produto dos nmeros mpares.

O algoritmo deve nalizar quando for digitado o valor 1. OBS: Utilize o Repeat.

5a Questo) Escrever um algoritmo que leia um nmero m de valores e calcule a mdia aritmtica

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 Questo) Faa um algoritmo que leia N Nmeros e imprima o maior deles. O algoritmo deve

ser nalizado quando o usurio digitar 0 (zero).

7a Questo) Faa um algoritmo que leia N Nmeros e imprima o maior deles. O algoritmo deve

ser nalizado quando o usurio digitar 0 (zero).

8a Questo) Escreva um programa Pascal que apresente o menu de opes abaixo:


OPES:
1 - SAUDAO
2 - BRONCA
3 - FELICITAO
0 - FIM
O programa deve ler a opo do usurio e exibir, para cada opo, a respectiva mensagem:

1
2
3
0

Ol. Como vai ?


Vamos estudar mais.
Meus Parabns !
Fim de servio.

Enquanto a opo for diferente de 0 (zero) deve-se continuar apresentando as opes. OBS: Use como
estrutura de repetio o comando REPEAT e como estrutura condicional o comando CASE.

73

6 FUNES E PROCEDIMENTOS

6.1 FUNES
O Pascal oferece muitas facilidades para a confeco de programas modularizados. A
modularizao consiste na diviso de um programa longo em vrias partes, chamadas subprogramas,
cada uma funcionando de forma independente das outras, cada uma realizando tarefas especcas
controladas por um ncleo 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 prprias variveis, suas
prprias denies de tipos, seus prprios subrotinas, etc. Cada vez que um subrotina chamado,
ele executado, e aps o trmino de sua execuo, 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 funes (FUNCTIONS) e os procedimentos (PROCEDURES).

6.1.1 ESTRUTURA DE UMA FUNO


Uma funo um subrotina que tem um nico valor de retorno. O Pascal oferece muitas
possibilidades na denio de funes. Uma funo declarada na rea de declaraes do programa
(depois do cabealho e do USES e antes do BEGIN da seo principal) e possui a seguinte estrutura:

i. Um cabealho (ou prottipo) identicado pela palavra chave FUNCTION, seguida do nome

da funo, da lista de parmetros e tipos entre parnteses e separados entre si por vrgulas, de
um sinal de dois pontos e do tipo do valor que ser retornado pela funo. Parmetros de tipos
diferentes devem ser separados por ponto-e-vrgula.

ii. Uma rea de declaraes de tipos, variveis, constantes, rtulos, funes ou procedimentos.

74

iii. A denio da funo delimitada pelas palavras chave BEGIN e END, com um ponto-e-vrgula
no nal. O valor de retorno da funo denida por uma atribuio do tipo:

Nome_da_funo := Valor;
O valor retornado por uma funo pode ser do tipo inteiro, real, boolean, string, char, entre
outros.
Exemplo: O cabealho de uma funo F com parmetro x inteiro e que retorne um valor inteiro
(ou seja, F : Z > Z) deve ser declarado como:

FUNCTION F (x: integer): integer;


Uma funo G com trs parmetros a, b, c do tipo shortint e que retorne um valor real, deve ser
declarada como:

FUNCTION G (a, b, c: shortint): real;


No caso da funo F deste exemplo, ela ser chamada para ser executada sempre que aparecer
no programa uma expresso do tipo F(expr), onde "expr" qualquer constante, varivel ou expresso
do tipo inteiro. J a funo G, ela pode ser chamada colocando-se em qualquer lugar do programa
algo como G(expr1, expr2, expr3), onde "expr1", "expr2", "expr3"so expresso do tipo shortint.
Exemplo: Neste exemplo, deniremos uma funo logaritmo decimal Log10(x) que, por denio,
ser igual ao quociente Ln(x)/Ln(10). Como queremos que o argumento x da funo seja sempre um
nmero real, ento na linha do cabealho da funo colocamos FUNCTION Log10(x: real). Para que
ela retorne um valor real, nalizamos a linha do cabealho com ": real; "Dessa forma, o cabealho
da funo dene seu domnio e contradomnio.
A seguir, entre os delimitadores BEGIN/END, denimos o valor que a funo deve retornar.
Neste caso, a atribuio feita ao nome da funo, e no ao nome seguido do parmetro. Uma
atribuio como Log10(x) := Ln(x)/Ln(10) est errada.

FUNCTION Log10(x: real): real;


BEGIN
Log10 := Ln(x)/Ln(10);
END;
Uma verso mais elaborada, deveria vericar se o argumento x vlido ou no. Temos ento:

FUNCTION Log10(x: real): real; { versao 2 }


BEGIN
if (x < 0) then
begin
Writeln('Parametro invalido');
Halt; { encerra a execuo do programa }
end
else
begin
Log10 := Ln(x)/Ln(10);

75

end;
END;

Todo programa que queira usar essa funo LOG10, dever t-la denida na sua rea de
declaraes:

PROGRAM LogaritmoDecimal;
VAR
num: real;
FUNCTION Log10(x: real): real;
BEGIN
Log10 := Ln(x)/Ln(10);
END; (* fim da definio da funo *)
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 parmetros da funo forem de tipos diferentes, ento a lista de parmetros deve
separar os tipos por ponto-e-vrgula. Por exemplo, uma funo TESTE que tenha os parmetros x, y
do tipo real e m, n do tipo integer e que retorne um valor do tipo integer dever ter como cabealho:

FUNCTION Teste (x, y: real; m, n: integer): integer;


Uma funo F que tenha parmetros a real, n inteiro e c1, c2, c3 do tipo char e que retorne um
string:

FUNCTION F (a: real; n: integer; c1, c2, c3: char): String;

Exemplo: Neste exemplo vamos construir um programa que use duas funes: MAX(x, y) e
MIN(x, y).

PROGRAM MaxMin;
VAR
a, b: real;
FUNCTION Max(x, y: real): real;
(* Funo MAX ---> retorna o maior valor entre x e y *)
BEGIN
if (x >= y) then
begin
Max := x;
end
else
begin
Max := y;
end;

76

END; (* fim da definio de MAX *)


FUNCTION Min(x, y: real): real;
(* Funo MIN ---> retorna o menor valor entre x e y *)
BEGIN
if (x <= y) then
begin
Min := x;
end
else
begin
Min := y;
end;
END; (* fim da definio de MIN *)
BEGIN (* inicio do programa principal *)
Write('Forneca dois numeros : ');
Readln(a, b);
Writeln('O maior dos dois ' ', Max(a, b):6:2);
Writeln('e o menor ' ', Min(a, b):6:2)
END. (* fim do programa *)
OBSERVAO IMPORTANTE: As variveis denidas em uma funo, chamadas variveis
locais, ou as que so denidas como parmetros, no tm nenhuma relao com as variveis de outras
funes ou do programa principal, mesmo que elas tenham o mesmo nome. O programa principal
no tem conhecimento das variveis locais declaradas em uma funo.
Exemplo: O comando EXIT, quando usado em uma funo, faz o controle do programa abandonar
a funo e voltar ao ponto na qual a funo foi chamada. til para se interromper a execuo de uma
funo que foi chamada com algum argumento com valor invlido. A seguir, denimos uma funo
fatorial. Se ela for chamada com argumentos invlidos (negativos ou grandes), ento o comando EXIT
faz o controle do programa abandonar a funo e voltar ao ponto de chamada.

FUNCTION Fat(n: integer): integer;


VAR
(* declarao das variveis locais *)
i, prod_aux: integer;
BEGIN
if (n < 0) or (n > 12) then
begin
Writeln('Argumento n invalido na chamada de FAT.');
EXIT; (* abandona a execuo da funo *)
end
else
begin
if n <= 1 then
begin
Fat := 1;
end
else
begin
prod_aux := 1;

77

for i := 2 to n do
begin
prod_aux := prod_aux * i;
end;
Fat := prod_aux

end;
end;
END; (* fim da definio da funo *)

Precisamos de uma varivel auxiliar (prod_aux) para guardar o valor do fatorial, porque uma
atribuio como Fat := Fat * i no permitida (s seria possvel se Fat fosse uma varivel).
Um exemplo de um programa que use esta funo :

PROGRAM UsandoFat;
(* Lista os valores de n!, com 0 <= n <= 12 *)
VAR
i: integer; (* este "i" no tem nenhuma relao com o "i"
da funo 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 funo CURSO que associa a alguns nmeros inteiros,
nomes de cursos da UFPB.

FUNCTION
BEGIN
CASE n
8 :
11 :
22 :
23 :
24 :
25 :
30 :
32 :
44 :
else
END;
END;

Curso(n: integer): string;


OF
Curso
Curso
Curso
Curso
Curso
Curso
Curso
Curso
Curso

:=
:=
:=
:=
:=
:=
:=
:=
:=

'Ciencias';
'Quim. Industrial';
'Eng. Civil';
'Eng. Alimentos';
'Eng. Mecanica';
'Bach. Quimica';
'Bach. Fisica';
'Bach. Matematica';
'Bach. Computacao';

Curso := 'Curso desconhecido';

Suponhamos que esta funo 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 incluso, 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 incluso no seja
confundida com um comentrio, no deve haver espaos 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 funo do tipo string que, dado um inteiro n e
um caracter x, ento o valor da funo no ponto (n, x) dever ser o caracter x repetido n vezes.
Chamaremos a funo de REPETE. Para as variveis do tipo string est denida uma operao
de soma, que na verdade uma concatenao. Se X, Y so strings, X + Y = string formado pela
juno de X com Y. Por exemplo, 'Para' + 'iba' = 'Paraiba', '19' + '92' = '1992', 'Jose' + 'Maria'
= 'JoseMaria', etc. Toda varivel char, pode ser considerada um string de comprimento 1. Assim,
temos tambm, ' + 'B' = 'AB', etc. Para repetir o caracter x por n vezes, faremos um somatrio
de strings:

Str_aux
Str_aux
Str_aux
Str_aux
Str_aux
...

:=
:=
:=
:=
:=

''
'' + 'x' = 'x'
'x' + 'x' = 'xx'
'xx' + 'x' = 'xxx'
'xxx' + 'x' = 'xxxx'
...
...

(n
(n
(n
(n

=
=
=
=

1)
2)
3)
4)

FUNCTION Repete(n: byte; x: char): string;


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 funo sob o nome de REPETE.PAS. Por exemplo,
REPETE(6, '*') = '******', REPETE(10, '%') = '%%%%%%%%%%', REPETE(0, 'A') = , etc.
Um exemplo de uso dessa funo :

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.
Um outro exemplo, gera aleatoriamente os valores de i e ch e repete esse processo indenidamente
(at ser pressionado as teclas CTRL e BREAK).

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.
Exemplo: O conjunto de funes a seguir, complementa a "decincia"do Pascal com relao
s funes trigonomtricas e hiperblicas. Podem ser criados dois arquivos no disco TRIG.PAS e
HIPER.PAS para serem includos em qualquer programa pela diretiva de incluso $I TRIG.PAS ou
$I HIPER.PAS.

{ ========================================================
{
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

function Cotg(x: real): real;


{ Cotangente
}
begin
if Sin(x) = 0 then
begin
Halt; { parametro invalido }
end;
Cotg := Cos(x)/Sin(x)
end;
{ -------------------------------------------------------function Sec(x: real): real;
{ Secante
}
begin
if Cos(x) = 0 then
begin
Halt;
end;
Sec := 1/Cos(x)
end;
{ -------------------------------------------------------function Cossec(x: real): real; { Cossecante
}
begin
if Sin(x) = 0 then
begin
Halt;
end;
Cossec := 1/Sin(x)
end;
{ -------------------------------------------------------function ArcSen(x: real): real; { Arco-seno
}
begin
if (Abs(x) > 1) then
begin
Halt; { parametro invalido }
end;
else
begin
if (x = 1) then
begin
ArcSen := Pi/2;
end;
else
begin
if (x = -1) then
begin
ArcSen := -Pi/2;
end;
else
begin
ArcSen := ArcTan(x/Sqrt(1 - Sqr(x)));
end;
end;
end;
{ --------------------------------------------------------

81

function ArcCos(x: real): real; { Arco-cosseno }


begin
if (Abs(x) > 1) then
begin
Halt; { parametro invalido }
end
else
if (x = 0) then
begin
ArcCos := Pi/2;
end;
else
begin
if (x > 0) then
begin
ArcCos := ArcTan(Sqrt(1 - Sqr(x))/x);
end;
else
begin
ArcCos := Pi + ArcTan(Sqrt(1 - Sqr(x))/x);
end;
end;
end;
{ -------------------------------------------------------- }
{ ======================================================== }
{
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

Halt; { parametro invalido }


end;
ArcCosh := Ln(x + Sqrt(Sqr(x) - 1))
end;
{ -------------------------------------------------------- }
function ArcTgh(x: real): real; { Arco-tangente hiperbolica}
begin
if (x >= 1) or (x <= -1) then
begin
Halt; { parametro invalido }
end;
ArcTgh := Ln((1 + x)/(1 - x))/2
end;
{ -------------------------------------------------------- }

Exemplo: Deniremos neste exemplo uma funo booleana chamada PRIMO(n) que ser TRUE
se n for primo e FALSE em caso contrrio.

FUNCTION Primo(n: integer): boolean;


(*
Testa se um inteiro n primo
*)
VAR
i: integer;
raiz: real;
BEGIN
Primo := TRUE; (* suposio inicial de que n primo *)
if (n < 0) then
begin
n := -n;
end;
if (n = 2) then
begin
Exit;
end;
if (n = 1) or (n mod 2 = 0) then (* caso em que n 1 *)
begin
(* ou par > 2
*)
Primo := FALSE;
Exit;
end;
raiz := Sqrt(n);
(* Caso geral: Se n for divis- *)
i := 3;
(* vel por um mpar maior ou *)
while (i <= raiz) do
(* igual a 3 e menor ou igual *)
begin
(* raiz quadrada de n, ento n *)
if (n mod i = 0) then (* no primo. Caso contrrio, *)
begin
(* n primo.
*)
Primo := false;
Exit;
end;
i := i + 2
end

83

END;
Gravando-se esta funo 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 extenso .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 funo potncia POT(x, y) = x  y. Para uso posterior,
vamos salv-la em disco sob o nome de POT.PAS. Identicaremos com 0 todo nmero que, em
mdulo, seja menor do que 1010 .

FUNCTION Pot(x, y: real): real;


CONST
epsilon = 1E-10;
BEGIN
if (Abs(x) < epsilon) and (Abs(y) < epsilon) then
begin
(* Caso em que x = 0 e y = 0 *)
Writeln('ERRO: Forma indeterminada 0 elevado a 0.');
Halt;
end
else
begin
if (Abs(x) < epsilon) then
begin
(* Caso em que x = 0
*)
if (y > 0) then
begin
Pot := 0;
end;
else
begin
Writeln('ERRO: Base nula e expoente negativo.');
Halt;
end;
end
else
begin
if (Abs(y) < epsilon) then (* Caso em que y = 0
*)
begin
Pot := 1;
end
else
begin
if (x > 0) then
(* Caso geral com x > 0 *)

84

end;
END;

end;
end;

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;

A funo POT assim denida no conveniente para o clculo de razes. Como exerccio,
desenvolva uma funo 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 seo, testa se um nmero inteiro positivo potncia de dois
ou no. Construmos a funo boolean POTENCIADEDOIS(n) que TRUE se n for uma potncia
de 2 e FALSE em caso contrrio. Grave no disco esta funo sob o nome de POT_2.PAS para ser
usada futuramente. O algoritmo usado foi o seguinte: so feitas sucessivas divises de n por 2 at se
encontrar um nmero mpar. Se o nmero mpar assim encontrado for 1, ento o n potncia de 2;
caso contrrio, n no potncia de 2.

85

FUNCTION PotenciaDeDois(n: integer): boolean;


VAR
m: integer;
BEGIN
repeat
m := n;
n := n div 2;
until n*2 <> m;
if (m = 1) then
begin
PotenciaDeDois := true;
end;
else
begin
PotenciaDeDois := false;
end;
END;

Como exemplo de utilizao dessa funo, temos o programa abaixo que lista as potncias 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.

6.1.2 FUNES DEFINIDAS POR SOMATRIOS


Exemplo: A funo real FSERIE a seguir denida por um somatrio. Fornecidos um real x e
a quantidade n de termos do somatrio, FSERIE(x, n) denida como sendo o somatrio de sin(kx)
k
com k variando de 1 a n.

FUNCTION FSerie(x: real; n: byte): real;


(*
Sen(2x)
Sen(nx)
FSerie(x, n) = Sen(x) + --------- + ... + --------2
n
*)
var
aux: real;
k: integer;

86

BEGIN
aux := 0;
for k := 1 to n do
begin
aux := aux + sin(k*x)/k;
end;
FSerie := aux
END;

Exemplo: A funo a seguir uma aproximao para a funo exponencial de base E. Trata-se
da funo denida pelos 11 primeiros termos da srie de Taylor de EXP(x).
Usamos na sua denio duas funes denidas anteriormente: FAT e POT.

FUNCTION ExpAprox(x: real): real;


(*
2
3
x
x
ExpAprox(x) = 1 + x + ----- + ----2!
3!
*)
var
i: integer;
aux: real;
BEGIN
aux := 0;
for i := 0 to 10 do
begin
aux := aux + Pot(x, i)/Fat(i);
end;
ExpAprox := aux
END;

10
x
... ----10!

6.2 PROCEDIMENTOS
6.2.1 DEFINIO, PROCEDIMENTOS SEM PARMETROS
Um procedimento (procedure) um trecho de programa que possui seus prprios objetos
(variveis, constantes, tipos, funes, outros procedimentos, ...) . Juntamente com as funes,
os procedimentos formam o que se chama genericamente de subrotinas (ou subprogramas). Os
procedimentos diferem das funes apenas pelo fato das funes retornarem sempre um nico valor,
enquanto que os procedimentos no retornam valor algum. A criao de um procedimento em Pascal
feita atravs de sua declarao na rea de declaraes do programa. Um procedimento possui um
cabealho, identicado pela palavra reservada PROCEDURE seguida do nome do procedimento e
uma lista opcional de parmetros. Segue-se ao cabealho um bloco de declaraes dos objetos locais
do procedimento, e um bloco de comandos delimitados pelas palavras chave BEGIN e END com um
ponto-e-vrgula no nal:

PROCEDURE NomeDoProcedimento (parmetro1, parmetro2, ...);


(* declaraes de tipos, variveis, constantes, ... *)
BEGIN
comando1;

87

comando2;
...
END;
A chamada ou ativao de um procedimento feita referenciando-se o seu nome no local do
programa onde o mesmo deve ser ativado, ou seja, onde sua execuo deve ser iniciada. Ao nal
da execuo de um procedimento, o controle do programa retorna ao comando seguinte aquele
que provocou sua chamada. Assim, a execuo de um procedimento se constitui na transferncia
temporria da execuo do programa para o trecho do programa que corresponde ao procedimento.
Tudo que for declarado dentro de um procedimento, ser considerado um objeto local e ser conhecido
apenas pelo procedimento.
Exemplo: Um uso bastante comum de procedimentos para se evitar repetio de trechos
anlogos em um programa. Observe o esboo de programa a seguir:

PROGRAM Teste;
VAR x, y, z: real;
BEGIN
comando1;
comando2;
x := funo1;
y := funo2;
comando3;
comando1;
comando2;
x := funo1;
z := Cos(x);
comando4;
comando1;
comando2;
x := funo1;
comando5;
END.
Observe que o trecho

comando1;
comando2;
x := funo1;
se repete no programa. Neste caso, seria mais prtico se declarar esse trecho como sendo
um procedimento, digamos que com nome REPETE, e assim, toda vez que o trecho aparecesse,
simplesmente colocaramos a palavra REPETE no seu lugar:

PROGRAM Teste;
VAR x, y, z: real;
PROCEDURE REPETE;
BEGIN (* inicio do procedimento *)
comando1;

88

comando2;
x := funo1;
END; (* fim do procedimento *)
BEGIN (* inicio da seo principal *)
REPETE;
y := funo2;
comando3;
REPETE;
z := Cos(x);
comando4;
REPETE;
comando5;
END. (* fim do programa *)
Os dois esboos de programa anteriores so equivalentes.
Exemplo: Os procedimentos aumentam signicativamente a clareza dos programas. Voltemos
aquele nosso primeiro programa do Captulo 2, aquele que somava dois inteiros. Um programa desse
tipo feito basicamente em trs etapas:

i. Ler os inteiros;
ii. Calcular sua soma;
iii. Mostrar seu resultado.
Cada etapa na elaborao de um programa, sugere um procedimento prprio. Neste caso,
usaremos trs procedimentos LERNUMEROS, CALCULARSOMA e MOSTRARRESULTADO.
Com isso o programa principal se limitar a listar as etapas na execuo do programa:

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

BEGIN (* inicio do programa principal *)


LerNumeros;
CalcularSoma;
MostrarResultado
END. (* fim do programa *)
Neste exemplo, as variveis X, Y, SOMA so do conhecimento de todo o programa pois elas foram
denidas fora de qualquer procedimento ou funo. Dizemos que variveis assim so globais. O uso de
variveis globais deve globais ser evitado, pois pode levar a erros difceis de serem detectados. O uso
de parmetros evita o uso abusivo de variveis globais. O programa cou grande, mas ca mais fcil de
se ler uma vez que cada parte do programa executa uma tarefa especca. Podemos estar interessado
apenas na sada dos resultados, e a, bastaramos olhar o procedimento MOSTRARRESULTADO e
ignorar os demais. O programa ca tambm mais fcil de se consertar ou de se fazer mudanas.

6.2.2 PROCEDIMENTOS COM PARMETROS


A lista de parmetros, delimitada por parnteses, pode aparecer no cabealho de um
procedimento. Nessa lista, se ela existir, so designadas as variveis que recebero valores enviados ao
procedimento na hora de sua chamada. Na lista de parmetros, cada nome de varivel seguido do
nome do respectivo tipo. Entre o tipo e o nome da varivel deve haver um sinal de dois pontos.
Variveis de um mesmo tipo podem estar separadas entre si por vrgulas e o tipo comum ser
mencionado apenas uma vez. Aps o nome de cada tipo deve vir um ponto-e-vrgula:

PROCEDURE NomeDoProcedimento(var1: tipo1; var2: tipo2; ...);


Cada varivel listada no cabealho de um procedimento ser considerada uma varivel local.
Portanto, outras partes do programa nem ao menos tm conhecimento dessas variveis, mesmo que
tenham o mesmo nome. Um "x"usado no cabealho de um procedimento normalmente no tem
nenhuma relao com um outro "x"do programa principal.

Exemplo: PROCEDURE Teste(a, b, c: integer);


Um procedimento que tenha este cabealho, est preparado para aceitar exatamente 3 inteiros
quando ele for ativado. Um comando no programa como TESTE(1, 2, 3), forar a execuo do
procedimento TESTE com os valores dos parmetros a = 1, b = 2 e c = 3. TESTE parece uma
funo de 3 variveis inteiras, mas observe a grande diferena de que nenhum valor retornado, ou
seja, no h nada que possa servir de contradomnio para TESTE.
Esto 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 declarao, uma
chamada a TESTEDOIS pode ser feita como

TESTEDOIS('Jose J J da Silva', 91110023);


ou como

TESTEDOIS('Antonio A Braga', 92101234);

90

No ltimo caso, a execuo do procedimento TESTEDOIS est sendo chamada com os parmetros
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 compem o procedimento.

PROCEDURE Cor(x, y: integer);


BEGIN
TextColor(x);
TextBackground(y)
END.
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 cpia na memria de cada argumento
para que a cpia seja usada pelo procedimento. As operaes executadas com as cpias no alteram
os valores dos argumentos originais. Para evitar que o Pascal faa cpia de varivel e passe para
o procedimento a prpria varivel para ser usada, deve-se colocar a palavra chave VAR antes do
nome da varivel na lista de parmetros no cabealho. Neste caso, qualquer modicao feita com o
parmetro durante a execuo do procedimento afetar o valor da varivel original que foi passada
como parmetro. de fundamental importncia saber quando se deve usar ou no a palavra VAR
antes de um parmetro no cabealho de um procedimento. O uso do VAR onde no for necessrio
no constitui erro, mas no recomendado.
Exemplo:

PROCEDURE IncrementaUm(x: integer; VAR y: integer; z: integer);


BEGIN
x := x + 1;
y := y + 1;
z := z + 1;
END.
Neste exemplo, o procedimento INCREMENTAUM incrementa de uma unidade os valores de
cada parmetro. Suponhamos que a, b, c sejam trs variveis inteiras (tipo byte) com valores
respectivamente iguais a 10, 11 e 12. Aps uma chamada a INCREMENTAUM, como por exemplo,

IncrementaUm(a, b, c);
teremos a = 10, b = 12 e c = 12. Observe que apenas o valor de b alterado, pois o nico parmetro
precedido por um VAR no cabealho.
Se o cabealho fosse

PROCEDURE IncrementaUm(VAR x, y, z: byte);


o que equivalente a

PROCEDURE IncrementaUm(VAR x: byte; VAR y:byte; VAR z:byte);

91

ento, se a, b, c valessem 10, 11 e 12 respectivamente, aps a chamada a IncrementaUm,

IncrementaUm(a, b, c);
teramos a = 11, b = 12 e c = 13.
Observao: Se a declarao de um parmetro no cabealho de um procedimento possui a palavra
VAR, ento diz-se que a passagem do parmetro uma passagem por referncia (porque nesse caso
o Pascal informa ao procedimento a localizao na memria da varivel usada como parmetro).
Quando a declarao no tem a palavra VAR, ento temos uma passagem por valor do parmetro.
Exemplo: O procedimento a seguir troca os valores dos parmetros. Isso s pode ser feito com o
uso do VAR no cabealho, pois um caso em que os valores dos parmetros so alterados.

PROCEDURE Troca(VAR x, y: real);


VAR
aux: real; (* variavel local ao procedimento *)
BEGIN
aux := x;
x := y;
y := aux
END.
Se tivermos, por exemplo, x = 1 e y = 2, aps o comando

Troca(x, y);
teremos x = 2 e y = 1.
Se no houver o VAR no cabealho do procedimento, ento os valores de x e y no sero alterados
aps Troca(x, y).
Exemplo: Toda funo pode ser substituda por um procedimento:

FUNCTION f(x: real): real; <---> PROCEDURE F(x: real,


VAR y: real);
...
...
y := f(x);
<--->
F(x, y);
A recproca tambm verdadeira, mas no parece ser muito natural.
Neste exemplo, calculamos o fatorial de n atravs de um procedimento. No estamos, no momento,
preocupados em fazer um programinha breve e pequeno.

PROGRAM CalculandoMaisUmaVezOFatorialDeN;
USES
Crt;
VAR
n: integer; (* variaveis *)
m: integer; (* globais *)
PROCEDURE Encerrar;

92

BEGIN
Writeln;
Writeln('Valor de n invalido.');
Writeln;
Halt;
END;
PROCEDURE LerN(VAR n: integer);
(*
Neste procedimento, fundamental o VAR acima. Sem ele,
o valor de N ficaria desconhecido do programa principal.
*)
BEGIN
ClrScr; Writeln;
Write('Forneca o valor do inteiro n: ');
Readln(n);
if (n < 0) or (n > 13) then
begin
Encerrar;
end;
(* Observe que
temos aqui a chamada a um procedimento de dentro de outro.
*)
END;
PROCEDURE CalcularFatorial(n: integer; VAR fat: integer);
VAR
i: integer; (* variavel local *)
BEGIN
fat := 1;
for i := 2 to n do
begin
fat := fat * i;
end;
END;
PROCEDURE MostrarResultado(n: integer; fat: integer);
VAR
pausa: char; (* variavel local *)
BEGIN
Writeln;
Writeln(n, '! = ', fat);
Writeln;
Write('Para encerrar, pressione qualquer tecla.');
pausa := ReadKey;
END;
BEGIN (* inicio do programa principal *)
LerN(n);
CalcularFatorial(n, m);
MostrarResultado(n, m)
END. (* fim do programa *)

93

Exemplo: Um procedimento pode chamar outro (como o caso do exemplo anterior, em que
LERN pode chamar ENCERRAR) e tambm pode ter suas prprias funes e procedimentos
internos:

PROCEDURE Externo;
PROCEDURE Interno1;
begin
...
end;
PROCEDURE Interno2;
begin
...
end;
FUNCTION f_interna(x: real): real;
begin
...
end;
VAR
(* variveis locais do procedimento EXTERNO *)
BEGIN (* incio do procedimento EXTERNO *)
...
(* comandos *)
...
END; (* fim do procedimento EXTERNO *)
Neste caso, toda parte do programa que seja exterior ao procedimento EXTERNO no tem
conhecimento da existncia dos procedimentos INTERNO1 e INTERNO2 e da funo F_INTERNA.
Esses procedimentos e funo internos podem fazer referncia entre si. Por exemplo, INTERNO2 pode
usar o INTERNO1.

6.2.3 EXERCCIOS
1a Questo) Escreva um programa que tenha uma rotina que receba como parmetro um valor

"N"e retorne TRUE caso um nmero seja par, FALSE caso contrrio

2a Questo) Escreva um programa que tenha uma rotina que receba como parmetro um valor

"N"e retorne TRUE caso um nmero seja mpar, FALSE caso contrrio.

3a Questo) Dado um vetor com n elementos numricos, faa um programa que tenha uma

rotina que receba como parmetro um nmero e verique se o valor existe neste vetor. A rotina deve
retornar TRUE se o elemento existir e FALSE caso contrrio.

4a Questo) Escreva um programa que tenha uma rotina para acrescentar N caracteres "$"a

esquerdade uma STRING qualquer.

5a Questo) Escreva um programa que tenha uma rotina para acrescentar N caracteres "$"em

branco a direita de uma STRING qualquer.

6a Questo) Escreva um programa que tenha uma rotina que receba como parmetro o raio de

uma circunferncia e calcule a rea.

7a Questo) Escreva um programa que tenha uma rotina que receba como parmetro o raio de

uma circunferncia e calcule o seu comprimento.

8a Questo) Escreva um programa que tenha uma rotina que receba como parmetro dois

valores inteiros A e B para calcular A elevado a um expoente B.

94

9a Questo) Escreva um programa que tenha uma rotina que receba como parmetro uma valor

inteiro "N"e retorne o seu fatorial.

10a Questo) Faa um PROGRAMA que tenha uma rotina para calcular a seguinte expresso

matemtica:

Y =

X2
2!

2X 3
3!

3X 4
4!

4X 5
5!

+ ... +

nX (n+1)
(n+1)!

11a Questo) Escreva um programa que tenha uma rotina que leia um vetor de caracteres e

informe se o caracteres nesse vetor formam uma palavra que polndrome.

12a Questo) Escreva um programa que tenha uma rotina para calcular a seguinte expresso

at o n-simo. (N deve ser passado com parmetro).

Y = X X 2 + X 3 X 4 + X 5 ......

13a Questo) Escreva um programa que tenha uma rotina para calcular:

10
X
1
n!
i=1

14a Questo) Escreva um programa que tenha uma rotina para calcular:

50
X
1
2n
i=

15a Questo) Escreva um programa que tenha uma rotina que receba como parmetro um

inteiro e informe se um nmero ou no primo. O valor a ser retornado ser um booleano.

16a Questo) Escreva um programa que tenha uma rotina que receba duas string como

parmetro e escreva um string que corresponde a concatenao das duas strings.

17a Questo) Escreva um programa que tenha uma rotina que limpe a tela do micro e exiba o

seu nome.

18a Questo) 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 Questo) Escreva um programa que tenha uma rotina chamada CUBO que receba um valor

do tipo real e retorne a potncia elevado a 3 do mesmo.

20a Questo) 20a Questo) Escreva um programa que tenha uma rotina chamada TROCA que

receba 2 variveis inteiras (X e Y) e troque o contedo entre elas;

21a Questo) Escreva um programa que tenha uma rotina chamado SINAL que receba como

parmetro um valor N inteiro e escreva a palavra POSITIVO se N for um nmero maior que zero,
NEGATIVO se N for menor que zero, ou ZERO se N for igual a zero. Escreva um programa que leia
um nmero inteiro e, usando o procedimento SINAL, mostre se ele maior, menor ou igual a zero.

22a Questo) Escreva um programa que tenha uma rotina que receba com parmetro um nmero

n e retorne a quantidade de divisores que ele possui.

23a Questo) Escreva um programa que tenha uma rotina chamada METADE que divida um

valor do tipo real (passado como parmetro) 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 Questo) Escreva um programa que tenha uma rotina chamada MEDIA que retorne a

mdia de 3 valores reais (X, Y e Z) passados como parmetros. Escreva um programa que, para um
nmero indeterminado de alunos, faa 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 mdia do aluno (usando a funo MEDIA);
iii. exiba o nome e a mdia do aluno.
25a Questo) Escreva um programa Pascal que leia as 3 notas e o nmero de faltas de um

aluno, calcule a sua mdia e determine e exiba a sua situao. Caso a aluno tenha mais de 10 faltas,
ele est REPROVADO POR FALTA. Caso contrrio, estar REPROVADO se sua mdia for menor
que 5.0 ou APROVADO se sua mdia for superior a 5.0. Observaes:

i. utilize uma funo para calcular a mdia e um procedimento para determinar e exibir a situao
do aluno;

ii. no utilize variveis globais.


26a Questo) Escreva um programa em Pascal que calcule o valor do coseno de X atravs de

20 termos da srie abaixo:

x2
2!

x4
4!

x6
6!

x8
8!

+ ....

Observaes:

i. O valor de x ser lido;


ii. Deve ser implementado em funes independentes o clculo do fatorial e o clculo das potncias.
27a Questo) Escreva uma funo chamada SEG para receber uma medida de tempo expressa

em Horas, Minutos e Segundos e retornar esta medida convertida apenas para segundos.

28a Questo) 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.
Faa um programa que leia 2 medidas de tempo (expressas em horas, minutos e segundos) e, usando
a funo SEG e o procedimento HMS, calcule e exiba a diferena (tambm em horas, minutos e
segundos) entre elas.

29a Questo) Escreva uma funo chamada NOME_MES que receba um valor inteiro N (de

1 a 12) e retorne um string contendo o nome do ms correspondente a N. Faa um programa que


leia uma data (no formato dia, ms e ano) e, usando a funo NOME_MES, exiba a data lida no
formato abaixo:

Entrada: 23 11 1998
Sada: 23 de novembro de 1998

96

Escreva uma funo chamada DIAS_ANO que receba 3 valores inteiros (DIA, MES, ANO) e
retorne o nmero de dias decorridos no ano at o dia/ms/ano fornecido.
Escreva um funo booleana chamada DATA_VALIDA que receba uma data (DIA, MS, ANO)
e verique se a data vlida (considerando os anos bissextos).
Faa um programa que leia 2 datas, no formato dia, ms e ano (as datas devem ter o mesmo
ano) vericando se as mesmas so vlidas (atravs da funo DATA_VALIDA), calcule e exiba a
diferena de dias entre elas (usando a funo DIAS_ANO).

97

7 VETORES E MATRIZES

7.1 DECLARAO DE TIPOS


A declarao de tipos feita com um comando TYPE da seguinte forma:

TYPE
Identificador_de_tipo_1 = Tipo1;
Identificador_de_tipo_2 = Tipo2;
...
...
Pela a nomenclatura acima o Identicador_de_tipo_1, ... so identicadores e Tipo1, Tipo2, ...
so nomes de tipos pr-denidos.
Uma vez denido o tipo possvel declarar uma varivel desse tipo utlizando o VAR.

7.2 VETORES
Um vetor um conjunto formado por uma quantidade xa de dados de um mesmo tipo. Sua
declarao 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 tambm costuma ser chamado de varivel indexada ou varivel composta homognea.
Para se ter acesso n-sima componente de um vetor V, deve-se fazer referncia a V[n]. A denio
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:

FOR n := LimInf TO LimSup DO


BEGIN
V[n] := valor;
END;
ou

FOR n := LimInf TO LimSup DO


BEGIN
Readln(V[n]);
END;

98

Exemplo: As declaraes a seguir denem os vetores i = (1, 0, 0), j = (0, 1, 0) e k = (0, 0, 1), a
base cannica do R3 .

TYPE
VetorDoR3 = ARRAY[1..3] OF
VAR
i, j, k: VetorDoR3;
...
i[1] := 1; i[2] := 0; i[3]
j[1] := 0; j[2] := 1; j[3]
k[1] := 0; k[2] := 0; k[3]

real;

:= 0;
:= 0;
:= 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 (dimenso) precisa ser
xado na sua declarao e o programa NO 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 necessrio. Desse modo o programa poder trabalhar com vetores de tamanhos
menores do que o tamanho mximo declarado, bastando para isso desperdiar algumas coordenadas,
o que corresponde a desperdiar memria do computador.
Neste exemplo, deniremos uma funo VMAX que calcula o maior elemento de um vetor real
de tamanho no mximo 100. A funo VMax deve ter dois parmetros: o vetor V e seu respectivo
tamanho n. Se o leitor cou pensando que amos dizer que a denio de uma funo VMIN seria
anloga, 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

if maximo < V[i] then


begin
maximo := V[i];
end;
end;
VMax := maximo
END;
Neste exemplo, o vetor V s ca bem denido fornecen- do-se os valores de V e de n.

7.2.1 EXERCCIOS
1a Questo) Implemente um programa que tenha duas subrotinas: uma que leia e e outra que

imprima o contedo de um vetor de nmeros reais chamado Y com 10 posies.

2a Questo) Implemente um programa que tenha duas subrotinas: uma que leia um vetor de

tamanho 10 e outra que imprima somente o contedo dos vetores que receberam valores maiores que
4.

3a Questo) Implemente um programa que tenha duas subrotinas: uma que leia um vetor de

tamanho 15 e outra que imprima somente o contedo dos vetores que receberam valores negativos.

4a Questo) Implemente um programa que tenha duas subrotinas: uma que leia um vetor de

tamanho 10 e outra imprima somente o contedo dos vetores que receberam valores pares.

5a Questo) Escreva um programa que tenha trs subrotinas: uma que leia dois vetores

unidimensionais A e B, de dimenso 8, e outra que realize a troca dos elementos destes vetores;
ou seja, aps a execuo do programa o vetor B dever conteros valores fornecidos para o vetor A,
e vice-versa. E nalmente escreva a rotina que receba como parmetro um vetor unidimensional de
tamanho 8 e imprima o seu contedo na tela.

6a Questo) Faa uma funo que recebe um vetor X(20) de reais, por parmetro, e retorna a

soma dos elementos de X.

7a Questo) Faa um procedimento que recebe, por parmetro, um vetor A(25) de inteiros e

substitui todos os valores negativos de A por zero. O vetor A deve retornar alterado.

8a Questo) Faa um procedimento que gera os 10 primeiros primos acima de 100 e retorna-os

em um vetor X(10), por parmetro.

9a Questo) Faa um procedimento que recebe 2 vetores A e B de tamanho 10 de inteiros, por

parmetro. O procedimento deve retornar um vetor C, por parmetro, que contm os elementos de
A e B em ordem decrescente.

10a Questo) Faa um procedimento que recebe, por parmetro, 2 vetores de 10 elementos

inteiros e que calcule e retorne, tambm por parmetro, o vetor interseco dos dois primeiros.

11a Questo) Faa um procedimento que recebe, por parmetro, 2 vetores de 10 elementos

inteiros e que calcule e retorne, tambm por parmetro, o vetor diferena dos dois primeiros.

12a Questo) Faa um procedimento que recebe, por parmetro, 2 vetores de 20 elementos

inteiros e que calcule e retorne, tambm por parmetro, o vetor soma dos dois primeiros.

13a Questo) Faa um procedimento que recebe, por parmetro, 2 vetores de 15 elementos

inteiros e que calcule e retorne, tambm por parmetro, o vetor produto dos dois primeiros.

14a Questo) Faa um procedimento que receba, por parmetro, um vetor K(15) e retorna,

tambm por parmetro, um vetor P contendo apenas os valores primos de K.

15a Questo) Faa 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 Questo) Faa um procedimento que receba, por parmetro 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, possvel se declarar os intervalo de variao dos ndices de uma s vez, bastando
para isso se separar cada intervalo do outro por uma vrgula:

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, so necessrias leituras ou atribuies para
cada elemento. Normalmente, essas atribuies so feitas com 2 laos 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 usurio pode preferir denir a matriz elemento por elemento (sem
usar laos FOR). Abaixo esto 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

a_ij = 2i^3 - j^2 + 1


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.
Observaes: Podemos ter variveis indexadas de dimenses maiores que 2. Por exemplo, o TYPE
a seguir dene variveis de dimenses 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 variveis desses tipos (X, Y, ...), deve-se fazer
referncias 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 variveis indexadas, como os vetores e as matrizes, podem ser declaradas sem o uso do bloco
TYPE. No entanto, acreditamos que esta no uma prtica muito vantajosa para o usurio.

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

O tipo string pode ser pensado como sendo um vetor de caracteres:

TYPE
string = ARRAY [0..255] OF char;

7.3.1 EXERCCIOS
1a Questo) Dada as matraizes M e S da gura 7.1:

Figura 7.1: Matrizes M e S


Qual ser o contedo de R depois de executado os comandos:

....
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 Questo) Faa uma funo que recebe, por parmetro, uma matriz A(5,5) e retorna a soma

dos seus elementos.

3a Questo) Faa uma funo que recebe, por parmetro, uma matriz A(6,6) e retorna a soma

dos elementos da sua diagonal principal e da sua diagonal secundria.

4a Questo) Faa uma funo que recebe, por parmetro, uma matriz A(7,6) e retorna a soma

dos elementos da linha 5 e da coluna 3.

5a Questo) Faa uma funo que recebe, por parmetro, uma matriz A(6,6) e retorna o menor

elemento da sua diagonal secundria.

6a Questo) Faa um procedimento que recebe, por parmetro, 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 Questo) Faa um procedimento que receba, por parmetro, duas matrizes A(4,6) e B(6,4)

e retorna uma matriz C, tambm por parmetro, que seja o produto matricial de M por N.

103

8a Questo) Faa um procedimento que receba, por parmetro, duas matrizes A(4,6) e B(6,4)

e retorna uma matriz C, tambm por parmetro, que seja a soma de M com N.

9a Questo) Faa um procedimento que receba, por parmetro, duas matrizes A(4,6) e B(6,4)

e retorna uma matriz C, tambm por parmetro, que seja a diferena de M com N.

10a Questo) Faa um procedimento que recebe, por parmetro, 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 parmetro.

11a Questo) Faa um procedimento que receba uma matriz A(10,10), por parmetro, e realize

as seguintes trocas:

a linha 2 com a linha 8;


a coluna 4 com a coluna 10;
a diagonal principal com a secundria;
a linha 5 com a coluna 10;
O procedimento deve retornar a matriz alterada.

12a Questo) Faa uma funo que receba, por parmetro, uma matriz B(9,9) de reais e retorna

a soma dos elementos das linhas pares de B.

13a Questo) Faa um procedimento que receba, por parmetro, uma matriz A(12,12) e retorna,

tambm por parmetro, um vetor com a soma de cada uma das linhas de A .

14a Questo) Faa um procedimento que receba, por parmetro, uma matriz A(6,6) e multiplica

cada linha pelo elemento da diagonal principal daquela linha. O procedimento deve retornar a matriz
alterada.

15a Questo) Na teoria dos sistemas, dene-se como elemento minimax de uma matriz o menor

elemento de uma linha onde se encontra o maior elemento da matriz. Faa uma funo que recebe, por
parmetro, uma matriz A(10,10) e retorna o seu elemento minimax, juntamente com a sua posio.

16a Questo) Faa um procedimento que receba, por parmetro, uma matriz 61x10. O

procedimento deve somar individualmente as colunas da matriz e armazenar o resultado na 61a


linha da matriz. O procedimento deve retornar a matriz alterada.

17a Questo) Faa uma funo que receba, por parmetro, uma matriz A(12,12) e retorne a

mdia aritmtica dos elementos abaixo da diagonal principal.

18a Questo) Faa uma funo que receba, por parmetro, uma matriz A(10,10)e retorne a

soma dos elementos acima da diagonal principal.

19a Questo) Faa uma funo que receba, por parmetro, uma matriz A(7,7)e retorne o menor

valor dos elementos abaixo da diagonal secundria.

20a Questo) Faa uma funo que receba, por parmetro, uma matriz A(8,8) e retorne o menor

valor dos elementos acima da diagonal secundria.

21a Questo) Faa uma funo que receba, por parmetro, uma matriz A(12,12) e retorna a

mdia aritmtica dos elementos abaixo da diagonal principal e da diagonal secundria.

22a Questo) Faa uma funo que receba, por parmetro, uma matriz A(12,12) e retorna o

produto dos elementos acima da diagonal principal e da diagonal secundria.

Você também pode gostar