1. INTRODUÇÃO À LINGUAGEM DE PROGRAMAÇÃO
/###### /### /##### /##### /### /###
| ### /### /### ### /###__/### / ###__/## /### ### | ###
| ###| ### /###_/ ### | #### /_/ | ### |/_/ /###_/ ### | ###
| ######_/ | ### | ### / #### | ### | ### | ### | ###
| ###__/ | ######### / #### | ### | ######### | ###
| ### | ###__/### /### ### |/ ### /## | ###__/### | ###
| ### | ### | ### |/ ##### / ##### / | ### | ### | #######
|/__/ |/__/ |/__/ /____/ /____/ |/__/ |/__/ |/______/
SEMESTRE
2008/1

2. SUMÁRIO
1 - FUNDAMENTOS DE PROGRAMAÇÃO ............................................ 1
1.1 O QUE SÃO ALGORITMOS ?.................................................................. 1
1.1.1 POR QUE PRECISAMOS DE ALGORITMOS ?.................................... 2
1.1.2 MÉTODO PARA CONSTRUIR UM ALGORITMO ................................ 2
1.1.3 EXERCÍCIOS ............................................................................. 3
1.2 TIPOS DE INFORMAÇÃO...................................................................... 3
1.2.1 TIPOS INTEIROS (NUMÉRICOS) .................................................... 3
1.2.2 TIPOS REAIS (NUMÉRICOS) ......................................................... 3
1.2.3 TIPOS CARACTERES .................................................................. 4
1.2.4 TIPOS LÓGICOS......................................................................... 4
1.3 VARIÁVEIS ........................................................................................ 4
1.3.1 ARMAZENAMENTO DE DADOS NA MEMÓRIA................................. 4
1.3.2 CONCEITO E UTILIDADE DE VARIÁVEIS........................................ 4
1.4 INSTRUÇÕES PRIMITIVAS .................................................................... 5
1.5 REPRESENTAÇÃO DE ALGORITMOS ATRAVÉS DE FLUXOGRAMAS............. 6
1.5.1 EXERCÍCIOS ............................................................................. 6
1.6 INTRODUÇÃO A LINGUAGEM PASCAL ................................................... 7
1.6.1 PROGRAMAS FONTE, OBJETO E EXECUTÁVEL .............................. 8
1.6.2 NOMES DOS ARQUIVOS EM DISCO................................................ 9
2 - FUNDAMENTOS DA PROGRAMAÇÃO EM PASCAL .......................... 11
2.1 ESTRUTURA DE UM PROGRAMA EM PASCAL ......................................... 11
2.1.1 IDENTIFICADORES .................................................................... 12
2.1.2 TIPOS DEFINIDOS DO PASCAL ..................................................... 13
2.1.2.1 TIPO INTEIRO................................................................ 14
2.1.2.2 TIPO BOOLEAN .............................................................. 14
2.1.2.3 TIPO CHAR.................................................................... 14
2.1.2.4 TIPO REAL .................................................................... 14
2.1.2.5 TIPO STRING ................................................................. 14
2.1.3 DECLARAÇÃO DE VARIÁVEIS ...................................................... 15
2.1.4 DECLARAÇÃO DE CONSTANTES .................................................. 15
2.1.5 COMANDO DE ATRIBUIÇÃO ........................................................ 16
2.1.6 COMENTÁRIOS.......................................................................... 17
2.1.7 EXPRESSÕES ARITMÉTICAS ........................................................ 17
2.1.8 FUNÇÕES MATEMÁTICAS PRÉ-DEFINIDAS ..................................... 18
2.1.9 EXPRESSÕES LÓGICAS ............................................................... 19
2.2 EXERCÍCIOS ...................................................................................... 20
3 - ENTRADA E SAÍDA DE DADOS ..................................................... 23
3.1 COMANDOS DE ENTRADA ................................................................... 23
3.2 COMANDOS DE SAÍDA......................................................................... 24
3.3 FORMATAÇÃO ................................................................................... 27
3.4 O COMANDO CLRSCR ......................................................................... 29
3.4.1 EXERCÍCIOS ............................................................................. 30
3.5 EXERCÍCIOS AVANÇADOS .................................................................... 32
4 - ESTRUTURAS DE DECISÃO .......................................................... 33
4.1 COMANDOS COMPOSTOS .................................................................... 33
4.2 A ESTRUTURA DE DECISÃO IF ............................................................. 33

3. 4.2.1 EXERCÍCIOS DE FIXAÇÃO ........................................................... 41
4.2.2 EXERCÍCIOS ............................................................................. 43
4.2.3 EXERCÍCIOS OPCIONAIS ............................................................. 45
4.3 A ESTRUTURA DE DECISÃO CASE......................................................... 46
4.4 EXERCÍCIOS ...................................................................................... 49
5 - ESTRUTURAS DE REPETIÇÃO ...................................................... 51
5.1 A ESTRUTURA DE REPETIÇÃO FOR ...................................................... 51
5.1.1 EXERCÍCIOS ............................................................................. 60
5.1.2 EXERCÍCIOS OPCIONAIS ............................................................. 61
5.2 A ESTRUTURA DE REPETIÇÃO WHILE .................................................. 62
5.2.1 EXERCÍCIOS ............................................................................. 64
5.2.2 EXERCÍCIOS OPCIONAIS ............................................................. 65
5.3 A ESTRUTURA DE REPETIÇÃO REPEAT-UNTIL ....................................... 66
5.3.1 EXERCÍCIOS ............................................................................. 72
6 - FUNÇÕES E PROCEDIMENTOS ..................................................... 73
6.1 FUNÇÕES .......................................................................................... 73
6.1.1 ESTRUTURA DE UMA FUNÇÃO .................................................... 73
6.1.2 FUNÇÕES DEFINIDAS POR SOMATÓRIOS ....................................... 85
6.2 PROCEDIMENTOS............................................................................... 86
6.2.1 DEFINIÇÃO, PROCEDIMENTOS SEM PARÂMETROS ......................... 86
6.2.2 PROCEDIMENTOS COM PARÂMETROS .......................................... 89
6.2.3 EXERCÍCIOS ............................................................................. 93
7 - VETORES E MATRIZES ................................................................ 97
7.1 DECLARAÇÃO DE TIPOS ..................................................................... 97
7.2 VETORES .......................................................................................... 97
7.2.1 EXERCÍCIOS ............................................................................. 99
7.3 MATRIZES .........................................................................................100
7.3.1 EXERCÍCIOS .............................................................................102

4. 1
1 − FUNDAMENTOS DE PROGRAMAÇÃO
1.1 O QUE SÃO ALGORITMOS ?
O uso de algoritmos é quase tão antigo quanto a matemática. Com o passar do tempo, entretanto,
ele foi bastante esquecido pela matemática. Com o advento das máquinas de calcular e mais tarde
os computadores, o uso de algoritmos ressurgiu com grande vigor, como uma forma de indicar o
caminho para a solução dos mais variados problemas.
Algoritmo não é a solução do problema, pois, se assim fosse, cada problema teria um único
algoritmo. Algoritmo é o caminho para a solução de um problema, e em geral, os caminhos que
levam a uma solução são muitos.
Ao longo dos anos surgiram muitas formas de representar os algoritmos, alguns utilizando
linguagens semelhantes às linguagens de programação e outras utilizando formas grácas. O
aprendizado de algoritmos não se consegue a não ser através de muitos exercícios.
Algoritmos não se aprende:
À especicação da seqüência ordenada de passos que deve ser seguida para a realização de uma
tarefa, garantindo a sua repetibilidade, dá-se o nome de algoritmo. Embora esta denição de algoritmo
seja correta, podemos denir algoritmo, de maneira informal e completa como:
Algoritmos é um conjunto de regras, bem denidas, para a solução de um problema
em um tempo nito e com um número nto de passos.
Algoritmo pode ser denido também como um conjunto de valores como entrada e produz algum
valor ou conjunto de valores como saída. Um algoritmo deve sempre possuir pelo menos um resultado,
normalmente chamado de saída, e satisfazer a propriedade da efetividade, isto é, todas as operações
especicadas no algoritmo devem ser sucientemente básicas para que possam ser executadas de
maneira exata e num tempo nito.

5. 2
Na prática não é importante ter-se apenas um algoritmo, mas sim, um bom algoritmo. O mais
importante de um algoritmo é a sua correção, isto é, se ele resolve realmente o problema proposto e
o faz exatamente.
Para se ter um algoritmo, é necessário:
i. Que se tenha um número nito de passos;
ii. Que cada passo esteja precisamente denido, sem possíveis ambigüidades;
iii. Que existam zero ou mais entradas tomadas de conjuntos bem denidos;
iv. Que existam uma ou mais saídas;
v. Que exista uma condição de m sempre atingida para quaisquer entradas e num tempo nito.
Para que um computador possa desempenhar uma tarefa é necessário que esta seja detalhada
passo a passo, numa forma compreensível pela máquina, utilizando aquilo que se chama de programa.
Neste sentido, um programa de computador nada mais é que um algoritmo escrito numa forma
compreensível pelo computador.
1.1.1 POR QUE PRECISAMOS DE ALGORITMOS ?
Vejamos o que algumas pessoas importantes, para a Ciência da Computação, disseram a respeito
de algoritmo: A noção de algoritmo é básica para toda a programação de computadores. [KNUTH
- Professor da Universidade de Stanford, autor da coleção The art of computer programming]
O conceito central da programação e da ciência da computação é o conceito de algoritmo.
[WIRTH - Professor da Universidade de Zurique, autor de diversos livros na área e responsável pela
criação de linguagens de programação como ALGOL, PASCAL e MODULA-2].
A importância do algoritmo está no fato de termos que especicar uma seqüência de passos
lógicos para que o computador possa executar uma tarefa qualquer, pois o mesmo por si só não tem
vontade própria, faz apenas o que mandamos. Com uma ferramenta algorítmica, podemos conceber
uma solução para um dado problema, independendo de uma linguagem especíca e até mesmo do
próprio computador.
1.1.2 MÉTODO PARA CONSTRUIR UM ALGORITMO
Utilizando os conceitos já desenvolvidos, esquematizaremos um método para construir um
algoritmo logicamente correto:
i. Ler atentamente o enunciado: Deve-se reler o enunciado de um exercício quantas vezes for
necessário, até compreendê-lo completamente. A maior parte da resolução de um exercício
consiste na compreensão completa do enunciado.
ii. Retirar a relação das entradas de dados do enunciado Através do enunciado, descobrimos
quais são os dados que devem ser fornecidos ao programa, via teclado, a partir dos quais
são desenvolvidos os cálculos. Obs. Pode haver algum algoritmo que não necessite da entrada
de dados (pouco comum).
iii. Retirar do enunciado as informações de saída Através do enunciado podemos descobrir quais são
as informações que devem ser mostradas para compor o resultado nal, objetivo do algoritmo.
4. Determinar o que deve ser feito para transformar as entradas em saídas Nessa fase é que
teremos a construção do Algoritmo propriamente dito. Devemos determinar qual sequência de
passos ou ações é capaz de transformar um conjunto de dados nas informações de resultado.
Para isso, utilizamos os fatores descritos anteriormente, tais como legibilidade, portabilidade,
método cartesiano e planejamento reverso, e nalmente podemos construir o algoritmo.

6. 3
1.1.3 EXERCÍCIOS
1a
Questão) Elabore um algoritmo que mova 3 discos de uma torre de Hanói, que consiste em
3 hastes (a-b-c), uma das quais serve de suporte para os três discos de tamanhos diferentes (1-2-3),
os menores sobre os maiores. Pode-se mover um disco de cada vez para qualquer haste, sendo que
nunca deve ser colocado um disco maior sobre um menor. O objetivo é transferir os três discos da
haste A para haste C.
Figura 1.1: Torres de Hanoi
Mova disco n da haste n1 para haste n2
-
-
-
-
-
1.2 TIPOS DE INFORMAÇÃO
Todo o trabalho realizado por um computador é baseado na manipulação das informações
contidas em sua memória. Estas informações podem ser classicadas em dois tipos:
• As instruções, que comandam o funcionamento da máquina e determinam a maneira como
devem ser tratados os dados.
• Os dados propriamente ditos, que correspondem à porção das informações a serem processadas
pelo computador.
A classicação apresentada a seguir não se aplica a nenhuma linguagem de programação
especíca; pelo contrário, ela sintetiza os padrões utilizados na maioria das linguagens.
1.2.1 TIPOS INTEIROS (NUMÉRICOS)
São caracterizados como tipos inteiros, os dados numéricos positivos ou negativos. Excluindo-se
destes qualquer número fracionário. Como exemplo deste tipo de dado, tem-se os valores: 35, 0, -56,
1024 entre outros.
1.2.2 TIPOS REAIS (NUMÉRICOS)
São caracterizados como tipos reais, os dados numéricos positivos e negativos e números
fracionários. Como exemplo deste tipo de dado, tem-se os valores: 35, 0, -56, 1.2, -45.987 entre
outros.

7. 4
1.2.3 TIPOS CARACTERES
São caracterizados como tipos caracteres, as seqüências contendo letras, números e símbolos
especiais. Uma seqüência de caracteres deve ser indicada entre aspas (). Este tipo de dado também
é conhecido como string, alfanumérico, string, literal ou cadeia. Como exemplo deste tipo de dado,
tem-se os valores: Programação, Rua Alfa, 52 Apto 1, Fone 574-9988, 04387-030, , 7 entre
outros.
1.2.4 TIPOS LÓGICOS
São caracterizados como tipos lógicos 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 à contribuição do lósofo e matemático inglês George Boole na área da lógica matemática.
1.3 VARIÁVEIS
Na programação, uma variável é um objeto (uma posição, freqüentemente localizada na memória)
capaz de reter e representar um valor ou expressão. Enquanto as variáveis só existem em
tempo de execução, elas são associadas a nomes, chamados identicadores, durante o tempo de
desenvolvimento.
1.3.1 ARMAZENAMENTO DE DADOS NA MEMÓRIA
Para armazenar os dados na memória, imagine que a memória de um computador é um grande
arquivo com várias gavetas, onde cada gaveta pode armazenar apenas um único valor (seja ele
numérico, caractere ou lógico). Se é um grande arquivo com várias gavetas, é necessário 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 VARIÁVEIS
Têm-se como denição de variável tudo aquilo que é sujeito a variações, que é incerto, instável
ou inconstante. E quando se fala de computadores, temos que ter em mente que o volume de
informações a serem tratadas é grande e diversicado. Desta forma, os dados a serem processados
serão bastante variáveis. Como visto anteriormente, informações correspondentes a diversos tipos de
dados são armazenadas nas memórias dos computadores. Para acessar individualmente cada uma
destas informações, em princípio, seria necessário saber o tipo de dado desta informação (ou seja,
o número de bytes de memória por ela ocupados) e a posição inicial deste conjunto de bytes na
memória.
Percebe-se que esta sistemática de acesso a informações na memória é bastante ilegível e difícil
de se trabalhar. Para contornar esta situação criou-se o conceito de variável, que é uma entidade
destinada a guardar uma informação.
Basicamente, uma variável possui três atributos: um nome, um tipo de dado associado à mesma
e a informação por ela guardada. Toda variável possui um nome que tem a função de diferenciá-la
das demais.
Cada linguagem de programação estabelece suas próprias regras de formação de nomes de
variáveis. Adotaremos para os algoritmos, as seguintes regras:
i. um nome de variável deve necessariamente começar com uma letra;
ii. um nome de variável não deve conter nenhum símbolo especial, exceto a sublinha ( _ ) e
nenhum espaço em branco;
iii. Um nome de variável não poderá ser uma palavra reservada a uma instrução de programa.

8. 5
Exemplos de nomes de variáveis:
• Salario - correto
• 1ANO - errado (não começou uma letra)
• ANO1 - correto
• SAL/HORA - errado (contém o caractere /)
• SAL_HORA - correto
• _DESCONTO - errado (não começou com uma letra)
Obviamente é interessante adotar nomes de variáveis relacionados às funções que serão exercidas
pela mesmas dentro de um programa. Outro atributo característico de uma variável é o tipo de dado
que ela pode armazenar. Este atributo dene a natureza das informações contidas na variável. Por
último há o atributo informação, que nada mais é do que a informação útil contida na variável.
Uma vez denidos, os atributos nome e tipo de dado de uma variável não podem ser alterados
e assim permanecem durante toda a sua existência, desde que o programa que a utiliza não seja
modicado. Por outro lado, o atributo informação está constantemente sujeito a mudanças de acordo
com o uxo de execução do programa. Em resumo, o conceito de variável foi criado para facilitar a
vida dos programadores, permitindo acessar informações na memória dos computadores por meio de
um nome, em vez do endereço de uma célula de memória.
Exemplo: Suponha que fosse atribuído os seguintes valores às seguintes variáveis: A = mesa, B
= 0, C = 2, D = -5.4, E = João e E = 5.656.
A gura 1.2 mostra como estas variáveis cam armazendas na memória.
Figura 1.2: Armazenamento de variáveis na Memória
1.4 INSTRUÇÕES PRIMITIVAS
Como o próprio nome diz, instruções primitivas são os comandos básicos que efetuam tarefas
essenciais para a operação dos computadores, como entrada e saída de dados (comunicação com
o usuário e com dispositivos periféricos), e movimentação dos mesmos na memória. Estes tipos de
instrução estão presentes na absoluta maioria das linguagens de programação.
Antes de passar à descrição das instruções primitiva, é necessária a denição de alguns termos
que serão utilizados:
• Dispositivo de entrada é o meio pelo qual as informações (mais especicamente os dados) são
transferidos pelo usuário ou pelos níveis secundários de memória ao computador. Os exemplos
mais comuns são o teclado, o mouse, leitora ótica, leitora de código de barras, as tas e discos
magnéticos.

9. 6
• Dispositivo de saída é o meio pelo qual as informações (geralmente os resultados da execução
de um programa) são transferidos pelo computador ao usuário ou aos níveis secundários
de memória. Os exemplos mais comuns são o monitor de vídeo, impressora, tas e discos
magnéticos.
• Sintaxe é a forma como os comandos devem ser escritos, a m de que possam ser entendidos
pelo tradutor de programas. A violação das regras sintáticas é considerada um erro sujeito à
pena do não reconhecimento por parte do tradutor;
• Semântica é o signicado, ou seja, o conjunto de ações que serão exercidas pelo computador
durante a execução do referido comando. Daqui em diante, todos os comando novos serão
apresentados por meio de sua sintaxe e sua semântica, isto é, a forma como devem ser escritos
e a(s) ação(ões) que executam.
1.5 REPRESENTAÇÃO DE ALGORITMOS ATRAVÉS DE FLUXOGRAMAS
Fluxograma é uma representação gráca de algoritmos onde formas geométricas diferentes
implicam ações distintas. Tal propriedade facilita o entendimento das idéias contidas nos
algoritmos. Nota-se que os uxogramas convencionais preocupam-se com detalhes de nível físico
da implementação do algoritmo. Por exemplo, guras geométricas diferentes são adotadas para
representar operações de saída de dados realizadas em dispositivos distintos, como uma unidade
de armazenamento de dados ou um monitor de vídeo. A gura 1.3 mostra as principais formas
geométricas usadas em uxogramas.
De modo geral, o uxograma se resume a um único símbolo inicial, por onde a execução do
algoritmo começa, e um ou mais símbolos nais, que são pontos onde a execução do algoritmo
se encerra. Partindo do símbolo inicial, há sempre um único caminho orientado a ser seguido,
representando a existência de uma única seqüência de execução das instruções. Isto pode ser melhor
visualizado pelo fato de que, apesar de vários caminhos poderem convergir para uma mesma gura
do diagrama, há sempre um único caminho saindo desta. Exceções a esta regra são os símbolos nais,
dos quais não há nenhum uxo saindo, e os símbolos de decisão, de onde pode haver mais de um
caminho de saída (normalmente dois caminhos), representando uma bifurcação no uxo.
Um diagrama de blocos é uma forma de uxograma usada e desenvolvida por prossionais da
programação, tendo como objetivo descrever o método e a seqüência do processo dos planos num
computador. Pode ser desenvolvido em qualquer nível de detalhe que seja necessário. Quando se
desenvolve um diagrama para o programa principal, por exemplo, seu nível de detalhamento pode
chegar até as instruções. Esta ferramenta usa diversos símbolos geométricos, os quais, estabelecerão as
seqüências de operações a serem efetuadas em um processamento computacional. Após a elaboração
do diagrama de bloco, é realizada a codicação do programa. A gura abaixo mostra o exemplo de
um diagrama de blocos ou uxogramas.
A gura 1.4 mostra como caria a representação de um algoritmo que calcula a média.
1.5.1 EXERCÍCIOS
1a
Questão) Dena, com suas palavras, o que é algoritmo.
2a
Questão) Cite alguns algoritmos que podemos encontrar na vida quotidiana.
3a
Questão)De acordo com seu entendimento, qual é a característica mais importante em um
algoritmo? Justique a sua resposta.
4a
Questão) Um algoritmo não pode conter um comando como Escreva todos os números
inteiros positivos. Por quê?
5a
Questão) Suponha que temos um robô a nossa disposição. Esse robô chama-se MANNY
e precisa ser ensinado a fazer determinadas tarefas. Para ensinar o MANNY, vamos fazer uso do

10. 7
Figura 1.3: Simbologia dos Fluxogramas
português para passar-lhe as instruções necessárias à execução de cada atividade. Escreva os passos
necessários para o nosso robô executar:
• encher uma bacia com água;
• trocar uma lâmpada no teto de sua casa;
• trocar o pneu de um carro;
• calcular a sua idade daqui a 20 anos;
• calcular a média de um aluno com 3 notas.
6a
Questão) É comum ouvirmos programadores experimentados armarem: algoritmos ...
aprendi e nunca usei na prática ... não vejo necessidade.... Discuta esse tipo de armativa.
1.6 INTRODUÇÃO A LINGUAGEM PASCAL
A linguagem Pascal se destina à programação de computadores. Foi desenvolvida no nal dos
anos 60 na Suíça e seu nome é uma homenagem ao criador da primeira calculadora mecânica, o
matemático francês do século XVII Blaise Pascal.

11. 8
Figura 1.4: Fluxograma Cálcula Média
Um dos principais fatores que motivaram o surgimento da linguagem foi a obtenção de uma
linguagem simples, capaz de incentivar a edição de programas claros e facilmente legíveis, favorecendo
a utilização das boas técnicas de programação.
Assim como as outras linguagens de programação, o Pascal possui várias versões. Cada fabricante
cria sua própria versão com suas particularidades. As versões mais famosas são o Turbo Pascal, da
Borland International, e o MS-Pascal, da Microsoft. Existem versões de Pascal para todos os tipos
de computadores, desde MSX e CP-500 a computadores de grande porte como o IBM 4381.
À medida que o tempo passa, cada fabricante costuma atualizar e melhorar as versões de seus
programas. O mesmo acontece com as linguagens de programação. Em 1983, a Borland criou o Turbo
Pascal, versão 1. Essa versão inicial passou por sucessivas atualizações até que em 1991 tínhamos o
Turbo Pascal, versão 6. Neste texto, onde nos referirmos simplesmente à linguagem Pascal, estamos
nos referindo à versão 5 do Turbo Pascal, lançada em 1988.
1.6.1 PROGRAMAS FONTE, OBJETO E EXECUTÁVEL
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 gramática rigorosa ditada pela linguagem de programação. 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 máquina,
formada exclusivamente por números binários, cujos únicos algarismos são 0 e 1. Logo, o programa
fonte deve passar por algum processo de tradução para que o computador possa entendê-lo. Essa
tradução é chamada compilação. O programa fonte, após a compilação, recebe o nome de programa
objeto.
Apesar do programa objeto estar na linguagem do computador, ele ainda não pode ser executado
pois, sob um certo aspecto, está ainda incompleto. Faltam instruções nele que ensinem o computador a

12. 9
executar os comandos básicos da linguagem. Por exemplo, você pode usar uma função trigonométrica
no seu programa fonte, e na hora dela ser executada, o computador saberá como calculá-la. Quem
é que ensina ao computador a calcular valor de função trigonométrica? A resposta a essa pergunta
é simples: toda linguagem de programação possui um conjunto de instruções básicas pronto para
ser adicionado a qualquer programa objeto. Esse conjunto de instruçÕes é a biblioteca padrão da
linguagem. O ato de ligar (link) o programa objeto à biblioteca padrão é chamado ligação (que
algumas pessoas chamam de linkagem, talvez pelo hábito de usar neologismos). O programa objeto
após a ligação com a biblioteca padrão torna-se um programa executável.
+------------+ +------------+
| Programa | COMPILAÇÃO | Programa |
| fonte |-----------| objeto |
+------------+ +------------+ +-------------+
|-----------| Programa |
+-------------+ | executável |
| Biblioteca | +-------------+
| padrão |
+-------------+
1.6.2 NOMES DOS ARQUIVOS EM DISCO
Os nomes com os quais os programas de qualquer linguagem de programação são gravados no
disco, obedecem às regras de formação de nomes do sistema operacional: todo arquivo do disco é
especicado por um nome obrigatório com no máximo 8 caracteres e uma extensão opcional com no
máximo 3 caracteres. O nome e a extensão são separados por um
ponto. Os caracteres que podem aparecer no nome ou extensão são letras, algarismos e alguns
caracteres especiais como:
( ) - _ $ ! @ #
Não podem fazer parte donome ou extensão os seguintes caracteres:
+ ? * / | [ ] : ; , .
É comum um programa fonte em Pascal ter extensão PAS. Se você não mencionar a extensão
de um arquivo, o Pascal incluirá automaticamente a extensão PAS, sempre que for feito algum uso
do mesmo. Neste caso, dizemos que PAS é a extensão default( = omissão, falta) do Pascal. A
extensão, geralmente, classica o tipo do arquivo. Algumas extensões bastante comuns são:
PAS --- Programa fonte em Pascal
BAS --- Programa fonte em BASIC
C --- Programa fonte em C
FOR --- Programa fonte em FORTRAN
PRO --- Programa fonte em PROLOG
ASM --- Programa fonte em Assembly
BAK --- Arquivo cópia (back up) de outro
BAT --- Arquivo de lote (batch)
EXE --- Programa executável

13. 10
COM --- Programa executável
OBJ --- Programa objeto
SYS --- Arquivo usado pelo sistema operacional
DOC --- Texto
TXT --- Texto
TPU --- Unidade do Turbo Pascal
Por exemplo, para um programa que trate da resolução de sistemas lineares, um nome natural
poderia ser SISTEMA.PAS. No entanto, o usuário poderia chamá-lo de @##!.)$$ se quisesse. Ambos
são nomes válidos para o Pascal, aliás, para o DOS. Se no disco aparecer também um SISTEMA.BAK
e um SISTEMA.EXE, então é muito provável que o SISTEMA.BAK seja apenas uma cópia do
SISTEMA.PAS e o SISTEMA.EXE seja sua versão executável. Outras versões de Pascal, bem como
outras linguagens de programação, costumam criar arquivos OBJ no disco, correspondentes aos
programas objeto, mas não é esse o caso do Turbo Pascal. Logo, o programa objeto correspondente
a SISTEMA.PAS será mantido apenas na memória e você não terá em disco um SISTEMA.OBJ.

14. 11
2 − FUNDAMENTOS DA PROGRAMAÇÃO EM PASCAL
2.1 ESTRUTURA DE UM PROGRAMA EM PASCAL
Um programa em Pascal é um conjunto de palavras e símbolos especiais (comandos, variáveis,
funções, algarismos, parênteses, ...) escritos segundo as regras de uma sintaxe pré-xada e possui a
seguinte estrutura:
• Cabeçalho;
• Especicação das unidades usadas pelo programa;
• Declarações de tipos, constantes, variáveis, rótulos, funções e procedimentos;
• Seção principal.
O cabeçalho é usado para dar nome ao programa e possui a forma:
PROGRAM Nome_do_programa;
O cabeçalho é identicado pela palavra chave PROGRAM, seguida de um nome que identicará
o programa, e encerra-se com um ponto-e-vírgula. Ele serve apenas para orientação do usuário.
Exemplo:
PROGRAM Teste;
Uma linha como essa, atribui o nome Teste a um programa. A especicação das unidades
usadas é feita com um comando USES, seguido dos nomes das unidades a serem usadas separadas
por vírgula, com um ponto-e-vírgula no nal da linha:
USES unidade1, unidade2, ... ;
Em Pascal, diversos comandos podem ser agrupados em conjuntos denominados unidades (units).
Temos assim uma unidade para vídeo, outra para manipulação de arquivos em disco, outra com os
comandos grácos, etc. Exemplo:
USES Crt, Graph;
Esta declaração permite que sejam usados no programa comandos, funções, constantes, ... das
unidades CRT e GRAPH.
A seção principal do programa inicia-se com a palavra chave BEGIN, seguida de linhas de
comandos, e encerra-se com a palavra chave END seguida de um ponto:

15. 12
BEGIN
comando1;
comando2;
... ...
END.
A seção principal é a única parte obrigatória 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 execução de todo programa inicia-se pela seção principal.
Não serão diferenciadas letras minúsculas de maiúsculas e serão ignorados os espaços em branco.
O nal de um comando ou declaração é sinalizado por um ponto-e-vírgula. As quatro expressões a
seguir serão consideradas idênticas:
(1) X := A + B + C; (2) x:=a+b + C;
(3) x := a + (4) X :=
b + a + B
c;
2.1.1 IDENTIFICADORES
Um identicador é um conjunto de caracteres usado para dar nome a um programa, unidade,
rótulo, variável, tipo, constante, função ou procedimento. Todo identicador deve iniciar-se com uma
letra e pode ser seguido por qualquer quantidade de outras letras, algarismos ou o sinal de sublinhado
( _ ). Somente os 63 primeiros caracteres serão considerados signicativos. Exemplo:
Identificadores permitidos: X, a1, Nota, NomeDoAluno,
Valor_Maximo_de_F, MIN2P3.
Identificadores inválidos: 1a, _Nota_Um, A+B, A(2).
O comprimento do nome de um identicador não tem efeito negativo sobre o desempenho de
um programa. Assim, o usuário está livre para criar nomes longos para variáveis, funções, etc. sem o
risco de tornar o programa lento. De preferência, os nomes dos identicadores devem sugerir alguma
relação com o que estiver sendo identicado.
Alguns identicadores especiais só podem ser usados pela linguagem com um signicado já
pré-xado. Esses identicadores são chamados palavras reservadas ou palavras chave e são os
seguintes:
ABSOLUTE GOTO RECORD
AND IF REPEAT
ARRAY IMPLEMENTATION SET
BEGIN IN SHL
CASE INLINE SHR
CONST INTERFACE STRING

16. 13
DIV INTERRUPT THEN
DO LABEL TO
DOWNTO MOD TYPE
ELSE NIL UNIT
END NOT UNTIL
EXTERNAL OF USES
FILE OR VAR
FOR PACKED WHILE
FORWARD PROCEDURE WITH
FUNCTION PROGRAM XOR
Existem, ainda, alguns identicadores que, apesar de terem um signicado pré-denido para o
Pascal, não são palavras reservadas, como por exemplo: REAL, INTEGER, READ, WRITE, PI,
SIN, COS. O signicado ou a função desses identicadores podem ser redenidos e alterados pelo
usuário.
2.1.2 TIPOS DEFINIDOS DO PASCAL
O diagrama a seguir, classica os tipos pré- denidos do Pascal que serão mais utilizandos no
curso.
+---------------------+
| TIPOS PRÉ-DEFINIDOS |
+---------------------+
|
+-------------------------+
| |
+-----------+ +--------------+
| SIMPLES | | ESTRUTURADOS |
+-----------+ +--------------+
| |
| +---+
| |
| Array
+-----------------------+
| | |
string ordinal real
| |
+---------------+ +------------+
| | | |
boolean char inteiro +-----+
| |
| real
+----+
|
integer
Vale ressaltar que a linguagem não possui apenas os tipos abaixo, mas estes é que aparecerão em
99% dos problemas. Em resumo vamos trabalhar com o seguintes tipos:

17. 14
- Integer - Real
- String - Char
- Boolean (Lógico) - Array
2.1.2.1 TIPO INTEIRO
O tipo inteiro formado pelo subconjunto de inteiros, de acordo com a seguinte tabela:
Tipo Domínio 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 expressões lógicas. É 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
símbolos especiais como +, =, %, $, #, , etc.). As constantes deste tipo são escritas entre apóstrofos:
'A', 'B', '3', etc.
2.1.2.4 TIPO REAL
O tipo real possui o seguinte domínio e tamanho:
Tipo Domínio Dígitos Tamanho
--------------------------------------------------------
real [2.9E-39, 1.7E38] 11-12 6 bytes
--------------------------------------------------------
Em Pascal, as potências de 10 são indicadas com um E. Por exemplo, 2E07 é o mesmo que 2
vezes 10 elevado a 7; 3.28E-11 é o mesmo que 3,28 multiplicado por 10 à -11.
Os domínios anteriores referem-se aos valores absolutos das constantes. Com isso, temos que
o tipo real da tabela acima corresponde aos números que estão na união dos intervalos [2.9E-39,
1.7E38] e [-1.7E38, -2.9E-39]. Está sendo indicada também a quantidade de dígitos signicativos de
cada tipo.
2.1.2.5 TIPO STRING
O tipo string é uma seqüência de caracteres de comprimento variando de 0 a 255. Escrevendo
string[N], estamos denindo N como tamanho máximo da seqüência (neste caso N deve ser menor
ou igual a 255). As constantes do tipo string devem estar entre apóstrofos.
Exemplo: TYPE
Nome = string[40];

18. 15
Neste exemplo está sendo declarado o tipo Nome que é uma seqüência de até 40 caracteres.
Podem ser consideradas deste tipo as constantes 'Turbo Pascal 5.0', '1991/1992' e 'UFPB - CCEN -
Dep. de Matematicá.
Falaremos dos tipos restantes em capítulos posteriores.
2.1.3 DECLARAÇÃO DE VARIÁVEIS
Todas as variáveis usadas por um programa em Pascal devem obrigatoriamente ser declaradas
com antecedência em um bloco de declarações VAR da seguinte forma:
VAR
Identificador, ..., Identificador: Tipo1;
Identificador, ..., Identificador: Tipo2;
... ...
Seguem alguns exemplos de declaração de variáveis 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 estão sendo declaradas as variáveis x, y, z como sendo do tipo real, uma variável
Tamanho do tipo integer, além de outras variáveis (i, j, ...). Os tipos das variáveis não podem ser
mudados durante a execução do programa e os valores que elas podem assumir devem ser compatíveis
com o seu tipo declarado. Por exemplo, a variável i acima pode assumir o valor 2309, mas não pode
assumir um valor fracionário como 0.71.
2.1.4 DECLARAÇÃO DE CONSTANTES
As constantes de um programa Pascal devem ser declaradas em um bloco CONST na forma:
CONST
Identificador = Expressão;
Identificador = Expressão;
... ...
Identificador: tipo = Valor;
Identificador: tipo = Valor;
... ...
Seguem alguns exemplos de declaração de constantes:
CONST

19. 16
Pi = 3.1415926;
NumeroMaximoDeLinhas = 1024 + 253 + 5;
Mensagem: string[20] = 'Hello world!';
X: integer = 7;
As constantes que são declaradas sem a especicação de tipo não podem ser alteradas durante
a execução do programa. Aquelas cujas declarações contiverem o tipo base, chamadas constantes
tipadas, desempenham um papel parecido com o das variáveis e podem ser alteradas durante a
execução do programa. A diferença entre uma variável e uma constante tipada é que a variável não
pode ter nenhum valor inicialna sua declaração.
2.1.5 COMANDO DE ATRIBUIÇÃO
A atribuição de um valor ou de uma expressão a um identicador é feita através do operador de
atribuição := . A sintaxe de uma operação de atribuição é:
Identificador := expressão;
Neste tipo de operação, a expressão e o identicador devem ser do mesmo tipo, exceto no caso em
que o identicador for do tipo real e a expressão do tipo inteiro (pois, neste caso, o valor inteiro da
expressão será automaticamente transformado em real). Exemplo: Considere a seguinte declaracão
de variáveis:
VAR
a, b, c: integer;
x, y: real;
teste: boolean;
data: string;
Neste caso, são válidas as atribuições:
a := -17;
x := y + 3.14;
teste := false;
data := '5/12/1991'
Mas não são válidas as atribuições:
teste := a + b + 1;
c := 6.02E23;
Em caso de várias atribuições a um mesmo identicador, será considerada apenas a última
atribuição efetuada.

20. 17
2.1.6 COMENTÁRIOS
Comentários são usados para aumentar a clareza de um programa. Todos os comentários são
desprezados na hora da compilação, logo, eles não têm inuência no desempenho e nem no tamanho
do programa objeto. Um comentário é colocado entre chaves ou entre (* e *).
{ Este é um exemplo de comentário... }
(* e este também é um comentário! *)
Para o Pascal, as declarações VAR abaixo serão consideradas equivalentes. Para o usuário, o
segundo bloco de declarações VAR oferece mais clareza.
VAR mat, nota, cod: string;
VAR
mat, { matrícula }
nota, { nota final }
cod: { codigo do curso }
string;
2.1.7 EXPRESSÕES ARITMÉTICAS
As operações aritméticas pré-denidas do Pascal são:
+ Adição - Subtração
/ Divisão * Multiplicação
DIV Quociente da divisão MOD Resto da divisão
inteira inteira
9/2 = 4.5 -3*7 = -21
9 DIV 2 = 4 9 MOD 2 = 1
10 DIV 2 = 5 10 MOD 2 = 0
Estas operações podem ser utilizadas com operandos reais ou inteiros, exceto DIV e MOD que
exigem operandos inteiros. A prioridade entre as operações é a mesma da Matemática:
i. Primeiramente, são efetuadas as multiplicações e divisões (/, DIV e MOD);
ii. por último, são efetuadas as adições e subtrações. Temos então dois níveis de prioridades.
Dentro de um mesmo nível, são efetuadas as operações da esquerda para a direita.
Exemplo: Na expressão 5 - 2/3*7 + 1 as operaçoes são efetuadas na seguinte ordem: divisão,
multiplicação, subtração e adição.
Se uma expressão contiver parênteses, então será executado primeiramente o que estiver entre
parênteses. Exemplo:

21. 18
Expressão Valor
------------------------
5 + 2*4 13
(5 + 2)*4 28
7 DIV 2*3 9
7 DIV (2*3) 1
------------------------
Observações:
i. Não existe operador pré-denido para a potenciação.
ii. O sinal de multiplicação nunca poderá ser omitido.
iii. A divisão / sempre fornece um resultado real, mesmo que os operandos sejam inteiros.
iv. Se todos os operandos forem inteiros e as operações envolvidas forem +, -, *, MOD ou DIV,
então o resultado será inteiro.
2.1.8 FUNÇÕES MATEMÁTICAS PRÉ-DEFINIDAS
Entre as muitas funções pré-denidas do Pascal, as que estão relacionadas com valores numéricos
são:
Função Descrição 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 fracionária real
ODD Testa se é ímpar booleano
-------------------------------------------------------
Em todas elas deve-se acrescentar um argumento entre parênteses à frente do nome da função,
como em COS(x) ou SQRT(y). O Pascal não tem pré-denidas funções como tangente, secante,
arco-seno, ... . Em breve será mostrado como o usuário poderá denir essas funções, bem como
outras com domínio e contradomínio mais complexos.
Exemplo: O modulo do seno do quadrado de x e codicado como ABS(SIN(SQR(x))). Neste tipo
de expressão, é obrigatório que a quantidade de parênteses abertos seja a mesma de fechados.
Exemplo: O quociente entre x2
+ 3x e x2
+ 5 se escreve como (SQR(x) + 3*x)/(SQR(x) + 5) ou
como (x*x + 3*x)/(x*x + 5). Nestes casos, o uso dos parênteses é fundamental.

22. 19
Exemplo: A derivada do arco-seno de x, ou seja, 1 sobre a raiz quadrada da diferença 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 função booleana ODD testa se um inteiro n e impar ou não. ODD(n) fornece um
valor TRUE se n for ímpar e FALSE em caso contrário. Desse modo, ODD(5) = TRUE e ODD(4)
= FALSE. Exemplo:
TRUNC(1.35) = 1 (inteiro) TRUNC(1.97) = 1 (inteiro)
INT(1.35) = 1 (real) INT(1.97) = 1 (real)
ROUND(1.35) = 1 ROUND(1.97) = 2
FRAC(1.35) = 0.35 FRAC(1.97) = 0.97
As funções INT e TRUNC são numericamente equivalentes. A diferença entre elas está apenas
no tipo do valor retornado.
2.1.9 EXPRESSÕES LÓGICAS
Expressão lógica (ou expressão booleana) é uma expressão cujos operadores são operadores lógicos
e cujos operandos são relações ou variáveis do tipo booleano. Os operadores lógicos são AND (e),
OR (ou), NOT (não) e XOR (ou exclusivo). Se X e Y são variáveis ou constantes booleanas, então:
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 relação é uma comparação realizada entre valores do mesmo tipo, cujo resultado é TRUE
ou FALSE. A comparação é indicada por um dos operadores relacionais a seguir:
= igual diferente
menor maior
= menor ou igual = maior ou igual
No caso de variáveis do tipo CHAR ou STRING, será usada a ordem alfabética para comparar
duas constantes ou variáveis.
Exemplo: Sejam a, b, c, d variaveis booleanas cujos valores são:
a := 1 2;
b := 3 = 5;
c := a OR b;
d := a AND b;
Como 1 2 é uma relação verdadeira, temos que a tem valor TRUE; 3 = 5 é falso, logo, b tem
valor FALSE. Sendo a TRUE e b FALSE temos que c é TRUE, pois a OR b só seria FALSE se a e
b fossem ambas FALSE. O valor de d é FALSE, uma vez que b é FALSE.
Exemplo: Consideremos as variaveis x, y, z, nome1, nome2 e teste declaradas abaixo:

23. 20
VAR
x, y, z: byte;
nome1, nome2: string;
teste: boolean;
Considere também as seguintes atribuições:
x := 3;
y := 10;
z := 4;
nome1 := 'Guizinha';
nome2 := 'Olezinho';
teste := false;
Temos então:
Expressão Valor
--------------------------------------------
x = y TRUE
(x = z) OR (x + z = y) FALSE
nome1 nome2 TRUE
(nome1 nome2) AND (NOT teste) TRUE
(nome1 = nome2) AND (x = y) FALSE
(NOT (x z)) OR teste OR (y z) TRUE
Odd(x) AND (NOT Odd(y)) TRUE
Odd(x) XOR Odd(y + 1) FALSE
(x mod 3 = 0) AND (y div 3 1) FALSE
Sqr(Sin(x)) + Sqr(Cos(x)) = 1 TRUE
--------------------------------------------
A prioridade das operações aritméticas, lógicas e relacionais está denida na seguinte tabela:
Prioridade Operadores
-------------------------------------
1 (alta) NOT
2 *. /, DIV, MOD, AND
3 +, -, OR, XOR
4 (baixa) =, =, =, , ,
-------------------------------------
2.2 EXERCÍCIOS
1a
Questão) Escreva as seguintes expressões de acordo com a sintaxe do Pascal:
3 2
a) sen(2x) = 2.sen(x).cos(x) b) x + 5x - 2x + 4

24. 21
1 arctg(x) + |x|
c) ------------------- d) e
Ln(x + Ln(x)) + 1
1a
Questão) Considere as constantes e as variáveis 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 após as seguintes atribuições:
i) a := m MOD 2 + n DIV (m + p);
ii) a := TRUNC(x)*ROUND(SQRT(2))
iii) a := SQR(p + 1) MOD (m MOD ABS(p));
iv) z := SQRT(2*m + p)/ROUND(EXP(1));
v) z := INT(11/7) - FRAC(1/(1 + n + 2*p));
b) Detecte o que está errado com as atribuições 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
Questão) Sejam a, b, c três variáveis que, em determinado momento da execução de um
programa, valem respectivamente 1, 2 e 3. Avalie o valor das seguintes expressões lógicas:
a) Odd(a) OR Odd(b) AND Odd(c);
b) NOT (b (a + c) DIV 2) AND NOT (a = 0)
c) (a = b + c) XOR (b = c + a)
d) (c = a) AND (NOT (a = 5*b - 3*c) OR (c = a + b))
4a
Questão) X e Y são duas constantes com valores -3 e 5, e CLASSIFICA é uma variável
booleana com valor FALSE em determinado momento. Determine o valor que está sendo atribuído
à variável booleana TESTE em cada um dos casos:

25. 22
a) TESTE := X Y;
b) TESTE := NOT (Abs(X*Y) = 5e20);
c) TESTE := (X 0) OR (Y 10*Abs(X)) OR Classifica;
d) TESTE := (X + Y 1) AND (Sqrt(Y) 1.2E-9);

26. 23
3 − ENTRADA E SAÍDA DE DADOS
Os comandos de entrada ou saída fazem a comunicação entre o programa que está sendo executado
e os periféricos de entrada (teclado, disco) ou os de saída (vídeo, disco, impressora). A entrada ou
saída de dados para um disco será tratada em capítulo posterior.
3.1 COMANDOS DE ENTRADA
Um comando de entrada, também chamado de comando de leitura, transfere dados do dispositivo
de entrada (teclado) para uma ou mais variáveis na memória, funcionando como um comando de
atribuição. Os dados que entram devem ser compatíveis com os tipos das variáveis. Dois dos comandos
de entradas do Pascal são READ e READLN, cujas sintaxes são:
READ(Var1, Var2, ...); --- Transfere dados para as
variáveis Var1, Var2, ...
READLN(Var1, Var2, ...); --- Transfere dados para as
variáveis Var1, Var2, ...
e, após a leitura dos dados,
posiciona o cursor no início
da próxima 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 espaço em
branco.
Exemplo: Suponhamos que A e B sejam duas variaveis reais de um programa. Quando a execução
do programa chegar em um comando como
Read(A, B);
Então o computador cará esperando que sejam digitados dois números reais para que sejam
atribuídos às variáveis A e B. Por exemplo, digitando-se uma linha como
3.05 -5.17
Pressionando-se ENTER ao nal da digitação dos números, serão atribuídos os valores 3.05 a A
e -5.17 a B. É como se o programa contivesse as atribuições:
A := 3.05; B := -5.17;

27. 24
3.2 COMANDOS DE SAÍDA
Um comando de saída transfere dados para um dispositivo de saída (vídeo, impressora). Os
dados que podem ser transferidos são valores ou expressões envolvendo constantes ou variáveis. Dois
comandos de saída bastante usados são WRITE e WRITELN que têm 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
início da próxima linha na tela.
Onde v1, v2, ... acima podem ser expressões envolvendo variáveis ou constantes do tipo inteiro,
real, string, booleano ou char.
Exemplo: Suponhamos que X seja uma variavel inteira de um programa, com valor 15 no momento
em que for executado o comando:
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 início da linha seguinte a essa na tela. Observe que a mensagem
O valor encontrado foi é uma constante do tipo string. Portanto, neste exemplo, o comando de
saída mostra os valores de uma constante e de uma variável.
Exemplo: Suponhamos que X, Y, Z, A, B e C sejam variaveis com valores respectivamente iguais
a ' Antonio ', ' Jose ', ' Maria ', 60, 75 e 90. Então, o comando:
WRITELN(x, a, y, b, z, c);
Exibirá na tela algo como:
Antonio 60 Jose 75 Maria 90
A seqüência de comandos:
WRITELN(x); WRITELN(a); WRITELN(y);
WRITELN(b); WRITELN(z); WRITELN(c);
Mostrará algo como:

28. 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 início de uma nova linha.
Exemplo: Vamos elaborar agora nosso primeiro programa completo. Queremos digitar dois
números inteiros no teclado e desejamos que o computador mostre sua soma no vídeo. Sejam Num1
e Num2 os nomes das variáveis que vão guardar na memória os valores dos números digitados no
teclado. A atribuição de valores a Num1 e Num2, neste caso, será feita por um comando como
READ(Num1, Num2);
Ou como:
READLN(Num1, Num2);
No entanto, quando o computador executar esse tipo de comando, em momento nenhum ele lhe
indicará se ele está esperando um, dois, três ou mais números. Tampouco indicará o tipo de dado
que está sendo esperado, se é um dado numérico ou não. Devido a isso, é recomendado que antes de
qualquer comando READ ou READLN, o programa contenha uma linha anterior com um WRITE
ou WRITELN para mostrar alguma mensagem que oriente o usuário.
Neste caso, colocaremos um comando WRITE para mostrar a mensagem Forneca dois numeros
inteiros : .
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 expressão Num1 + Num2 em um comando de saída:
WRITELN('Soma = ', Num1 + Num2);

29. 26
Observe que neste WRITELN temos uma constante do tipo string 'Soma = ' e uma expressão
aritmética Num1 + Num2.
Nosso programa ca, então, com o seguinte aspecto:
PROGRAM SomaDeDoisInteiros;
VAR
Num1, Num2: integer;
BEGIN
WRITE('Forneca dois numeros inteiros : ');
READLN(Num1, Num2);
WRITELN('Soma = ', Num1 + Num2);
END.
Estamos atribuindo o nome SomaDeDoisInteiros ao programa. Observe que os comandos do
programa (WRITE..., READLN..., ...) devem car na seção principal do programa delimitados pelas
palavras BEGIN e END. Não pode ser omitido o ponto após o END. O bloco VAR de declaração de
variáveis deve vir antes da seção principal.
É comum se deslocar para a direita as linhas de comandos compreendidas entre um BEGIN e um
END. Esse tipo de deslocamento é chamado endentação. 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 27
Soma = 38
_
O caracter de sublinhado _ acima representa a posição do cursor na tela. Qualquer outra saída
de dado posterior à execução do programa seria feita a partir dessa posição. Se a seção principal
deste programa fosse:
BEGIN
WRITELN('Forneca dois numeros inteiros : ');
READLN(Num1, Num2);
WRITE('Soma = ', Num1 + Num2);
END.
Então teríamos uma tela como:
Forneca dois numeros inteiros :
11 27
Soma = 38_
Observe a diferença na posição nal do cursor.
Observação: sem parâmetros, ou seja, só o nome do comando seguido imediatamente de um ponto
e vírgula. Um WRITELN sem parâmetros causa a impressão de uma linha em branco. Por exemplo:

30. 27
WRITELN; WRITELN; WRITELN;
Isso causa a impressão de três linhas em branco.
Um READLN sem parâmetros faz o computador car esperando que se pressione a tecla ENTER
para poder continuar. Temos assim, uma maneira de causar uma pausa na execução de um programa.
Durante a execução do fragmento de programa a seguir, o computador coloca uma mensagem na tela
(Para continuar...), e pára temporariamente a execução até ser pressionado ENTER.
... ...
WRITE('Para continuar, pressione [ENTER]');
READLN;
... ...
3.3 FORMATAÇÃO
A impressão dos valores a serem impressos por um WRITE ou WRITELN pode ser formatada
através da especicação da largura do campo de impressão ou do número de casas decimais.
Para valores do tipo inteiro, booleano, string ou char, basta colocar o tamanho do campo de
impressão à direita do valor a ser impresso. Neste caso, o valor e o tamanho do campo devem estar
separados por dois pontos (:).
WRITE(V:n) ou WRITELN(V:n) --- Imprime o valor de V em um
campo de n espaços
Se o valor de n for maior do que a quantidade necessária para a impressão do valor de V, então
a largura do campo será completada com espaços em branco adicionados à esquerda.
Exemplo: Consideremos x1, x2, s1, s2 variaveis com valores denidos pelas atribuições
x1 := 8; s1 := 'A';
x2 := 19; s2 := '*';
Para cada comando WRITE abaixo, temos as seguintes saídas mostradas na tela:
Comando Saída
---------------------------------------------------
WRITE(x1) 8
WRITE(x1:2) ^8
WRITE(x1:10) ^^^^^^^^^8
WRITE(x1, s1, x2, s2) 8A19*
WRITE(x1, ' ', s1, ' ', x2, ' ', s2) 8^Â19^*
WRITE(x1, s1:2, x2:5, s2:3) 8^Â^^19^^*
WRITE(x1:6, x2:2) ^^^^^819
WRITE(x1, ' ':5, x2) 8^^^^^19
---------------------------------------------------

31. 28
O símbolo na tabela acima assinala os espaços em branco. Em um comando WRITE ou
WRITELN, a impressão de n espaços em branco pode ser feita acrescentando-se à lista de valores a
serem impressos uma expressão da forma ' ':n, como no último exemplo da tabela acima. O tamanho
do campo de impressão pode ser uma expressão aritmética. Por exemplo, WRITE(dado:5) é o mesmo
que WRITE(dado:(11 - 9 + 3)).
Para se formatar a impressão de um valor real, devem ser fornecidos dois inteiros que
correspondem ao tamanho do campo de impressão 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 necessária para a impressão do valor de x, então a
largura do campo será completada com espaços em branco adicionados à esquerda. O ponto decimal
ou o sinal negativo ocupam um espaço do campo de impressão. O tamanho do campo de impressão
e a quantidade de casas decimais podem ser fornecidos em forma de expressão aritmética. Valores
reais sem formatação são impressos em forma de potências de 10.
Exemplo: Consideremos Pi e X constantes reais com valores respectivamente iguais a
3.1415926535 e -1991. A tabela a seguir mostra as diversas saídas geradas pelo respectivo comando
WRITE. Denotamos os espaços em branco por .
Comando Saída
-------------------------------------
WRITE(X:9:3) -1991.000
WRITE(X:15:2) ^^^^^^^-1991.00
WRITE(X:10:2) ^^-1991.00
WRITE(X) -1.9910000000E+03
WRITE(Pi) 3.1415926535E+00
WRITE(Pi:4:2) 3.14
WRITE(Pi:7:2) ^^^3.14
WRITE(Pi:10:3) ^^^^^3.141
WRITE(Pi:10:6) ^^3.141592
WRITE(Pi:10:8) 3.14159265
WRITE(Pi:5:0) ^^^^3
-------------------------------------
Exemplo: Vamos construir agora um programa que solicita ao usuário a medida de um ângulo
em graus (um número inteiro) e mostra na tela o seno, o cosseno e a tangente do ângulo fornecido.
As funções trigonométricas pré-denidas SIN(x) e COS(x) operam com um ângulo x em radianos.
Logo, o programa deve ser esperto o suciente para transformar o ângulo em graus, fornecido pelo
usuário, para um valor equivalente em radianos. Isto é feito através de uma multiplicação por Pi/180.
O Pascal tem o valor de Pi pré-denido com 19 casas decimais. Vamos usar três variáveis reais seno,
cossenoe tangentepara guardar os valores desejados. Vamos exigir que a impressão dos valores
seja em um campo com 8 espaços e 4 casas decimais.
PROGRAM Sen_Cos_Tg;
{ Calculo do seno, cosseno e tangente de um angulo }
VAR

32. 29
AnguloEmGraus: INTEGER;
seno, cosseno, tangente, AnguloEmRadianos: REAL;
BEGIN { inicio da secao principal }
WRITE('Forneca a medida de um angulo (em graus) : ');
READLN(AnguloEmGraus);
WRITELN; { gera uma linha em branco }
AnguloEmRadianos := AnguloEmGraus*Pi/180; { transforma
graus em radianos }
seno := SIN(AnguloEmRadianos); { Calculo dos valores }
cosseno := COS(AnguloEmRadianos); { desejados. Lembre- }
{ se que o Pascal nao }
tangente := seno/cosseno; { tem funcao tangente }
{ pré-definida }
{ Saida dos resultados }
WRITELN('Seno de ', AnguloEmGraus, ' = ', seno:8:4);
WRITELN('Cosseno de ', AnguloEmGraus, ' = ', cosseno:8:4);
WRITELN('Tangente de ',AnguloEmGraus,' = ', tangente:8:4);
END. { fim da secao principal }
Executando-se esse programa (após a digitação correta deve-se pressionar CTRL-F9 e ALT-F5),
vemos na tela algo parecido com:
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 versão 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 padrão chamada SYSTEM.
A unidade SYSTEM não 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 cabeçalho 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 próprio nome sugere, é limpar a tela. Muitos dos livros sobre Pascal
disponíveis em Português, referem-se às versões anteriores à 4. Nesses livros, não é feita referência à
unidade CRT.
Exemplo: Queremos fornecer tres numeros reais a, b e c ao computador e queremos que ele nos
forneça, com três casas decimais, o valor da área do triângulo cujos lados medem a, b e c. Vamos
querer também que o computador se dê ao trabalho de limpar a tela antes de pedir os valores de a,
b, c. Vamos usar a fórmula da Geometria Plana que diz que, neste caso, a área desejada é igual à
raiz quadrada de p(p - a)(p - b)(p - c) onde p é a metade da soma a + b + c.

33. 30
PROGRAM AreaDoTriangulo;
{
Dados os números reais a, b, ç é fornecida o valor
da área do triângulo cujos lados têm essas medidas.
}
USES CRT; { Permite o uso de comandos da unidade CRT, como
o CLRSCR. Deve ser colocado nesta posição, logo
abaixo do cabeçalho }
VAR
a, b, c, p, area: REAL;
BEGIN
CLRSCR; { Limpa a tela }
{ Leitura dos valores de a, b e c }
WRITE('Valor de a: '); READLN(a);
WRITE('Valor de b: '); READLN(b);
WRITE('Valor de c: '); READLN(c);
{ Calculo da area }
p := (a + b + c)/2;
area := SQRT(p*(p - a)*(p - b)*(p - c));
{ Impressao dos resultados na tela }
WRITELN;
WRITELN('A area do triangulo cujos lados medem');
WRITELN(a:7:3, ',', b:7:3, ' e ',c:7:3,' é' ', area:7:3);
END.
A impressão de um apóstrofo é obtida colocando-se dois apóstrofos consecutivos como parte da
constante string. Assim, WRITELN(' e ') tem como saída na tela um é, que não chega a ser
um eacentuado, mas ajuda na leitura. No lugar dos três READLN acima, poderíamos ter colocado
apenas um READLN(a, b, c). Este programinha não é inteligente o suciente para rejeitar na entrada
valores negativos ou valores inválidos como a = 3, b = 5, c = 11. Após sua execução 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 EXERCÍCIOS
1a
Questão) Escreva um programa em Pascal que leia duas variáveis A e B e depois calcule e
imprima a média dos valores lidos.
2a
Questão) Crie um programa que leia quatro números do teclado e imprima a média deles na
tela.
3a
Questão)Elabore um programa que leia cinco números do teclado e imprima o produto deles.
4a
Questão)Escreva um programa que leia seis números inteiros do teclado e imprima a soma
deles.
5a
Questão)Apresente o seguinte algoritmo:
i. Ler 2 valores, no caso variáveis A e B.

34. 31
ii. Efetuar a soma das variáveis A e B colocado seu resultado na variável X;
iii. Apresentar o valor da variável X após a soma dos dois valores indicados.
6a
Questão)Elabore um programa que leia a quantidade de chuva em polegadas e imprima a
equivalente em milímetros (25,4 mm = 1 polegada).
7a
Questão)Dados dois lados de um triângulo retângulo, faça um programa para calcular a
hipotenusa.
8a
Questão) Leia 2 variáveis A e B, que correspondem a 2 notas de um aluno. A seguir, calcule
a média do aluno, sabendo que a nota A tem peso 3 e a nota B tem peso 7.
9a
Questão) Leia 3 variáveis A e B e C, que são as notas de um aluno. A seguir, calcule a média
do aluno, sabendo que a nota A tem peso 2, a nota B tem peso 3 e a nota C tem peso 5.
10a
Questão) Leia 4 variáveis A,B,C e D. A seguir, calcule e mostre a diferença do produto de
A e B pelo produto de C e D (A*B-C*D).
11a
Questão) O custo ao consumidor de um carro novo é a soma do custo de fábrica com
a percentagem do distribuidor e dos impostos (aplicados ao custo de fábrica). Supondo que a
percentagem do distribuidor seja de 12% e os impostos 45%, preparar um programa para ler o
custo de fábrica do carro e imprimir o custo ao consumidor.
12a
Questão) Escreva um programa que leia uma temperatura em graus Celsius e converta para
graus fahrenheit.
C = 5∗(F−32)
9
13a
Questão) Escrever um algoritmo para calcular o volume de uma esfera sendo fornecido o
valor de seu raio.
V olume = 4
3
.π.R3
Onde π e uma constante que vale 3.1415 e R é o raio da esfera.
14a
Questão)Leia 4 variáveis A,B,C e D. A seguir, calcule e mostre a diferença do produto de A
e B pelo produto de C e D (A*B-C*D).
15a
Questão)Entrar com dois números inteiros e exibir a seguinte saída:
Dividendo:
Divisor:
Quociente:
Resto:
16a
Questão)Entrar com um ângulo em graus e exibi-lo em radianos.
17a
Questão) Entrar com um ângulo em graus e exibir o valor do seno, co-seno e tangente.
18a
Questão)Faça um programa que entre com o saldo e aplique um percentual de 10%. Mostre
o valor com o reajuste.
19a
Questão) Leia um número com três dígitos e imprima-o na ordem inversa, ou seja, se o
número for 453 imprima 354.
20a
Questão) Uma pessoa resolveu fazer uma aplicação em uma poupança programada. Para
calcular rendimento, ela deverá fornecer o valor constante da aplicação mensal, a taxa e o número de
meses. Sabendo-se que a fórmula usada nesse cálculo e:

35. 32
V alorCalculado = P ∗ (1+i)2−1
i
Onde:
i. i = Taxa;
ii. P = Aplicação Mensal
iii. n = número de meses
Faça um algoritmo que calcule o valor da aplicação.
3.5 EXERCÍCIOS AVANÇADOS
1a
Questão) Preparar um programa para ler os comprimentos dos três lados de um triângulo
(S1, S2 e S3) e calcular a área do triângulo de acordo com a fórmula:
Area = T(T − S1)(T − S2)(T − S3)
Onde,
T = S1+S2+S3
2

36. 33
4 − ESTRUTURAS DE DECISÃO
Para resolver problemas complexos, um programa deve ser capaz de tomar decisões e escolher
uma entre várias possibilidades. Nestes casos, são necessárias avaliações bem sucedidas de condições
lógicas. O Pascal dispõe de duas estruturas que podem determinar uma direção especíca para um
programa: o comando IF-THEN-ELSE e o comando CASE.
4.1 COMANDOS COMPOSTOS
Chamaremos de comando composto a toda seqüência nita de instruções separadas entre si por
um ponto-e-vírgula e delimitadas pelas palavras chave BEGIN e END.
Exemplo: A seqüência de comandos a seguir é um comando composto:
BEGIN
ClrScr;
Write('Valor de x? ');
Readln(x)
END
Todo ponto-e-vírgula escrito antes de um END é opcional. É por isso que omitimos o
ponto-e-vírgula do Readln(x) acima. Também é comum se acrescentar alguns espaçoes em branco
nas linhas de comandos entre o BEGIN e o END (esse acréscimo de espaços em branco costuma ser
chamado endentação ou indentação). Onde a sintaxe do Pascal permitir uma instrução simples,
também permitirá um comando composto.
4.2 A ESTRUTURA DE DECISÃO IF
A estrutura de decisão IF seleciona para execução um entre dois comandos, ou decide se um
determinado comando será executado ou não. A estrutura consiste das cláusulas obrigatórias IF (se)
e THEN (então) seguidas, opcionalmente, de uma cláusula ELSE (senão). Sua sintaxe é:
IF condição THEN
BEGIN
comando1;
END
ELSE
BEGIN
comando2;
END;
ou
IF condição THEN
BEGIN
comando1;

37. 34
END;
onde condição é uma expressão booleana. Se a condição for verdadeira, isto é, for avaliada
em TRUE, então será executado o comando1; se a condição for falsa (FALSE), será executado o
comando2. Na sua segunda forma (sem o ELSE), o IF não executará nenhuma ação se a condição
for falsa.
IF IF
| |
/ /
TRUE / FALSE TRUE / FALSE
+-----cond-----+ +-----cond-----+
| / | | / |
| / | | / |
v v v |
+----------+ +----------+ +----------+ |
| comando1 | | comando2 | | comando1 | |
+----------+ +----------+ +----------+ |
| | | |
+------+-------+ +---------------+
| |
O comando1 ou comando2 acima podem ser comandos compostos ou outras estruturas de decisão.
Exemplo: Consideremos a seguinte estrutura de decisão:
IF (x 0) THEN
BEGIN
WRITE(Sqrt(x));
END
ELSE
BEGIN
x := 1;
END;
Neste caso, se x for um valor numérico positivo, então será mostrado o valor da sua raiz quadrada.
Em caso contrário, será atribuído a x o valor constante 1. A condição neste caso é a expressão lógica
x 0, o comando1 é o WRITE(Sqrt(x)) e o comando2 é a atribuição x := 1. A condição lógica deste
exemplo não precisaria estar entre parênteses.
OBSERVAÇÃO IMPORTANTE: Não deve haver ponto-e-vírgula antes do ELSE. Se
houvesse, o ponto-e-vírgula seria considerado o nal do IF e, neste caso, o ELSE seria considerado o
comando seguinte ao IF e seria rejeitado.
Exemplo: Suponhamos que x seja uma variável real de um programa e consideremos o seguinte
IF:
IF (x -1) AND (x 1) THEN
BEGIN
Writeln('X tem modulo menor do que 1');

38. 35
END
ELSE
BEGIN
Writeln('X tem modulo = 1');
END;
Se x em determinado momento valer 2, então a expressão booleana (x -1) AND (x 1)
será falsa e, assim, será mostrada na tela a mensagem X tem modulo = 1. Os parênteses dessa
expressão booleana são essenciais. Sem eles, teríamos
x -1 AND x 1
Veja que o AND tem prioriade sobre os operadores de comparação e , caríamos com uma
expressão sem sentido equivalente a x (-1 AND x) 1.
Exemplo: Consideremos o seguinte fragmento de um programa, no qual estão denidas a variável
booleana CONTINUAR, a variável do tipo char RESPOSTA, e as variáveis inteiras A e B.
...
Write('Continua? (s/n) '); Readln(resposta);
Continuar := (resposta = 'S') OR (resposta = 's');
(* CONTINUAR será TRUE somente quando RESPOSTA
for um S, maiúsculo ou minúsculo *)
IF Continuar THEN
BEGIN (* Inicio do comando composto 1 *)
Write('Forneca o valor de A : ');
Readln(A);
Write('Forneca o valor de B : ');
Readln(B);
END (* Fim do comando composto 1. Nao pode ter
ponto-e-vírgula aqui *)
ELSE
BEGIN (* Inicio do comando composto 2 *)
Writeln;
Writeln('Pressione ENTER para encerrar');
Readln;
END; (* Fim do comando composto 2 e fim do IF *)
...
No IF acima, se CONTINUAR for verdadeira, então serão solicitados valores para A e B. Em
caso contrário, o programa esperará ser pressionado a tecla ENTER para encerrar. Nas constantes
do tipo char ou string, é feita distinção entre letras minúsculas e maiúsculas. Logo, 'S' é considerado
diferente de 's'.
Exemplo: Queremos, neste exemplo, elaborar um programa que solicite do usuário um número
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

39. 36
Se x for negativo, por exemplo -9, queremos ver algo como
A raiz quadrada de -9.000 é 3.000 i
A função pré-denida SQRT(x) calcula a raiz quadrada de x, se x for maior do que ou igual
a 0. Portanto, se x for negativo, deveremos calcular a raiz de -x e acrescentar um ià direita do
resultado. Temos assim uma situação em que o programa deve decidir se calcula SQRT(x) ou se
calcula SQRT(-x), um caso típico de uma estrutura de decisão IF:
PROGRAM RaizQuadrada;
VAR
x: real;
BEGIN
Write('Valor de x? '); Readln(x);
IF (x = 0) THEN
BEGIN
Writeln('A raiz quadrada de ', x:7:3, ' e'' ',SQRT(x):7:3);
END
ELSE
BEGIN
Writeln('A raiz quadrada de ', x:7:3, ' e'' ',SQRT(-x):7:3, ' í);
END;
END.
Exemplo: A ordem denida no conjunto das constantes do tipo string ou char é uma extensão
da ordem alfabética. As letras maiúsculas são diferenciadas das minúsculas e ocupam uma posição
anterior às mesmas. Assim, a ordem nesses conjuntos satisfaz a:
'A' 'B' 'C' ... 'Z' ... 'a' 'b' ... 'z'
Devido a isso, temos que 'X' 'b', 'JOAO PESSOA' 'joao', 'Matematica' 'logica'.
No fragmento a seguir, nome1, nome2 e aux são duas variáveis do tipo string. Queremos comparar
nome1 com nome2, e se nome1 for maior do que nome2, queremos trocar os valores de nome1
por nome2 entre si. Toda troca de valores de variáveis só é possível com a ajuda de uma variável
intermediária, que neste caso será aux.
...
IF (nome1 nome2) THEN
BEGIN
aux := nome1; (* Troca nome1 *)
nome1 := nome2; (* por nome2 *)
nome2 := aux;
END;
Se tivéssemos, por exemplo, nome1 = 'Joaó e nome2 = 'Aná, após a execução do IF anterior
passaríamos a ter nome1 = 'Aná e nome2 = 'Joaó. Observe que um fragmento como

40. 37
...
IF (nome1 nome2) THEN
BEGIN
nome1 := nome2;
nome2 := nome1;
END;
...
não faria a troca desejada. Neste caso, nome1 e nome2 cariam ambas iguais a 'Ana' e o valor 'Joao'
estaria perdido.
Exemplo: O programa a seguir, testa se três números reais fornecidos pelo usuário podem ser
usados como medidas dos lados de um triângulo retângulo. Exige-se que os valores sejam todos
positivos e fornecidos em ordem crescente. Uma vez fornecido os números, o teste para saber se
eles formam um triângulo retângulo ou não será testar se o quadrado do maior deles é a soma dos
quadrados dos menores.
PROGRAM TrianguloRetangulo;
VAR
a, b, c: real;
teste: boolean;
BEGIN
Write('Forneca 3 números positivos em ordem crescente: ');
Readln(a, b, c);
teste := (a 0) and (b 0) and (c 0) and (a b) and
(b c); (* TESTE será TRUE somente quando as
condições desejadas forem satisfeitas *)
IF teste THEN
BEGIN
IF (Sqr(c) = Sqr(a) + Sqr(b)) THEN
BEGIN
Writeln(a:6:2, ',', b:6:2, ' e ', c:6:2, ' formam um',
' triangulo retangulo.');
END
ELSE
BEGIN
Writeln(a:6:2, ',', b:6:2, ' e ', c:6:2, ' nao ',
'formam um triangulo retangulo.');
END;
END;
ELSE
BEGIN
Writeln('Os valores fornecidos devem ser positivos e ',
'em ordem crescente.');
END;
END.
Observe que temos dois IF's encaixados. O IF mais interno (IF (Sqr(c)...) só será executado
quando TESTE for TRUE.
Exemplo: Sendo fornecidos 3 números reais, o programa a seguir mostra o maior entre eles.

41. 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 ausência do ponto-e-vírgula em muitas das linhas acima.
Exemplo: Resolver uma equação do segundo grau, sendo fornecidos seus coecientes a, b e c.
Nosso roteiro na elaboração 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 execução do programa;
• Calcular o valor do discriminante ∆ = b2
− 4 ∗ a ∗ c;
• Se o Delta for maior ou igual a zero, calcular as raízes x1 e x2 usando a conhecidíssima fórmula;
• Se o Delta for negativo, calcular as raízes complexas.
x1 = −b+
√
∆
2a
x2 = −b−
√
∆
2a
Estamos colocando o módulo na parte imaginária simplesmente porque queremos que x1 tenha
parte imaginária positiva e x2 a parte imaginária negativa, independentemente de a ser positivo ou
não.

42. 39
• Limpar a tela;
• Mostrar a equacao;
• Imprimir as raízes.
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 }

43. 40
END.
Após a execução 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 usuários com uma disposição maior de trabalho o exercício de melhorar a saída
desses resultados, fazendo-a mais próxima do usual. Por exemplo, no exemplo executado acima, seria
mais interessante (e mais trabalhoso) mostrar uma linha como
2
EQUACAO: x - 2 x + 3 = 0.
Observação: Um dos aspectos que mais causam confusão com relação ao IF em qualquer
linguagem de programação é o IF encaixado (também chamado de IF aninhado). O problema consiste
na diculdade de se indenticar que ELSE está relacionado com qual IF. Nestes casos uma boa
endentação pode ajudar. Observe o seguinte IF:
IF condição1 THEN
BEGIN
IF condição2 THEN
BEGIN
comando1;
END;
END
ELSE
BEGIN
comando2;
END;
A qual dos dois IF's anteriores o ELSE se refere? A forma na qual os IF's foram escritos sugere
erroneamente que o ELSE está relacionado com o primeiro IF. No entanto, ele está relacionado com o
segundo IF. Em geral, o ELSE está ligado ao IF mais próximo. Assim, uma forma melhor de escrever
o fragmento acima é:
IF condição1 THEN
BEGIN
IF condição2 THEN
BEGIN
comando1;
END
ELSE
BEGIN
comando2;
END;
END;

44. 41
Se quiséssemos realmente que o ELSE estivesse relacionado com o primeiro IF, então a forma
correta de se escrever seria:
IF condição1 THEN
BEGIN
IF condição2 THEN
BEGIN
comando1;
END;
END
ELSE
BEGIN
comando2;
END;
Este tipo de erro lógico em um programa, em geral, é difícil de se detectar. Ele costuma ser
chamado de armadilha dos IF's encaixados.
4.2.1 EXERCÍCIOS DE FIXAÇÃO
1a
Questão) Escreva o programa referente ao uxograma da gura 4.1.
Figura 4.1: Fluxograma A
2a
Questão) Para os valores (a=5) (b=7) e (c=9), assinale com X a seqüência de execução dos
Algoritmos abaixo:
a)
SE a = 5 E b = 7 Entao ( )
c: c + 1 ( )
senão ( )
c := c - 1; ( )
fim-se ( )

45. 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
Questão) Escreva o programa referente ao uxograma da gura 4.2.2.
Figura 4.2: Fluxograma B
4a
Questão) Para as saídas, considere os seguintes valores: A=2, B=3, C=5, D=9 e E=6.
a) Resposta: _______
Se não D 5 entao
X := (A + B) * D;
senao
X := (A - B) / C
fim-se
Escrever X
b) Resposta: _______
Se (A 2) E (B 7) entao
X := (A + 2) * (B - 2);
senao

46. 43
X := (A + B) / D * (C + D)
fim-se
Escrever X
c) Resposta: ______
Se (A 2) E (B 7) entao
X := (A + 2) * (B - 2)
senao
X := X := (A + B) * D / (C + D)
fim-se
Escrever X
d) Resposta: ______
Se (A = 2) OU (C 1) Entao
X := (A + D) / 2;
senao
X := D * C;
fim-se
Escrever X
e) Resposta: ______
Se nao (A 2) ou nao (B 7) entao
X := A + E;
senao
X := A / E;
fim-se
Escrever X
f) Resposta: ______
Se nao (A 3) e nao (B 5) entao
X := A + D;
senao
X := D / B
fim-se
Escrever X
4.2.2 EXERCÍCIOS
1a
Questão) Faça um programa que leia dois números inteiros A e B da entrada padrão (teclado)
e retorne o quociente da divisão entre A e B. O programa deve vericar, previamente à divisão, se o
valor de B é diferente de zero.
2a
Questão) Leia um valor inteiro X e diga se ele é par ou ímpar.
3a
Questão) Escreva um algoritmo para receber o sexo e a idade de uma pessoa. Se a pessoa for
do sexo feminino e tiver menos de 25 anos, imprimir o nome e a mensagem: ACEITA. Caso contrário,
imprimir o nome e a mensagem não aceita. (Considerar para o Sexo as letras F,f,M ou m).
4a
Questão)Faça um programa que leia dois números inteiros A e B da entrada padrão (teclado)
e imprima o maior deles. Dê um tratamento caso estes números forem iguais.
5a
Questão)Escreva um algoritmo para receber a sigla e o Estado de uma pessoa e imprimir
uma das seguintes mensagens:

47. 44
• Carioca;
• Paulista;
• mineiro;
• Outros estados.
6a
Questão)Faça um programa que leia dois inteiros A e B e imprima a soma destes valores se
eles forem iguais, senão, ou seja, se forem diferentes imprima o seu produto.
7a
Questão)Leia três lados de um triângulo e diga que:
i. O triângulo é equilátero se todos os lados forem iguais;
ii. O triângulo é escaleno se todos os lados forem diferentes;
iii. O triângulo é isóceles se apenas dois lados forem iguais.
8a
Questão) Escreva um algoritmo para o calcula das raízes de uma equação do segundo grau.
9a
Questão)Escreva um algoritmo que leia o código de um aluno e suas três notas. Calcule a
média ponderada do aluno, considerando que o peso para a maior nota seja 4 e para as duas restantes,
3. Mostre o código do aluno, suas três notas, a média calculada e uma mensagem APROVADO se
a média for maior ou igual a 5 e REPROVADOse a média for menor que 5.
10a
Questão) Faça um algoritmo que leia um no
inteiro e mostre uma mensagem indicando se
este número é par ou ímpar, e se é positivo ou negativo.
11a
Questão) Tendo como dados de entrada a altura e o sexo de uma pessoa (M masculino e F
Feminino), construa um algoritmo que calcule seu peso ideal, utilizando as seguintes fórmulas:
• para homens: (72.7*h)-58
• para mulheres: (62.1*h)-44.7
12a
Questão)Um usuário deseja um algoritmo onde possa escolher que tipo de média deseja
calcular a partir de 3 notas. Faça um algoritmo que leia as notas, a opção escolhida pelo usuário e
calcule a média.
1 - aritmética
2 - ponderada (3,3,4)
13a
Questão) Elaborar um algoritmo que lê 3 valores a,b,c e verica se eles formam ou não um
triângulo. Supor que os valores lidos são inteiros e positivos. Caso os valores formem um triângulo,
calcular e escrever a área deste triângulo. Se não formam triângulo escrever os valores lidos. ( se a
b + c não formam triângulo algum, se a é o maior).
14a
Questão) O departamento que controla o índice de poluição do meio ambiente mantém 3
grupos de indústrias que são altamente poluentes do meio ambiente. O índice de poluição aceitável
varia de 0,05 até 0,25. Se o índice sobe para 0,3 as indústrias do 1o grupo são intimadas a suspenderem
suas atividades, se o índice cresce para 0,4 as do 1o e 2o grupo são intimadas a suspenderem suas
atividades e se o índice atingir 0,5 todos os 3 grupos devem ser noticados a paralisarem suas
atividades. Escrever um algoritmo que lê o índice de poluição medido e emite a noticação adequada
aos diferentes grupos de empresas.
15a
Questão) Escrever um algoritmo que leia o tempo de duração em segundos de um
determinado evento em uma fábrica e informe-o expresso no formato horas:minutos:segundos.

48. 45
16a
Questão) Escrever um algoritmo que leia a idade de uma pessoa em dias e informe-a em
anos, meses e dias. Suponha que 1 ano possua 365 dias e um mês possua 30 dias.
17a
Questão)Faça um algoritmos para ler um número e imprimir se ele é igual a 5, 200 ou 400.
Se não vericar se o mesmo está no intervalo entre 500 e 1000 inclusive , ou se está fora do escopo
especicado.
18a
Questão)Faça um algoritmo que leia o percurso em quilômetros, o tipo de carro e informe
o consumo estimado de combustível, sabendo-se que um carro do tipo C faz 12 Km com um litro de
gasolina, um do tipo B faz 9 Km e o do tipo A faz 8 Km por litro.
19a
Questão) 19a Questão) Um endocrinologista deseja controlar a saúde de seus pacientes e,
para isso se utiliza de um índice de massa corporal (IMC). Sabendo-se que o IMC é calculado através
da fórmula abaixo:
IMC = Peso
Altura2
Onde o Peso é dado em Kg e a Altura é dada em metros. Faça um algoritmo que apresente o nome
do paciente e sua faixa de risco, baseando-se na seguinte tabela 4.2.2:
4.2.3 EXERCÍCIOS OPCIONAIS
1a
Questão) Escrever um algoritmo que lê a hora de início e hora de término de um jogo,
ambas subdivididas em dois valores distintos : horas e minutos. Calcular e escrever a duração do
jogo, também em horas e minutos, considerando que o tempo máximo de duração de um jogo é de
24 horas e que o jogo pode iniciar em um dia e terminar no dia seguinte.
2a
Questão) Escrever um algoritmo que lê um valor em reais e calcula qual o menor número
possível de notas de 100, 50, 10, 5 e 1 em que o valor lido pode ser decomposto. Escrever o valor lido
e a relação de notas necessárias.
3a
Questão) Ler três números do teclado e imprimi-los em ordem crescente.
4a
Questão)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, são quaisquer valores reais e os escreva. A seguir:
i. Se i=1 escrever os três valores a, b, c em ordem crescente.
ii. Se i=2 escrever os três valores a, b, c em ordem decrescente.
iii. Se i=3 escrever os três valores a, b, c de forma que o maior entre a, b, c que dentre os dois.

49. 46
4.3 A ESTRUTURA DE DECISÃO CASE
O comando IF-THEN-ELSE permite que um entre dois comandos seja executado. O comando
CASE permite que seja selecionado um entre vários comandos. Desse modo, o CASE funciona como
uma generalização do IF com a seguinte restrição: a expressão que é usada para selecionar os comandos
deve ser do tipo ordinal. Sua sintaxe é:
CASE expressão OF
val_1 : comando1;
val_2 : comando2;
... ...
ELSE
comandoN;
END;
O valor da expressão ordinal é avaliado e comparado com cada valor alvo val_1, val_2, ... .
Se existir algum valor alvo que coincida com o valor da expressão, então será executado apenas o
comando que estiver associado aquele valor. Se o valor da expressão não coincidir com nenhum valor
alvo, então será executado o comando que estiver associado ao ELSE, se esse comando existir. O
ELSE de um CASE é opcional. Para encerrar o CASE deveremos ter um END, mas não temos um
BEGIN para iniciar.
CASE
|
+---+ val_1 +----------+
| e |-------------| comando1 |--------+
| x | +----------+ |
| p | val_2 +----------+ |
| r |-------------| comando2 |--------+
| e | +----------+ |
| s | ... ... |
| s | |
| ã | ELSE +----------+ |
| o |-------------| comandoN |--------+
+---+ +----------+ |
v
Exemplo: Suponhamos que x seja uma variável inteira. Então o comando CASE abaixo executará
o comando1 quando tivermos x = 5, o comando2 quando x = 11, o comando3 quando x = -4 e o
comando4 quando x for diferente desses três valores anteriores.
CASE x OF
5 : comando1;
11 : comando2;
-4 : comando3;
ELSE
comando4;
END;

50. 47
Em um CASE, no lugar de um único valor alvo, podemos ter um lista de valores alvo associados a
um mesmo comando. Nessa lista, os valores devem ser separados por vírgulas ou fornecidos em forma
de intervalo valor1..valor2, onde valor1 e valor2 são, respectivamente, os limites inferior e superior do
intervalo. Por exemplo, 1..1000 é uma forma abreviada de se referir aos inteiros de 1 a 1000 e 'A'..'G'
é o mesmo que 'A', 'B', 'C', 'D', 'E', 'F', 'G'.
Exemplo: Seja N inteiro que possa assumir em um programa valores de 0 a 100. Consideremos o
seguinte CASE:
CASE N OF
1, 3, 5,
7, 9 : Write('N impar, N = 10');
2, 4, 6,
8, 10 : Write('N par, N = 10');
11..20 : Write('11 = N = 20');
21..100 : Write('21 = N = 100');
END;
De acordo com o valor de N, será mostrada apenas uma das mensagens N impar, N = 10,
N par, N = 10, 11 = N = 20ou 21 = N = 100.
Exemplo: Consideremos no CASE abaixo, CH como uma variável do tipo ordinal char.
CASE Ch OF
'A'..'Z', 'a'..'z' :
Writeln('E'' uma letrá);
'0'..'9':
Writeln('E'' um algarismó);
'+', '-', '/', '*':
Writeln('E'' uma operacaó);
ELSE
Writeln('E'' um caracter especial');
END;
De acordo com o valor de CH, será mostrada uma mensagem especíca, dizendo se CH é letra,
digito, operador ou símbolo especial ('', '?', '[', '$', '%', ...)
Exemplo: O programa a seguir lê dois números reais A e B do teclado e mostra na tela um menu
onde o usuário poderá selecionar uma das operações A+B, A-B, A/B, A*B ou A elevado a B. Uma
vez feita a escolha da operação, seu resultado será mostrado na tela. Para ler qual foi o número da
opção do menu, poderíamos usar um READLN(opcao), mas não vamos usá-lo. Vamos usar um outro
comando de entrada chamado READKEY. Sua sintaxe é:
Variável := READKEY;
O READKEY espera que seja digitado um caracter do teclado e o associa à variável do tipo
char escrita antes do símbolo de atribuição ( := ). Além disso, READKEY não mostra o caracter
digitado na tela, nem espera ser pressionado ENTER. Os comandos CASE e READKEY são ideais
para serem usados em menus.
PROGRAM Menu;

51. 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.

52. 49
4.4 EXERCÍCIOS
1a
Questão) Em que situações é mais indicado o uso da estrutura CASE-OF ?
2a
Questão) Em que situações não podemos utilizar a estrutura CASE-OF ?
3a
Questão)Desenvolva um programa que leias dois números inteiros da entrada padrão com os
nomes A e B e, em seguida, implemente um menu principal com as seguintes opções:
a. A + B
b. A - B
c. A * B
d. A / B
Em seguida, efetue e mostre o resultado da operação determinada pela opção escolhida.
4a
Questão) Faça um programa em Pascal que leia um número que represente um mês do ano.
Após a leitura, imprima o mês correspondente por extenso. Caso o número entrado não esteja na
faixa de 1 até 12, imprima uma mensagem informando ao usuário que o mês é inválido.
5a
Questão) Faça 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 Classificação
0 até 3 Bebê
4 até 10 Criança
11 até 18 Adolescente
Acima de 18 Adulto
6a
Questão) Supondo que a cobrança de imposto de renda na fonte seja feita com base na tabela
abaixo, elabore um programa que mostre na tela o valor do imposto, quando o usuário fornecer o
valor do salário (inteiro).
+------------------------+----------+-------------------+
| salario (em Cr$) | alíquota | parcela a deduzir |
+------------------------+----------+-------------------+
| até 200000 | ---- | ----- |
| de 200001 a 300000 | 5% | 10000 |
| de 300001 a 400000 | 10% | 25000 |
| de 400001 a 500000 | 15% | 45000 |
| a partir de 500001 | 20% | 70000 |
+------------------------+----------+-------------------+
Por exemplo, para um salário de 350000, temos uma alíquota de 10valor do imposto, segundo a
tabela, deverá ser de
350000 * 0.10 - 25000 = 10000 cruzeiros.
7a
Questão) Em cada caso abaixo, determine o valor do inteiro x após a execução do seguinte
CASE, sabendo que o valor do inteiro y antes da execução do CASE é:

53. 50
a) y = 7; CASE y OF
-10..0 : x := 5;
b) y = -7; 2, 4 : x := y div 2 + Sqr(y - 1);
5..10 : BEGIN
c) y = 2; IF Odd(y) THEN y := 12;
x := Round(Sqrt(y + 5))
d) y = -2; END;
ELSE
e) y = 20 IF y 4 THEN x := 0 ELSE x := 1;
END;

54. 51
5 − ESTRUTURAS DE REPETIÇÃO
A repetição é a essência de muitas aplicações em computadores. Uma estrutura de repetição é
uma estrutura que comanda os processos de repetição, por mais complexos e complicados que sejam.
Uma tarefa essencial no projeto de qualquer estrutura de repetição (também chamada de
loopou laço) é como decidir quando as repetições (ou iterações) devem terminar. O Pascal
oferece três estruturas de repetição diferentes, cada uma com um esquema próprio para o controle
do processo de repetição: os comandos FOR, WHILE e REPEAT.
5.1 A ESTRUTURA DE REPETIÇÃO FOR
O FOR especica explicitamente a faixa de iterações. A quantidade de iterações é controlada por
uma variável de controle que deve ser do tipo ordinal, cujo valor aumenta ou diminui à medida que
cada repetição é executada. Sua sintaxe é:
FOR Variável := ValorInicial TO ValorFinal DO
BEGIN
comando;
END;
ou
FOR Variável := ValorInicial DOWNTO ValorFinal DO
BEGIN
comando;
END;
Observe que:
• VARIÁVEL é a variável de controle do FOR, que deve ser do tipo ordinal (integer).
• VALORINICIAL é o valor que a variável de controle assumirá na primeira iteração. Deve ser
do mesmo tipo da variável de controle.
• VALORFINAL é o valor que a variável de controle assumirá na última iteração. Deve ser do
mesmo tipo da variável de controle.
• COMANDO é o comando que será executado em cada iteração. Pode ser uma seqüência
nita de outros comandos delimitada por BEGIN-END (comando composto). Se ValorInicial
= ValorFinal, então deve ser usado um FOR-TO. Caso contrário, deve ser usado um
FOR-DOWNTO.
Um esboço da execução do FOR é o seguinte:
i. No início da execução, a variável 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,
então a primeira iteração é executada, isto é, o comando escrito após o DO é executado.

55. 52
ii. Antes de cada iteração subseqüente, a variável de controle recebe o próximo valor (no caso do
FOR-TO) ou o valor anterior (no caso do FOR-DOWNTO) do intervalo ValorInicial..ValorFinal
(ou ValorFinal..ValorInicial).
iii. O laço assim criado termina após a iteração corresponde ao ValorFinal.
Exemplo: FOR i := 1 TO 5 DO Writeln(Sqr(i)); onde i é do tipo inteiro, funciona da seguinte
forma:
i. É atribuído o valor 1 a i e, como 1 5, é executado o comando escrito após o DO, o
Writeln(Sqr(i)). Assim, é mostrado o quadrado de 1 na tela;
ii. A variável i passa a ter o valor seguinte ao anterior, ou seja, i passa a valer 2 e o comando é
executado. É mostrado, então, o quadrado de 2 na tela.
iii. A variável de controle i vai ser aumentada de uma em uma unidade e a cada acréscimo o
WRITELN é executado. Esse processo acaba quando a variável atingir o valor 5.
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 diferença: os valores de i
vão 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 variável do tipo char. O FOR a seguir mostra na tela todas as letras
maiúsculas 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 minúsculas: zyxv...cba. Veja o exemplo abaixo:
FOR i := 100 TO 50 DO
BEGIN
comando;
END;
FOR j := 1 DOWNTO 20 DO
BEGIN
comando;
END;

56. 53
No FOR i... e no FOR j... acima, o comando escrito após o DO não será executado nenhuma vez.
Exemplo: A variável de controle do FOR, quando for numérica, terá de ser do tipo inteiro e só
poderá aumentar ou diminuir de 1 em 1. Podemos multiplicar ou dividir essa variável todas as vezes
em que ela aparecer no comando, como forma de aumentar ou diminuir o valor do incremento em
cada iteração. Por exemplo,
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 têm 256 valores. As funções que estabelem
uma bijeção entre esses valores são as funções ORD e CHR, inversas uma da outra.
CHR(n) --- n-ésimo caracter do tipo char;
ORD(x) --- Ordinal do caracter x.
Os valores que o n acima podem assumir são de 0 a 255 e o x desde o primeiro ao último caracter
pré-denido do computador (de um total de 256).
CHR(n) também pode ser denotado como #n. Alguns valores particulares dessas funções são:
ORD('$') = 36 CHR(36) = '$' ou #36 = '$'
ORD('+') = 43 CHR(43) = '+' ou #43 = '+'
ORD('7') = 55 CHR(55) = '7' ou #55 = '7'
ORD('A') = 65 CHR(65) = 'A' ou #65 = 'A'
ORD('B') = 66 CHR(66) = 'B' ou #66 = 'B'
ORD('C') = 67 CHR(67) = 'C' ou #67 = 'C'
ORD('Z') = 90 CHR(90) = 'Z' ou #90 = 'Z'
ORD('') = 92 CHR(92) = '' ou #92 = ''
ORD('a') = 97 CHR(97) = 'a' ou #97 = 'a'
ORD('z') = 122 CHR(122) = 'z' ou #122 = '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

57. 54
Writeln(i:4, Chr(i):4);
IF (i MOD 10 = 0) AND (i 0) THEN
BEGIN
Writeln;
Writeln('Pressione [ENTER] para continuar.');
Readln;
Writeln(' n Chr(n)');
Writeln('-----------');
END; { fim do IF }
END; { fim do FOR }
END. { fim do programa }
No programa acima, a variável inteira i varia de 0 a 255. Devido ao IF (i MOD 10...) , sempre
que i for maior que 0 e múltiplo de 10 , o programa fará uma pausa. Ao ser pressionado a tecla
ENTER, serão mostradas mais 10 linhas da tabela e assim o programa prossegue até chegar em i =
255. Alguns caracteres ASCII são símbolos que não podem ser impressos. Por exemplo, o #7 é um
som de bip (beep).
Ao ser executado, ele gera na tela varios trechos como esse:
n Chr(n)
-----------
61 =
62
63 ?
64 @
65 A
66 B
67 C
68 D
69 E
70 F
Pressione [ENTER] para continuar.
Exemplo: Neste exemplo, vamos calcular o valor de um somatório. Em particular, consideraremos
a soma dos 5 primeiros termos da série cujo termo geral é 1
n2+1
Chamaremos a variável que vai guardar
o valor do somatório de S. Em todo cálculo de somatório, a variável que irá guardar o valor da soma
deverá ter um valor inicial nulo. A seguir, usamos um FOR com variável de controle fazendo o papel
do índice do termo geral do somatório para atuar no comando S := S + Termo_Geral, o que neste
caso, é S := S + 1/(n2 + 1). Ao nal da execução do FOR, temos em S o valor da soma desejada.
PROGRAM Somatorio;
{ ------------------------------------------- }
{ CALCULO DE UM SOMATORIO }
{ ------------------------------------------- }
VAR
S: real;
n: integer;
CONST
IndiceInicial = 1;

58. 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, são feitas as seguintes atribuições de valores a S:
S := 0;
S := 0 + 1/2; ( n = 1 )
S := 1/2 + 1/5; ( n = 2 )
S := (1/2 + 1/5) + 1/10; ( n = 3 )
S := (1/2 + 1/5 + 1/10) + 1/17; ( n = 4 )
S := (1/2 + 1/5 + 1/10 + 1/17) + 1/26; ( n = 5 )
Exemplo: Neste exemplo, queremos calcular a soma dos 10000 primeiros termos das séries cujos
termos gerais são 1
n
e 1
n2 . Não vamos nos contentar só com o resultado nal, queremos acompanhar o
valor do somatório de 1000 em 1000 termos. A série 1/n2
converge para (π2
)/6; logo, a raiz quadrada
de 6 vezes o somatório de 1/n2
fornece uma aproximação para o valor de π.
Usaremos quatro caracteres ASCII especiais: o #227 que é um pi minúsculo, o #228 que é
um sigma maiúsculo, o #253 que é um expoente 2 e o #247 que usaremos como símbolo de
aproximadamente.
A unidade CRT dispõe de dois comandos para alterar as cores de textos da tela. São eles o
TEXTCOLOR, para alterar a cor do texto, e TEXTBACKGROUND, para alterar a cor de fundo.
Suas sintaxes são:
TextColor(Nome_da_cor)
e
TextBackground(Nome_da_cor)
onde Nome_da_cor pode ser uma das seguintes constantes:
Black = 0; Blue = 1;
Green = 2; Cyan = 3;
Red = 4; Magenta = 5;
Brown = 6; LightGray = 7;
DarkGray = 8; LightBlue = 9;
LightGreen = 10; LightCyan = 11;
LightRed = 12; LightMagenta = 13;
Yellow = 14; White = 15;
Blink = 128;