Apostila Prof Virgilio Vilela

APRENDENDO
A PROGRAMAR
NA PRÁTICA
Virgílio V. Vilela
"A rocha é imensa e dura. O cortador bate uma, duas, três, dez vezes,
nenhuma rachadura. Ele dá 100 marteladas, só tirando lascas. Na
centésima primeira batida, a rocha imensa e dura se parte em duas. O
cortador de pedras sabe que não foi somente aquela martelada a que
conseguiu, mas também todas as que vieram antes".
"E na próxima pedra, o cortador pode pegar uma ferramenta mais

apropriada e cortar a pedra mais rapidamente".
Este produto adota o
Princípio da Retribuição Espontânea

Há alguns movimentos no sentido de que a informação digital seja disponibilizada gratuitamente. Nós
apoiamos essa iniciativa. Entretanto, achamos também que ela conflita com a necessidade de os
produtores e autores de informação e arte terem renda para sua sustentação mínima, o que a prazo
mais longo pode inclusive reduzir a informação e a arte oferecidas.
Como uma iniciativa no sentido de equilibrar esse quadro, este produto se enquadra no Princípio da
Retribuição Espontânea, que consiste no seguinte:
1) O usuário de informação e arte digitais tem o legítimo direito de usufruir de produtos digitais
gratuitamente, para fins não-comerciais.
2) A seu critério, e dentro de suas possibilidades, o usuário pode retribuir ao detentor dos direitos
autorais o valor monetário que considerar justo em termos dos benefícios que obteve, por meio de
depósito em conta ou outro indicado pelo produtor, tendo o usuário direito a um recibo.
Acreditamos que, desta maneira, todos os interesses podem ser atendidos: os produtores e autores
recebem por seu trabalho se este tiver qualidade, os usuários continuam tendo acesso aos produtos
digitais, quem não pode pagar não paga e quem pode pagar paga somente o quanto pode e o que achar
justo.
Assim, estaremos construindo uma sociedade justa e produtiva não por regras e obrigações, e sim por
um saudável espírito de respeito, liberdade de escolha e troca.
Portanto, esteja à vontade para se beneficiar deste produto. Caso você decida espontaneamente retribuir
por ele, faça seu depósito conforme indicado abaixo. Após, envie um e-mail ao autor, informando nome
completo, endereço e CPF ou CGC, para efeitos de imposto de renda. E, desde já, muito obrigado!
Creditado: Virgilio Vasconcelos Vilela

E-mails: virgiliovv@ieg.com.br; virgiliovv@uol.com.br; webmaster@possibilidades.com.br
CPF: 398.136.146-68 (para copiar e colar, use este: 39813614668)
Opção 1:
Banco: 104 – Caixa Econômica Federal
Agência: 0002-1
Conta: 01181810-3
Opção 2:
Banco: 237 – Bradesco
Agência: 3426-6
Conta: 2703-0
SUMÁRIO
Princípio da Retribuição Espontânea..............................................................................................................................1

APRESENTAÇÃO.......................................................................................................................................3
COMO ESTUDAR NESTA APOSTILA.....................................................................................................5
.0 INTRODUÇÃO À PROGRAMAÇÃO DE COMPUTADORES...................................................6
.0.1. Programas e programação.............................................................................................................................6
.0.2. Conhecendo os programas............................................................................................................................7
.0.3. A linguagem do computador.........................................................................................................................7
.0.4. Linguagens de alto nível...............................................................................................................................8
.0.4.1 Tipos de instruções de alto nível............................................................................................................9
.0.5. Conversão do programa-fonte.....................................................................................................................10
.0.6. Orientação das linguagens de alto nível......................................................................................................11
.0.7. Linguagem Pascal.......................................................................................................................................11
.0.8. Software que você precisa ter ou conhecer.................................................................................................12
.0.9. Fatores de sucesso ......................................................................................................................................13
.0.10. Para você que está começando..................................................................................................................14
.0.11. Atividades suplementares..........................................................................................................................15
.1 PENSANDO A PROGRAMAÇÃO................................................................................................16
.1.1. Meu Primeiro Robô.....................................................................................................................................16
.1.2. Brincando de robô........................................................................................................................................21
.1.3. Algoritmos....................................................................................................................................................25
.1.3.1 Representando problemas e situações..................................................................................................26
.1.4. Atividades suplementares.............................................................................................................................29
.2 O PROCESSO DE PROGRAMAR................................................................................................30
.2.1. Estratégia geral de programação..................................................................................................................30
.2.2. Etapas da programação................................................................................................................................31
.2.3. Especificação do programa.........................................................................................................................31
.2.4. Projeto de programas...................................................................................................................................34
.2.4.1 O que os programas fazem...................................................................................................................34
.2.4.2 Tipos de programas...............................................................................................................................35
.2.4.3 Estrutura de programas.........................................................................................................................37
.2.4.4 Projetando programas...........................................................................................................................39
.2.5. Visão geral de um programa-fonte...............................................................................................................44
.2.6. Teste e qualidade de programas...................................................................................................................45
.2.6.1 O que testar...........................................................................................................................................47
.2.7. Atividades suplementares.............................................................................................................................48
.3 O AMBIENTE TURBO PASCAL..................................................................................................51
.3.1. O Turbo Pascal............................................................................................................................................51
.3.2. Instalando o Turbo Pascal...........................................................................................................................51
.3.3. Acessando o Turbo Pascal..........................................................................................................................52
.3.4. Editando texto.............................................................................................................................................52
.3.5. Alternativas para obter ajuda.......................................................................................................................55
.3.6. O DOS Shell: um pouco de MS-DOS.........................................................................................................56
.4 PRIMEIROS PROGRAMAS.........................................................................................................58
.4.1. Primeiras instruções....................................................................................................................................58
.4.2. Mais de Write..............................................................................................................................................62
.4.3. Turbo Debugger..........................................................................................................................................68
.4.4. Expressões aritméticas................................................................................................................................69
.4.5. Units............................................................................................................................................................73
.4.6. Funções ......................................................................................................................................................77
.4.6.1 Funções matemáticas............................................................................................................................77
.4.6.2 Números aleatórios..............................................................................................................................80
.4.7. Constantes declaradas.................................................................................................................................81
.4.8. Atividades suplementares ............................................................................................................................83
.5 MEMÓRIA E ENTRADA DE DADOS.........................................................................................85
.5.1. Comandos de memória.................................................................................................................................85
.5.2. Tipos de dado...............................................................................................................................................88
.5.2.1 Tipos de dado do Turbo Pascal.............................................................................................................88
.5.3. Mais do tipo de dado char............................................................................................................................95
.5.4. Mais do tipo de dado string..........................................................................................................................97
.5.5. Descobrindo variáveis .................................................................................................................................99
.5.6. Declarando seus próprios tipos de dado.....................................................................................................104
.5.7. Conversões entre tipos de dados................................................................................................................105
.5.8. Atividades suplementares...........................................................................................................................107
.6 ALTERNATIVAS E DECISÃO...................................................................................................110
.6.1. Decisão e expressões lógicas: IF...............................................................................................................110
.6.2. Múltiplas alternativas: CASE.....................................................................................................................117
.6.3. Reconhecendo decisões..............................................................................................................................121
.6.4. Organizando o pensamento: árvores de decisão........................................................................................124
.7 REPETIÇÃO.................................................................................................................................129
.7.1. While..........................................................................................................................................................129
.7.2. Repeat.........................................................................................................................................................132
.7.3. For..............................................................................................................................................................134
.7.4. Casos freqüentes e problemas com comandos de repetição.......................................................................138
.7.5. Programando repetições.............................................................................................................................140
.8 CRIAÇÃO DE INSTRUÇÕES E MODULARIZAÇÃO............................................................153
.8.1. Instruções criadas pelo programador.........................................................................................................153
.8.2. Tipos e características de instruções.........................................................................................................154
.8.3. Declarando procedimentos.........................................................................................................................155
.8.4. Parâmetros por referência..........................................................................................................................161
.8.5. Funções declaradas pelo programador.......................................................................................................165
.8.6. Independência e reusabilidade...................................................................................................................168
.8.7. Roteiro para criar novas instruções...........................................................................................................169
.8.8. Reusabilidade total: units...........................................................................................................................174
.9 LISTAS NUMERADAS: VETORES E MATRIZES..................................................................185
.9.1. Vetores......................................................................................................................................................185
.9.2. Declaração de vetores...............................................................................................................................186
.9.3. Operações com vetores.............................................................................................................................187
.9.4. Processando todo um vetor.......................................................................................................................191
.9.5. Registros....................................................................................................................................................197
.9.6. Matrizes ....................................................................................................................................................200
.9.7. Atividades suplementares..........................................................................................................................204
.10 TRABALHO FINAL...................................................................................................................206
.10.1. Especificação............................................................................................................................................206
.10.2. Projeto......................................................................................................................................................206
.10.3. Programa-fonte.........................................................................................................................................207
.10.4. Teste.........................................................................................................................................................212
.10.5. Idéias para trabalhos.................................................................................................................................212
APÊNDICE A: PERGUNTAS FREQÜENTES ......................................................................................216
APÊNDICE B: PROCEDIMENTOS E FUNÇÕES DO TURBO PASCAL............................................217
APÊNDICE C: FERRAMENTAS DE PENSAMENTO..........................................................................219
APÊNDICE D: TABELA ASCII..............................................................................................................223
BIBLIOGRAFIA.......................................................................................................................................224
ÍNDICE REMISSIVO...............................................................................................................................225
APRESENTAÇÃO
Um bom profissional de informática tipicamente é alguém com disposição para buscar

soluções onde necessário, por sua própria iniciativa. Com base nessa premissa, muitos livros e
cursos deixam a cargo do estudante grande parte da busca, com a melhor intenção de estimular
essa iniciativa. Mas quando começamos algo, ignoramos até o que não sabemos; é comum não
dispormos de pontos de partida, e procurá-los representa um custo às vezes alto demais. Nesse
momento, obter orientação adequada pode fazer a diferença entre prosseguir ou desistir. O
objetivo deste curso é ser uma orientação para quem está iniciando o aprendizado da
programação de computadores. Através de uma linguagem específica, facilitar o treinamento nas
habilidades essenciais necessárias para qualquer linguagem de programação, de forma simples e
prática.
Bons profissionais de informática também sabem que somente dedicação e prática

regulares podem conduzir ao amadurecimento e à competência. Por isto, mais de 400 exercícios
e práticas conduzem o aprendiz a compreender e fixar os novos conhecimentos e também a
conhecer valiosos recursos da linguagem e do ambiente de programação.
A linguagem adotada é o Turbo Pascal 7.0 da Borland, uma versão para DOS. Uma razão
básica para isso é reduzir a quantidade de informações necessárias para que o estudante obtenha
resultados. De qualquer maneira, este não é um livro destinado a esgotar os recursos da
linguagem. O objetivo não é formar especialistas, e sim apoiar a formação básica de
programadores, cuja prioridade maior consiste em desenvolver as habilidades centrais
mencionadas acima. Feito isso, o programador estará em condições de dominar outras
linguagens rapidamente.
Estrutura do curso
Pressupõe-se que o estudante está familiarizado com os conceitos iniciais de

processamento de dados. O material foi desenvolvido para ser trabalhado principalmente no
computador. Após fazer os exercícios e as práticas, o aprendiz deve implementar programas a
partir de especificações, sejam as sugeridas ou outras que descobrir ou elaborar; o mais
importante é estar programando.
Uma das primeiras atividades é colocar o aprendiz em contato com os programas, para
criar uma visão das possibilidades e do que ele vai fazer. Por isto, é imprescindível que ele tenha
os programas de demonstração que acompanham este texto.
De maneira geral os capítulos iniciam com práticas que mostram ao aluno como funciona
algum recurso da linguagem, o que em alguns casos será suficiente. Caso seja necessário, ele
pode recorrer às explicações, embora o mais importante seja o aluno fazer coisas e perceber o
feedback proporcionado pelo computador; isto é considerado mais didático do que exigir que o
aluno saiba descrever como as coisas funcionam. Nesta edição também se procurou fornecer
uma estratégia geral de programação, envolvendo especificação, projeto e implementação, com o
objetivo de suprir o aluno com uma estrutura, independente de linguagens, que organize seu
pensamento na direção dos resultados desejados.
Várias das modificações efetuadas nesta versão refletem conceitos e métodos da
Aprendizagem Dinâmica, de Robert B. Dilts e Todd Epstein, que acredito vão efetivamente
facilitar para os alunos o desenvolvimento das habilidades de programar.
O autor
Engenheiro Eletricista e Mestre em Ciência da Computação pela UFMG. Analista de

Sistemas na Caixa Econômica Federal. Professor de Primeira Linguagem de Programação na
UNEB - União Educacional de Brasília, e na UPIS - União Pioneira de Integração Social,
também de Brasília. Practitioner em PNL.
Agradecimentos
Ao Professor Sílvio Moreira Santana, por me mostrar que os alunos poderiam ir muito
além das minhas expectativas e das deles; ao Professor Vicente P. Teixeira, pelo Apêndice B; ao
Professor Roberto Silveira, então chefe do Departamento de Informática da UNEB, pela
liberdade e apoio proporcionados.
Comentários, críticas e sugestões serão muito bem-vindos e podem ser enviados via
Internet, para virgilio@tba.com.br.
Virgílio Vasconcelos Vilela
Home page: virgiliovv.cjb.net.
Brasília, Janeiro/2000.
COMO ESTUDAR NESTA APOSTILA
Para um melhor aproveitamento da sua dedicação, siga as seguintes orientações:
• Os capítulos consistem de atividades dos seguintes tipos: práticas (a maioria)

devem ser feitas no computador; exercícios devem ser feitos fora do computador e
se destinam preferencialmente para revisões ou testes de aprendizado;
especificações indicam programas a serem feitos; pesquisas indicam atividades
nas quais você deve se virar. Simplesmente vá executando cada atividade na
seqüência em que aparece, pulando o que já estiver muito óbvio para você. A
maioria dos programas das práticas e exemplos estão disponíveis no disquete que
acompanha esta apostila ou na home page do autor.
• Em algumas páginas há caixas com textos explicativos. Uma vez que o objetivo é
formar programadores, não é estritamente necessário ler essas explicações; o
essencial é saber programar, e não saber explicar ou contar como é que se
programa. Programar é implementar causas para efeitos desejados, e se você sabe
o que acontece quando escreve Write(N) em um programa, não se considera aqui
que você deva saber descrever para alguém o que é este comando.
• Ao final de cada capítulo há uma seção de atividades suplementares. Após fazer

as práticas e exercícios, escolha algumas e implemente os programas solicitados.
Quando estiverem "fáceis", é hora de seguir em frente. "Fácil" quer dizer, por
exemplo, que após ter contato com uma especificação e imaginar ou esquematizar
uma tela de saída de um programa, as instruções em Pascal necessárias, ou uma
boa parte delas, vem naturalmente à sua mente, sem grande esforço, e você
eventualmente consulta algum material apenas para se certificar.
• Antes de começar, dê uma boa olhada na apresentação, no sumário, no índice

alfabético e no capítulo 1, apenas para ter uma idéia do conteúdo e familiarizar-se.
Folheie as páginas uma a uma, olhando alguma coisa que lhe chame a atenção.
Não gaste mais que uns 10 ou 15 minutos nesta atividade. Estes poucos minutos
podem lhe economizar horas posteriormente!
Fique atento aos textos neste formato: dicas, alertas e informações

importantes.
6
.0 INTRODUÇÃO À PROGRAMAÇÃO DE
COMPUTADORES
Um computador é uma máquina que, para realizar algo, precisa que alguém lhe indique o que
fazer, de uma forma que ele entenda. Para que você possa fazer isso, é preciso que:
• Conheça o computador e os recursos disponíveis;
• Saiba o que quer que o computador faça;
• Instrua o computador, através de um programa escrito em uma linguagem de programação.
Nesta introdução veremos informações básicas para se aprender uma linguagem de programação
de computadores. Pressupomos aqui que você está familiarizado com os fundamentos do processamento
de dados, incluindo operação do computador e periféricos, sistema operacional e sistema de arquivos.
.0.1. Programas e programação
O hardware do computador, constituído de placas e dispositivos mecânicos e eletrônicos, precisa

do software para lhe dar vida: programas, com finalidades bem determinadas, que façam o que os
usuários querem ou precisam. Há programas para editar um texto, para fazer cálculos, jogos e literalmente
milhares de outras finalidades. Alguns programas maiores, como processadores de texto, planilhas e
navegadores da Internet, são de fato agrupamentos de dezenas de programas relacionados entre si.
Programas são constituídos de instruções e comandos que o processador do computador entende:

faça isso, faça aquilo. Esses comandos devem estar representados em uma linguagem. Você talvez não
esteja ciente de que está familiarizado com vários tipos de linguagem. Além do Português, há linguagens
para inúmeras finalidades: sinais, faixas e placas de trânsito, gestos com a mão e com a cabeça, o Braille e
a linguagem dos surdos-mudos... Até para falar com bebês temos formas específicas! Também há formas
de linguagem mais simples para nos comunicarmos com máquinas, como a televisão, o videocassete, a
calculadora. Ninguém "chama" verbalmente um elevador, nem "diz" à TV qual canal sintonizar; se você
não fizer algo que os aparelhos entendam, não vai conseguir o que quer. Assim é o computador: você
deve comandá-lo de uma forma que ele entenda.
Para que algo aconteça no computador, não basta um programa; os comandos

do programa devem ser executados. Programas de computador são como filmes: uma
coisa é a película em um rolo, contendo uma seqüência de imagens. Outra coisa é
colocar o filme em um projetor e assisti-lo na telona. Os programas ficam guardados
em arquivos no disco rígido ou CD, até que seja comandada sua execução. São então
carregados pelo sistema operacional para a memória e só então acontece (exatamente)
o que foi programado, e você pode perceber o que o programa faz.
Uma diferença entre máquinas em geral e o computador é que este pode fazer muito mais coisas,
portanto precisa de uma variedade maior de comandos. E outra diferença fundamental: o computador
pode armazenar os comandos, agrupados em programas, para execução posterior.
0 - INTRODUÇÃO À PROGRAMAÇÃO DE COMPUTADORES 7
Programar um computador é, portanto, produzir comandos agrupados em programas, em uma

linguagem que o computador entenda e que, quando executados, façam o computador produzir algum
resultado desejado. Um bom programador é treinado em algumas habilidades, sendo o nosso objetivo
desenvolver na prática essas habilidades, para isso usando uma linguagem de programação de
computadores chamada Pascal.
.0.2. Conhecendo os programas
Quando viajamos, nossa principal referência é o destino desejado, que nos guia nas decisões de
para onde virar. Nesta seção você vai conhecer o nosso destino: programas prontos. Há uma infinidade
deles; aqui veremos aqueles dentro dos nossos propósitos.
Para as atividades desta seção, você vai precisar dos programas que são parte do curso. Todos
podem ser executados a partir do programa principal, chamado "demoap.exe". Se você não possui o
disquete de programas, obtenha-os na Internet, na página indicada no final da apresentação da apostila. Se
os programas foram fornecidos em um único arquivo compactado, descompacte-os em uma única pasta.
Para que os programas de demonstração possam ser executados, eles precisam constar do
cadastro do programa (arquivo "cadprog.dat"). Outros programas podem ser cadastrados a partir de uma
opção no menu principal.
Os programas que você vai ver foram feitos por ex-alunos, pelo próprio autor ou obtidos na
Internet. Divirta-se!
Prática 0.1 – Brincando

Execute o programa de demonstração. Escolha a opção "Programas por categoria", depois escolha a
categoria desejada (jogos, desenho, sons e as demais) e escolha alguns. Não há nenhuma regra, escolha os
que lhe parecerem mais interessantes.
.0.3. A linguagem do computador
A atividade básica de um computador consiste em executar instruções, através de um

microprocessador ou simplesmente processador, às vezes também chamado de CPU (Central Processing
Unit). O processador, em última análise, recebe instruções na forma de impulsos elétricos: em um
determinado circuito, pode estar ou não fluindo corrente. Representamos cada impulso por 1 ou 0,
conforme passe corrente ou não. Esta é a menor unidade de informação que pode ser representada em um
computador, e é chamada bit. A CPU recebe instruções e dados na forma de bits agrupados de 8 em 8;
cada conjunto de 8 bits é chamado byte. De uma forma simplificada, um byte, ou seja, um conjunto de 8
impulsos elétricos (ou sua ausência), constitui uma instrução ou um dado (na verdade, uma instrução
pode ocupar mais de um byte). Representaremos essa unidade de informação pelo número correspondente
no sistema decimal. Dessa forma, ao byte 00000001 associamos o número 1, ao byte 00000011
associamos o número 3, ao 00000100 o número 4 e assim por diante. Um byte pode armazenar, portanto,
um número de 0 a 255 (11111111).
A memória RAM, ou simplesmente memória, de um computador é constituída de uma seqüência

de milhares ou milhões de bytes, cada um identificado por um número que constitui o seu endereço
(figura). O processador tem a capacidade de buscar o conteúdo da memória e executar instruções ali
armazenadas. A CPU também contém algumas unidades de memória, chamadas registradores,
identificados por nomes como AX, CS e IP, que também armazenam números e servem a várias funções.
8 APRENDENDO A PROGRAMAR NA PRÁTICA VIRGÍLIO V. VILELA
1 2 3 4 5 6 ...
56 23 0 247 154 87 ...
Esquema simplificado da memória RAM: endereços, bytes e respectivos valores.
Os números armazenados na memória podem representar dados ou instruções. Quando

representando instruções, tem significados específicos para a CPU. Por exemplo, a CPU em geral recebe
comandos do tipo (mas não na forma):
“Armazene 9 no registrador DS”
“Armazene 204 no endereço de memória 1.234.244”
“Some 5 ao conteúdo do registrador AL”
“Se a última instrução deu resultado 0, passe a executar as instruções a partir do
endereço de memória 457.552”
PUSH DS
CLD Esse tipo de linguagem é chamado linguagem de máquina ou
MOV CX,0FFFFH
assembly (veja ao lado um trecho de programa). As instruções são
XOR AL,AL
NOT CX executadas na seqüência em que estiverem na memória, a menos que o
LES DI,Dest fluxo de execução seja redirecionado por alguma instrução apropriada.
REP MOVSB Nesta linguagem, mesmo para mostrar algo na tela é necessário colocar
MOV AX,DI números em certos endereços de memória, reservados para isso. Não
MOV DX,ES
DEC AX há indicação explícita do tipo número da linha ou da coluna da tela;
POP DS devemos calcular esses dados.
.0.4. Linguagens de alto nível
Escrever programas de computador em linguagem de máquina, apesar de os programas

produzidos serem extremamente rápidos, pode ser muito difícil, trabalhoso e de alto custo, além de exigir
conhecimentos profundos sobre o computador.
Para não termos que programá-lo nessa linguagem difícil, foram desenvolvidas as linguagens de
alto nível. Estas nos permitem descrever o que queremos que o computador faça utilizando instruções
mais próximas da nossa linguagem. Além de facilitar a descrição dos processos a serem executados, as
linguagens de alto nível simplificam a utilização da memória do computador, diminuindo a quantidade de
detalhes com os quais deve ocupar-se o programador. Assim, ao invés de lidarmos com bits, bytes,
endereços de memória e uma infinidade de outros detalhes, podemos pensar em "limpar a tela", "imprimir
uma linha de texto", somar e subtrair variáveis como na matemática e tomar uma decisão na forma "se...
então".
Veja um exemplo específico: as instruções abaixo, na linguagem Pascal, determinam que a tela
seja limpa e uma soma seja efetuada, e o resultado desta mostrado na tela:
ClrScr;
Write(513 + 450 + 1200);
Uma linguagem de programação de alto nível possui várias características em comum com a
nossa linguagem. Elas possuem um alfabeto (letras, números e outros símbolos) e palavras. Há palavras
predefinidas na linguagem, mas também podemos formar as nossas próprias. Frases podem ser
construídas com as palavras, respeitando-se certas regras. O conjunto de regras de construção de palavras
e frases numa linguagem de alto nível, assim como nas linguagens comuns, chama-se sintaxe.
.0.4.1 Tipos de instruções de alto nível
O que você pode fazer dentro de um programa, utilizando uma linguagem de alto nível? Vamos
ver algumas analogias com outras máquinas.
Um televisor possui vários recursos: a tela, o alto-falante, o controle remoto, opções de

configuração. Quando você aperta ou gira um botão de controle, está de certa forma instruindo o televisor
a fazer algo; é uma forma rudimentar de linguagem. Em qualquer caso, você está
limitado a atuar sobre os recursos do seu televisor; não há meios de instruí-lo a
gravar algo numa fita de vídeo. Da mesma forma, numa linguagem de
programação você não vai encontrar (a princípio) instruções para regular
contraste ou temperatura. Uma categoria de instruções que você pode esperar
que existam são aquelas que vão lhe permitir interagir com os recursos
disponíveis: teclado e mouse (entrada), tela e impressora (saída), discos
(entrada e saída), memória. Assim, há instruções para se ler algo do teclado e
mostrar algo na tela. Sendo o disco rígido estruturado em pastas (diretórios) e
arquivos, há instruções para se ler e gravar arquivos no disco rígido, e para se saber seu
conteúdo. Também há instruções que declaram que você quer usar a memória, e instruções para
armazenar e consultar dados nela armazenados.
Para poder executar uma gravação programada, seu videocassete precisa tomar
pelo menos duas decisões: quando iniciá-la, e quando interrompê-la. Assim é num
programa: em várias situações será necessário fazer verificações e tomar decisões de
quando executar ou não um conjunto de instruções, ou executar um ou outro conjunto. Por
exemplo, um programa que lê uma nota que um aluno tirou em uma disciplina e deve
informar se ele foi aprovado ou não. Ou o programa informa que o aluno passou ou que foi
reprovado, mas nunca as duas coisas. Portanto, numa linguagem de alto nível, também
você pode esperar que existam instruções para tomada de decisões.
Para explorar a enorme capacidade de processamento de um computador, que tal deixarmos para
ele fazer coisas que exigem a repetição de um procedimento uma certa quantidade de vezes, sejam duas
ou milhões de vezes? Você também encontrará numa linguagem instruções para programar repetição
condicional de um grupo de instruções. Suponha que você quer escrever um programa que escreva seu
nome em cada linha da tela. Ao invés de escrever 25 instruções, uma para cada linha, você pode usar uma
instrução para repetir 25 vezes a instrução que mostra seu nome na tela. Em outros casos você terá um
padrão a ser seguido, como no caso do cálculo da média aritmética: lê o número, calcula a soma parcial,
incrementa um contador, lê outro número, calcula a soma parcial, incrementa um contador, e assim por
diante; no final da leitura, divide a soma pelo contador. Uma vez identificado o padrão, você escreve
apenas uma vez as instruções que se repetem e inclui um comando que controle a repetição.
Para facilitar a vida do programador, as linguagens de alto nível também contêm vários outros
tipos de instruções: todos contêm operações matemáticas básicas (soma, subtração, multiplicação e
divisão) e também funções matemáticas como seno, co-seno, logaritmo e exponencial. Algumas
linguagens disponibilizam instruções gráficas, para desenhar retas, círculos e outros objetos, colorir
objetos e muitas outras.
E o melhor dos mundos: você também poderá criar suas próprias instruções e funções, que
depois de testadas e corretas, poderá usar como se fizessem parte do repertório da linguagem. Por
exemplo, você poderá escrever uma instrução chamada RepeteMeuNome, que mostra seu nome na tela 25
vezes. Uma vez testada, correta e gravada, basta inserir o nome da instrução na posição apropriada do
programa ("chamar" a instrução) para mostrar seu nome 25 vezes. E se quiser mostrar seu nome mais 25
vezes, basta "chamar" de novo a instrução. Para melhorar ainda mais, você pode criar a instrução de
forma que a quantidade de repetições seja definida somente quando o programa for executado.
Exercício 0.2 - Revisão

Complete os espaços:
a) O processador executa instruções em linguagem de ________________.
b) As instruções executadas pelo processador devem estar e são buscadas na
_______________.
c) As instruções em linguagem de máquina são agrupadas em _____________, cada um
com uma finalidade determinada.
d) Para ser executado, um programa deve estar na ______________ do computador, para
onde é carregado pelo _______________ ___________________.
Exercício 0.3 – Vantagens e desvantagens

Assinale com V as vantagens e com D as desvantagens de se elaborar programas em linguagem de
máquina:
( ) Mais trabalhoso
( ) Maior rapidez de execução
( ) Permite maior controle do computador
( ) Exige mais conhecimentos sobre o hardware do computador
Exercício 0.4 – Categorias de instruções

Descreva as categorias de instruções de uma linguagem de programação de alto nível. Para cada
categoria, forneça dois exemplos de coisas que podem ser feitas.
.0.5. Conversão do programa-fonte
Como o computador não entende as instruções de um programa-fonte, para que este possa ser
executado, ele precisa ser convertido para a linguagem que o computador reconhece, a linguagem de
máquina. Uma instrução em uma linguagem de alto nível pode corresponder a centenas ou até milhares
de instruções em linguagem de máquina. A conversão é feita por programas apropriados, e pode ser feito
antes ou durante a execução do programa.
Quando o programa-fonte é todo convertido em linguagem de máquina antes da execução, esse

processo é chamado de compilação, e os programas que o fazem são chamados compiladores. O
programa resultante é chamado programa-objeto ou código-objeto, que contém instruções em linguagem
de máquina mas ainda não pode ser executado; para que isso ocorra, é necessária outra etapa chamada
"linkedição" (jargão da área) ou ligação, efetuada também por um programa apropriado chamado
"linkeditor" ou ligador. Na linkedição, são juntados ao código-objeto do programa outros códigos-objeto
necessários à sua execução. Após esta etapa, a conversão está completa e produz finalmente um
programa executável (figura).
e d i t oP r R O G R c A o M m Ap i l a d P o R r O G R A l i Mn k A e d i t oP r R O G R A M A
F O N T E O B J E T O E X E C U T Á V E L
t e x t o lin g u a g e m d e lin g u a g e m d e
m á q u in a m á q u in a
Quando a conversão é feita durante a execução, o processo é chamado de interpretação, e o

programa conversor, interpretador. Neste caso, o interpretador permanece na memória, junto com o
programa-fonte, e converte cada instrução e a executa, antes de converter a próxima. É evidente, portanto,
que a execução de um programa interpretado é mais lenta que a de um compilado.
Note que não é a linguagem em si que é compilada e interpretada. Essa característica depende da
disponibilidade de um compilador ou um interpretador; pode haver ambos para uma linguagem, ou até
nenhum.
.0.6. Orientação das linguagens de alto nível
As instruções disponíveis em uma linguagem de alto nível podem não ser apropriadas para uma
determinada aplicação. Programas científicos têm muitas diferenças em relação a programas comerciais,
que também podem diferir bastante de programas voltados para tratar imagens ou de inteligência
artificial. Assim, foram desenvolvidas linguagens para áreas específicas. A primeira linguagem de alto
nível criada, o compilador FORTRAN, é direcionada para aplicações científicas. A linguagem COBOL,
também compilada, é orientada para aplicações comerciais. O interpretador BASIC é voltado para
iniciantes. A linguagem PL/I foi criada pela IBM para ser a união de várias linguagens. Há também várias
linguagens que facilitam o tratamento de grandes quantidades de dados, como SQL (Structured Query
Language).
Uma distinção importante a ser feita é que uma coisa é a linguagem, outra coisa é a
implementação comercial desta linguagem. Há uma definição padrão para a linguagem Pascal, por
exemplo, e há compiladores comerciais desta linguagem, como o Turbo Pascal. Normalmente os
ambientes de programação comerciais incluem instruções extras, conhecidas como extensões da
linguagem, o que os torna menos compatíveis com os outros. Os melhores compiladores comerciais
incluem outras facilidades, como ajuda on-line, exemplos e vários outros recursos.
.0.7. Linguagem Pascal
O PASCAL (não fale "pascoal"!) foi desenvolvido por Niklaus Wirth para ser a primeira
linguagem de programação a ser aprendida. É bem fácil de ensinar e aprender, e sua estrutura é um pouco
mais rígida do que a de outras linguagens, visando estimular maior organização e disciplina no
programador. Isso se justifica devido ao fato de que as linguagens, ao mesmo tempo em que permitem a
elaboração de grandes soluções, possibilitam que se cometa grandes erros, principalmente em programas
maiores. Um programa pode estar sintaticamente correto e no entanto conter erros como seqüência
inadequada das instruções, valores incorretos ou também a sua execução pode nunca terminar
normalmente, porque as condições de terminação nunca são atingidas (esses erros são chamados “bugs”
ou erros de lógica).
Para a construção de programas grandes e com estrutura muitas vezes complexa demais para
nossos limites atuais, foram (e ainda continuam sendo) criadas várias técnicas e metodologias de
desenvolvimento e estruturação de programas mais fáceis de serem testados, alterados ou corrigidos. Mas
não se iluda: qualquer que seja a linguagem ou a metodologia, é possível produzir programas
desorganizados, incompreensíveis e repletos de erros ou que não fazem o que deveriam fazer. A
qualidade final dos produtos dependerá predominantemente do programador.

Assinale V para as afirmações verdadeiras e F para as falsas:
( ) Sintaxe é o nome dado às regras de construção de frases em uma linguagem de
programação.
( ) Um programa-fonte pode ser executado diretamente, como estiver.
( ) Um programa pode ser compilado mesmo que tenha pequenos erros de sintaxe.
( ) Um programa pode ser compilado, interpretado ou ambos.
( ) Um programa pode conter erros, mesmo estando sintaticamente correto.
.0.8. Software que você precisa ter ou conhecer
Alguns programas são necessários às atividades de um programador:
Sistema operacional - Como programador, você precisa ter um mínimo de informações sobre o
sistema ou ambiente operacional em vai trabalhar, como por exemplo:
• Como executar programas
• Os nomes que você pode dar aos arquivos
• Como organizar seus arquivos em pastas ou subdiretórios
• Como listar, excluir, renomear e copiar arquivos
Se o computador em que você trabalha está conectado a uma rede, você vai precisar de um nome
registrado, associado a uma senha, para poder acessar arquivos e programas da rede.
Editor de textos - Um programa Pascal é um texto simples, sem caracteres de controle do tipo
negrito, tamanho de fonte, paginação, etc. Você vai precisar de um editor para digitar seu programa no
computador. Editores que produzem tais textos são o Edit, que vem com o MS-DOS, o Bloco de Notas
(NotePad), que vem com o Windows, e vários outros. Textos formatados pelo Word, WordPad ou Carta
Certa não servem. Os compiladores comerciais normalmente trazem um editor; usá-los será normalmente
mais prático. O Turbo Pascal traz um ótimo editor, e você não precisará se preocupar com isto, exceto
talvez para imprimir os programas.
Compilador - Uma vez que você digitou o texto do programa, precisará convertê-lo para
linguagem de máquina. Para isso você precisa de um compilador. Como compiladores comerciais da
linguagem Pascal temos por exemplo as várias versões do Turbo Pascal, da Borland. Há versões para
DOS (até 7.0) e para Windows. Há vários outros, como o Free Pascal, compatível com o Turbo Pascal e
que você pode transferir via Internet gratuitamente.
Escolhemos o Turbo Pascal 7.0 por vários motivos: facilidade de instalação, ótima curva de
aprendizagem, por ser a base do Delphi (um dos ambientes de programação profissional mais usados
atualmente em micros) e ainda o fato de ser o "queridinho" da Internet: há muitos sites especializados
nele, e quase nada dos outros. O Turbo Pascal 7.0 é vendido até hoje, e não o acho exatamente barato, o
que é uma medida do interesse geral por ele.
.0.9. Fatores de sucesso
Um programador pode atuar em várias áreas. Como funcionário de uma empresa, normalmente
trabalha em equipe, recebendo especificações dos analistas de sistemas. Pode ter uma empresa, com
outros programadores ou não, e através dela comercializar seus programas. Outra possibilidade é
distribuir seus programas via Internet, na forma de shareware, modalidade de distribuição na qual o
usuário tem acesso ao programa para avaliação antes da decisão de compra. Há muitas pessoas que
programam por hobby, por gostarem, e vários deles acabam se profissionalizando, inclusive porque são
muitas as oportunidades para quem está disposto a fazer um bom trabalho.
Para que isso se materialize, são essenciais alguns recursos materiais e, além destes, há recursos
pessoais que, quanto mais desenvolvidos, mais enriquecem a competência do programador:
Computador pessoal - É fundamental que você tenha o seu próprio computador, para que se
dedique mais e melhor, para que pratique quando quiser e puder e mais um monte de razões. Para
começar, não é preciso ter um Pentium; é possível rodar o Turbo Pascal, nosso compilador, até em um
processador 286 e sistema operacional DOS 3.0. Por tudo isto, faça o que for preciso para ter o seu
próprio microcomputador ou para ter acesso a um.
Datilografia ou digitação - Se você é um (mau) “catilógrafo”, corra para fazer um curso, a não
ser que queira sofrer. Sua produtividade será bastante prejudicada.
Inglês - A menos que você tenha um compilador com ajuda ou manual em Português, procure
desenvolver pelo menos alguma habilidade de ler inglês. É essencial, por exemplo, para poder usufruir da
ajuda sensível ao contexto dos compiladores: você aperta uma tecla e aparecem informações sobre a
palavra onde está o cursor da tela. Não saber inglês é uma forma de analfabetismo da área de informática!
Tempo e dedicação - São os principais recursos que você pode investir, e constituem fatores
críticos de sucesso. Sem eles, nada será possível.
Limites - Ter uma consciência clara de que você tem limites permite que eles sejam respeitados e
também que possa ir além deles. Em um determinado momento, há limites para o que você sabe do
sistema operacional, da linguagem, do compilador. Há limites também para sua capacidade de organizar
mentalmente informações em maior quantidade. Conhecer seus limites pode evitar aborrecimentos, no
sentido de que você saberá exatamente quando precisa de melhores informações ou métodos e que está na
hora de buscá-los.
"Se algo está difícil, eis aí uma indicação de algo que você não sabe"
Richard Bandler & John Grinder
Atitude - O direcionamento interior que você assumir (suas

crenças e convicções), principalmente em momentos críticos, pode
fazer muita diferença. Todo profissional, de qualquer grau de
maturidade, em algum momento fica diante de algo que não sabe, e deve decidir o
que fazer. Persistir, desistir? Tentar um pouco mais? Muitos desistem dois minutos
antes de achar a solução ou um ponto de partida para ela. O ponto chave aqui é
perceber que cada momento desses é uma oportunidade de melhoria.
Experiência - Aprender a programar computadores é um processo que tem um início, mas não
um fim, e se há limites para o que você sabe, não há limites para o que você pode aprender. Você vai
aprender de livros, exemplos, ao ver outros fazendo e outras formas. Mas a meu ver, a experiência (e o
que você fizer com ela), incluindo os erros aproveitados e os desafios vencidos, será seu melhor professor
e o que lhe proporcionará os aprendizados mais consistentes. E o que você pode aprender depende pura e
simplesmente de sua dedicação e de sua calma em progredir passo a passo.
"A inteligência não substitui a falta de informação"
Exercício 0.6 – Planejando o dia

Faça um levantamento das suas atividades semanais, juntamente com o tempo médio necessário para cada
uma. Após, identifique o tempo de que vai usar para o curso que está fazendo.
.0.10. Para você que está começando
Neste capítulo você obteve algumas noções básicas sobre o que é programar computadores e do
que você precisa para iniciar. Já sabe que tudo que é feito com e através do computador só é possível
porque há pessoas elaborando os programas necessários. E cada um desses programas foi produzido por
um programador ou uma equipe de programadores. Nos programas maiores podem estar envolvidos
vários tipos de pessoas: programadores visuais, consultores e até compositores para as trilhas sonoras.
Mas o programador é o único com presença garantida em qualquer projeto de programação.
Mas na vida de todo programador houve um tempo em que ele não sabia nada; teve que começar,
e do jeito mais simples. Primeiro aprendendo algo sobre como o computador funciona, depois aprendendo
as primeiras instruções. Quase sempre o primeiro programa mostra uma frase na tela ou efetua uma
operação aritmética básica. Após dominar os princípios da coisa, ele aprende novas instruções, como
fazer um programa tomar decisões e controlar repetições, depois cria as suas próprias instruções. Conhece
uma nova linguagem, descobre novas formas de programar, aplica suas próprias idéias, ultrapassa
obstáculos e aproveita várias oportunidades, sucessivamente atingindo graus crescentes de maturidade.
Provavelmente (e isto é bom) você tem vários pontos de interrogação: É difícil? Será que eu
consigo? É legal? Dá pra ganhar dinheiro programando? Como é que é esse Pascal? Tem que dedicar
muito pra ficar bom? E por aí vai.
Vou resumir em algumas frases minha opinião:

• Programar é tão fácil ou tão difícil quanto aprender a falar, andar, tocar um instrumento ou
outra habilidade. Após um começo algo obscuro, estabelece-se uma base de conhecimentos e
habilidades sobre a qual se cresce.
• Programar pode ser muito prazeroso, embora tenha momentos de desafio que podem diminuir
o prazer de quem não os aprecia. É uma atividade muito absorvente: se você quiser fugir de
alguma coisa, vá programar!
• Há muitas (mesmo) oportunidades para programadores ganharem dinheiro, seja como
autônomo, como empresário ou como empregado. Atuar como programador também tem sido
a porta para muitos profissionais de outros ramos de informática, e muito deles são melhores
devido à experiência como programador. O salário inicial é em geral superior a muitas outras
categorias, e a competência profissional é valorizada. Já vi casos de programadores que em
dois anos passaram a analistas. É útil para isso ter consciência de que um bom profissional
não é constituído apenas por conhecimentos e habilidades técnicas. Neste curso você
encontrará também temas não diretamente técnicos que podem ser, em certos momentos, até
mais importantes.
• Obstáculos fazem parte da vida de quem aprende; quem está aprendendo nem sempre está na
"zona de conforto", pelo contrário, está avançando sobre limites. Certos fatos, chamados em
outros contextos de "problemas", para profissionais de informática são na verdade
oportunidades de melhoria, são feedback; bons profissionais aprendem como fazer e também
como não fazer.
O que vai acontecer depende basicamente de quanto você estiver disposto a investir, sabendo que
às vezes semeamos para colher os frutos algum tempo depois, e que cada minuto dedicado com certeza
dará seus frutos. Siga a receita do sucesso: estabeleça onde quer chegar (em etapas, se necessário) e tome
as medidas necessárias para chegar lá, modificando suas atitudes ou estratégias quando verificar que o
que está fazendo não está funcionando.
.0.11. Atividades suplementares

Identifique os conceitos e ache-os no diagrama, da esquerda para a direita, de cima para baixo e vice-
versa:
a) Conjunto de regras de construção de palavras e frases em uma linguagem de programação de alto
nível
b) A melhor professora
c) Tipo de instrução que permite executar várias vezes um conjunto de instruções
d) Garante o emprego do programador
e) Juntamente com a dedicação, constitui um recurso essencial do programador
f) Componente do hardware usado para armazenar dados e instruções
g) Tipo de instrução que permite executar um ou outro conjunto de instruções
h) Processo de tradução de um programa-fonte para linguagem de máquina
C P I A X A D E C I S Ã O
O S S I N T A X E V N O I
M M A R T E O P M N A R N
P O X Ó Y S E E I E F W T
I T E M E T E R R O U A E
L I R E P E T I Ç Ã O R R
A V E M L A I Ê O O H N F
Ç A Ç A H S K N C P L O A
Ã Ç O I N G O C I M A T C
O Ã Ç A C I F I C E P S E
S O L E I F X A A T O J P
Entrevista 0.8 – Experiência de outros

Entreviste pelo menos dois alunos de turmas mais adiantadas e pergunte: qual foi a importância desta
disciplina para disciplinas posteriores? Se pudesse voltar atrás, como procuraria conduzir a disciplina? Se
o colega já programou em duas ou mais linguagens, pergunte-lhe se o que aprende em uma linguagem
pode ser aplicado em outras. Ele gostou ou gosta de programar?
16
.1 PENSANDO A PROGRAMAÇÃO
Você sabe que cada disciplina possui formas peculiares de pensar: a forma de resolver problemas
de Matemática não é a mesma da Biologia. A forma de pensar da Física inclui a da Matemática e algumas
outras. De forma análoga, a programação de computadores requer raciocínios apropriados, chamados em
geral de "lógica de programação". Essa lógica é uma combinação de elementos simples, que todos
usamos no dia a dia mas nem sempre estamos cientes: executar uma seqüência de ações, tomar decisões
diante de alternativas e controlar ações repetidas.
Uma vez que você já conhece essas ações, este capítulo vai prepará-lo para lidar com esses tipos
de ações, na forma como são usados na programação.
.1.1. Meu Primeiro Robô
PARTE I: UAU!
Ano: 2010. Cenário: sua casa. No seu aniversário, você realizou um sonho: ganhou um magnífico
robô tipo humano, modelo sem-sexo. Não é o mais moderno, é verdade, mas sem dúvida é sensacional.
E agora você deve aprender a operá-lo, e para isso dispõe tão-somente do manual de instruções (e
quando tiver grana, talvez você faça o curso da loja...).
Você então faz o primeiro teste: virando-se para o robô estático, você diz:
− Ligue a televisão no canal 10. O robô fica imóvel. Você insiste:
− Robô, ligue a televisão! E ele responde! Numa voz masculina, algo metálica, mas não
desagradável, ele diz:
− Instrução não compreendida.
− Pô, robô, como é que você funciona?
Você então se resigna e pega o manual. Lá, descobre que todas as comunicações com o robô
devem iniciar-se com a palavra “ROBÔ”, e que ele entende a linguagem, mas não como falamos
normalmente. Seus comandos devem ser instruções num formato específico: algumas regras devem ser
obedecidas. Além disso, o robô tem um repertório limitado de instruções: só é capaz de fazer o que já tem
programado.
Mais resignado (ou resignada) ainda, você pacientemente dá uma olhada geral no manual,
enquanto procura pelas instruções que o robô entende. Encontra então uma seção de aprendizagem rápida,
e descobre que para fazer o robô falar algo, deve dizer-lhe:
Fale(Frase, Entonação).
Mas o manual alerta para dizer o Fale, não pronunciar os parênteses, substituir Frase pelo que
você quer que ele fale, e substituir Entonação por uma das palavras: Normal, Enfático, Sussurrante,
Nervoso, Autoritário e Staccato. Você pode omitir a entonação, e o robô assumirá Normal. Testando,
você diz ao robô:
− Fale Você é muitcho legal, Staccato.
2 - PENSANDO A PROGRAMAÇÃO 17
O robô continua em silêncio. Aí você se lembra de como deve começar:

− Robô, Fale Você é muitcho legal, Staccato.
− Vo-cê-é-mui-tcho-le-gal. O som da resposta ressoa maravilhosamente em seus ouvidos e você
fica mais animado.
Depois de brincar um pouco com as entonações do robô, e fuçando no manual, descobre uma
seção chamada “Serviços Domésticos”, e nela encontra as instruções
Ligar(Aparelho)
Desligar(Aparelho).
Os aparelhos que o robô reconhece podem ser Lâmpada, Ventilador, Rádio, Televisão ... A-HÁ!
− Robô, Ligar televisão.
Você vê o robô mover a cabeça até parar na direção da televisão, andar até ela, estender a mão e
pressionar com um dedo o botão de ON/OFF, retornando à sua posição de imobilidade.
− Robô, desligar televisão.
O robô faz os mesmos movimentos, desta vez sem andar. Progressos!
De novo o manual. Na mesma seção, você acha a instrução
Sintonizar (Aparelho, Canal)
onde Aparelho pode ser Televisão ou Rádio e canal é um número de 1 a 500 se Aparelho for Televisão e
é uma freqüência se Aparelho for Rádio. Lê de novo, para se certificar de que tinha entendido e, já usando
a experiência adquirida, comanda rapidamente ao robô:
− Robô, Ligar televisão. Robô, sintonizar televisão, 10.
O robô executa os comandos exatamente como você queria.
− Robô, você sintoniza qualquer televisão?
- É, você não é nenhum Exterminador do Futuro. Dá um leve tapa no ombro do robô, sem
qualquer reação.
Evoluindo
Após alguns dias explorando o robô, e achando-o muito limitado, decide pedir uma grana
emprestada para comprar um acessório opcional: a ULP - Unidade Lógica Programável. Um folheto que
vira dizia que com a ULP o robô poderia aprender a reconhecer novos objetos e novas instruções.
Já com a ULP que você mesmo instalou (lendo as instruções, é claro), você testa o
reconhecimento de objetos. Você já sabe que, para ensiná-lo, deve mostrar o objeto e dizer o nome dele.
E se quiser que reconheça vários objetos distintos com o mesmo nome, deve fazer o mesmo com os
demais objetos.
Você pega logo a caixa de Lego do seu irmãozinho, e mostra ao robô várias peças, dizendo
“Lego” a cada uma. Após ouvir cada nome, ele diz “Registrado”. Você mostra por fim a caixa, dizendo:
− Caixa do Lego.
− Registrado.
Virando o conteúdo da caixa, diz:
− Robô, guarde os legos na caixa do lego.
- Favor reformular a instrução.
Impaciente, revira o manual e descobre que o robô reconhece a instrução Coloque(Local). Ao
ouvi-la, ele soltará um ou mais objetos que estejam em suas mãos, no Local especificado. E uma das
maneiras de por objetos em sua mão é através da instrução Pegue(Objeto). Pensando “primeiro tem que
pegar, para depois colocar”, você diz:
− Robô, Pegue Lego. Robô, Coloque Caixa do Lego.
O robô imediatamente se abaixa, pega uma peça e a coloca na caixa.
− Robô, é pra você guardar todas!
− Favor reformular a instrução.
Angustiado com a possibilidade de ter que dizer ao robô 200 vezes as instruções ou, pior, você
mesmo guardar as peças, de repente se lembra de um amigo que já teve um robô com ULP (e agora tem
um modelo com-sexo!). Liga pra ele e fica sabendo que vai ter que programar o robô, criando uma nova
instrução que o ensine a guardar todos os legos. O amigo disse que você poderia programar 200 vezes o
Pegue e Coloque, mas seria mais simples usando uma instrução de repetição.
Conferindo o que seu amigo disse, você lê no manual que, para programar o robô você deve
descrever, na linguagem dele, o padrão de comportamento que ele deve seguir. As instruções que
descrevem o padrão são armazenadas na memória do robô sob um nome que você mesmo atribui, depois
da palavra algoritmo, que é o nome dos programas do robô. Após a programação, basta dizer ao robô o
nome dado para que as instruções sejam executadas. Mas atenção, alerta o manual: se um algoritmo tiver
comando de repetição e o robô não achar uma condição de terminação, ele o executará até que seja
desligado ou acabe a bateria.
Sem entender muito bem o que o manual queria dizer com o alerta, mas muito interessado, você
tenta um pequeno programa. Após verificar como fazer a programação, diz ao robô:
− Robô, programar.
− Registrado.
− Algoritmo LigarTV. Ligue(Televisão). Sintonize(Televisão, 10). Fim algoritmo. O robô, sem se
mexer:
− Registrado.
− Robô, LigarTV.
Ele imediatamente se dirige à televisão e a liga, sintonizando no canal 10. “Bom, bom”.
Pensando agora no problema de catar o lego, você procura a seção do manual que trata de
programação de repetições, conforme indicado pelo seu amigo. Chamam sua atenção as instruções:
REPITA REPITA N VEZES

<instrução 1> <instrução 1>
<instrução 2> <instrução 2>
... ...
ATÉ QUE <condição> FIM-REPITA
A primeira é para repetir instruções um número indefinido de vezes; o robô só pára quando uma
condição ocorrer. A segunda automaticamente repete N vezes as instruções que estiverem depois do
REPITA e antes do FIM-REPITA, ou seja, uma quantidade de vezes previamente definida. Você escolhe
a segunda instrução, que lhe pareceu mais fácil de entender: é só conhecer as instruções a serem repetidas
e substituir o N pela quantidade de repetições.
Antes de programar o robô, e já mais metódico, você anota num papel o que dirá a ele, já com as
instruções que iniciam e terminam uma programação e separando as instruções que serão repetidas:
ALGORITMO GuardeLego
REPITA 100 VEZES
Pegue(Lego)
Coloque(Caixa do Lego)
FIM-REPITA
FIM-ALGORITMO
Você repassa mentalmente as instruções e acha que está tudo na seqüência correta. Já acostumado
com aquele jeito estranho de conversar, comanda o robô, enquanto lê suas anotações:
− Registrado.
− Algoritmo Guarde Lego. Repita 100 vezes. Pegue Lego. Coloque Caixa do Lego. Fim Repita.
Fim algoritmo.
− Registrado.
- Robô, guarde lego.
Sucesso! O robô, com seu jeito mecânico, pega e guarda as peças, uma a uma, até que para.
Ainda restam peças no chão.
Você começa a pensar em como poderia utilizar a instrução REPITA..ATÉ para mandar o robô
guardar as peças até não restar nenhuma. Mas outra idéia vem, você faz uma expressão marota e diz ao
robô:
− Registrado.
− Algoritmo Chateie Irmã. Execute 1000 vezes. Fale você não deve mexer no robô, Staccato. Fale
você não deve mexer no robô, Enfático. Fim Execute. Fim algoritmo.
− Registrado.
Parte II: Tomando decisões
Agora você quer descobrir como fazer o robô catar o lego até não restar nenhuma peça. Já
familiarizado com o manual, você procura no índice alfabético pela palavra “FIM”. Nada. Depois tenta
“TÉRMINO”, e nada ainda. De súbito, vem uma idéia e você procura “DECISÃO”. E lá está: “Decisões,
tomando”. Abrindo na página indicada, encontra a descrição da seguinte instrução:
SE <condição> ENTÃO
<instrução 1>
<instrução 2>
...
FIM-SE
Nesta instrução, se a <condição> for verdadeira, o robô executará as instruções depois de
ENTÃO e até FIM-SE. Por isso, no lugar de <condição> você deve colocar uma instrução que tenha
resposta do tipo VERDADEIRO ou FALSO.
Procurando no índice “CONDIÇÃO”, e abrindo na página indicada, você descobre que o robô é
capaz de fazer avaliações do ambiente, através da instrução
CONDIÇÃO (Objeto, Estado).
Ao instruir o robô, Objeto deve ser trocado por lâmpada, porta, algum aparelho ou outro objeto
que o robô reconheça. Estado deve ser substituído por aberto, fechado, ligado, desligado ou outro, que
faça sentido para o objeto informado. O exemplo do manual lhe pareceu uma das formas mais estranhas
que já tinha visto de se comunicar com alguém:
SE Condição(Lâmpada, Acesa) ENTÃO Desligue(Lâmpada).
“Mas parece fácil”, você pensa, e então testa o robô:

− Robô, Condição(Televisão, Ligada).
− Robô, Condição(Televisão, Ligado).
Surpreso, você se indaga porque não funcionou. Folheia o manual, resmungando algo sobre os
inventores daquilo não gostarem de artigos e preposições, quando vê um exemplo no manual e diz:
− Robô, Fale(Condição(Televisão, Ligada)).
− Verdadeiro.
Ufa! Funcionou, mas você se pergunta se não haveria jeito melhor de programar algo tão bobo.
“Bem, se não tiver, é com isso que eu vou ter que me virar”.
Mas você não viu ainda um jeito de o robô verificar se ainda tem peças de lego para guardar.
Voltando à página do SE..ENTÃO, e lendo os exemplos, você vê que depois do SE pode ser usada a
instrução ACHOU, porque esta também tem as respostas VERDADEIRO ou FALSO. “Achou o quê?”
Animando-se, descobre que o robô entende a instrução
Procure (Objeto)
Ao ouvi-la, ele efetua uma busca visual no ambiente pelo objeto indicado. O ACHOU se refere à
última procura feita. E você pode incluir um NÃO antes do ACHOU: “Se achou...”, “Se não achou...”.
Testando, diz ao robô:
− Robô, Procure (Peça do Lego). Robô, Fale(Achou). O robô, após alguns movimentos com a
cabeça, responde:
− Verdadeiro.
Muito bom. Uma nova idéia:
− Robô, Procure(Peça do Lego). Robô, se achou então fale(“Meu amado mestre, achei uma peça
do lego”).
− Meu amado mestre, achei uma peça do lego.
− Veja só, tem jeito de você parecer um pouco mais normal!
De repente, lhe vem à mente que havia aquela instrução REPITA..ATÉ que executava várias
instruções até que uma condição fosse verdadeira: agora já entende as condições. Acha então que já tem
todas as que precisa: como procurar uma peça e guardá-la na caixa, como repetir a procura e como fazer o
robô decidir a hora de parar. Agora só falta organizar as instruções numa seqüência apropriada.
Após fazer alguns esboços num papel, você finalmente chega ao algoritmo:
ALGORITMO Guarde todos os lego.

REPITA
Procure(Peça do Lego)
Pegue(Peça do Lego)
ATÉ QUE Não Achou
FIM-ALGORITMO
Você acha que o algoritmo vai funcionar, mas parece estar faltando alguma coisa. Faz de conta
então que é o robô, e executa as instruções como se fosse ele. Procura uma peça, pega, coloca na caixa, a
condição “Não Achou” é falsa, então volta, procura uma peça, coloca... Espera aí: e se não achar, vai
colocar o quê? Chega à conclusão de que após a procura deve testar se encontrou uma peça, e só
pegar/colocar se achou peça. O algoritmo aperfeiçoado fica assim:
ALGORITMO Guarde todos os lego.

REPITA
Procure(Peça do Lego)
SE Achou ENTÃO
Pegue(Peça do Lego)
FIM-SE
ATÉ QUE Não Achou.
FIM-ALGORITMO
Após programar o robô, espalha as peças pra todo lado e diz:
− Robô, guarde todos os lego.
YESSS!!! Uma a uma, o robô vai pegando as peças e colocando na caixa, até não sobrar
nenhuma. Bem, sobrou uma, que caíra embaixo do sofá, mas nem por isso a satisfação é menor.
Sua imaginação dispara com as possibilidades de usar aquele seu servo: fazer-lhe massagem e
cafuné, arrumar seu quarto, café na cama, digitar trabalhos (ou quem sabe fazê-los!), lhe dar banho... Que
outras coisas interessantes poderia fazer com ele?
Exercício 1.1 – Outras utilidades do robô

Se tivesse um robô como o do texto, para que acha que o usaria? Identifique 3 aplicações. Seja específico:
“atender à porta”, ao invés de 'tarefas domésticas”.
Exercício 1.2 - Chateando

Como você instruiria o robô para chatear alguém, se quisesse? Faça um algoritmo simples para isso. Você
pode utilizar instruções mencionadas no texto ou inventar alguma que lhe pareça razoável estar disponível
num robô doméstico (por exemplo, Puxar (Objeto), onde Objeto pode ser “cabelo”).
Exercício 1.3 – Decisões cotidianas

Cotidianamente tomamos vários tipos de decisão: quando parar de comer ou a que horas tomar banho,
estudar ou ir ao cinema, o que jogar no computador e inúmeras outras. Forneça 3 exemplos simples de
decisões domésticas e cotidianas do tipo SE <condição> ENTÃO <ação> SENÃO <outra ação>,
distintas das mencionadas no texto. Modelo: SE “telefone está tocando” ENTÃO “Atenda ao telefone”
SENÃO "Continue estudando".
Exercício 1.4 – Fale comigo

Altere o algoritmo “Guarde todos os lego”, acrescentando instruções de forma que o robô, depois de
guardar todas as peças, informe a conclusão.
.1.2. Brincando de robô
Aproveitando as idéias da história, vamos explorar um pouco as possibilidades de um robô. Nos

exercícios abaixo, considere que o robô entende as seguintes instruções:
Ande(X passos)
Vire(X graus), onde graus positivos referem-se ao sentido horário.

As respostas dos exercícios devem ter a forma de um algoritmo, como na história. Veja um
exemplo:
Exemplo 1.5 – Ande e vire

Usando as instruções Ande e Vire, elabore um algoritmo que faça o robô (à esquerda) alcançar o pote do
outro lado. A linha tracejada representa a medida da distância, em passos .
Solução:
Algoritmo BuscaOPote_2
Ande(10 passos)
Vire(90 graus)
Ande(3 passos)
Vire(-90 graus)
Ande(8 passos)
fim
Exercício 1.6 – Ande e vire 2

Agora é sua vez: faça um algoritmo semelhante para o roteiro abaixo:
Exercício 1.7 – Ache o erro

O algoritmo abaixo foi feito para o robô achar o pote por um dos caminhos, mas contém erros. Corrija-o.
Algoritmo BuscaOPote_com_erro
Ande(10 passos)
Vire(90 graus)
Ande(4 passos)
Vire(90 graus)
Ande(8 passos)
Vire(90 graus)
Ande(4 passos)
Vire(-90 graus)
Ande(8 passos);
fim
Exemplo 1.8 – Alternativas

Na figura abaixo, há um obstáculo, e não se pode saber se o robô pode passar até que ele chegue ao local.
Lá, ele deve verificar se pode passar; se puder, prossegue, senão volta.
?
Verifique que o algoritmo deve ter os seguintes passos:
"Ande até o local do obstáculo"
"Se puder passar"
"Ande até o pote"
"Senão"
"Volte ao ponto de partida".
Lembre-se de que o robô, diante de alternativas, pode tomar decisões, na forma:
Se <condição> então
Ações
Senão
Outras ações.
Consultando o manual, verificamos que o robô entende uma instrução do tipo verdadeiro ou falso, no
formato Possível(Verbo), onde verbo é uma ação. Uma das ações pode ser andar, ou seja, a instrução
informa verdadeiro quando o robô pode dar um passo e falso quando não pode. Com essa instrução,
podemos converter os passos acima para um algoritmo que o robô entenda:
Algoritmo BuscaOPoteComDecisão;
Ande(6 passos)
Se Possível(Andar) então
Ande(6 passos)
Senão
Vire(180 graus)
Ande(6 passos);
fim.
Exercício 1.9 – Alternativas duplas

Vamos aplicar o comando de escolha para o percurso abaixo. Agora o robô deve seguir por um dos lados,
verificar se pode passar. Se puder, segue, caso contrário, volta e passa pelo outro lado. Somente um dos
lados vai estar fechado.
Como dica, veja a seqüência básica das ações:

"Ande até o obstáculo da esquerda"
Se "é possível andar" então
"Ande até o pote"
Senão
"Retorne e vá até o pote pelo outro lado".
Note que algumas das ações devem ser decompostas para se chegar a instruções que o robô entende. Faça
agora o algoritmo.
Exemplo 1.10 – Repetição

Vamos ver agora como um comando de repetição pode facilitar o controle das ações do robô.
Combinando as instruções Repita..Até-que e uma variante de Possível(), a instrução Impossível(), para o
percurso abaixo podemos fazer o seguinte (passando pela esquerda):
Algoritmo AndandoComRepetição
Repita
Ande(1 passo)
Até que Impossível(Andar);
Vire(90 graus);
Repita
Ande(1 passo)
Até que Impossível(Andar)
Vire(-90 graus)
Repita
Ande(1 passo)
Até que Impossível(Andar)
Vire(90 graus)
Ande(6 passos)
Vire(-90 graus)
Ande(6 passos)
fim
Note que para a maioria do percurso não precisamos mais saber quantos passos o robô deve dar, o que
sem dúvida proporciona muito mais flexibilidade.
Exercício 1.11 – A casa

Elabore um algoritmo para que o robô percorra a "casa" da figura abaixo e caminhe até o pote. Faça uma
estimativa de passos, digamos, cada centímetro na folha um passo.
.1.3. Algoritmos
Como você viu na história do robô, algoritmos descrevem padrões de ação para se resolver um
problema ou atingir um determinado resultado, usando um repertório de ações disponíveis. A elaboração
de algoritmos é a alma da programação; boa parte desta consiste em se achar soluções que possam ser
implementadas com os recursos disponíveis no computador e em uma linguagem de programação. O
personagem da história estava envolvido em elaborar algoritmos para conseguir que o robô fizesse o que
queria, assim como você, nos exercícios, estava envolvido em fazer o robô chegar até o pote.
Todos estamos familiarizados com algoritmos, já que aplicamos vários no dia-a-dia. Quando você
decide que vai a algum lugar e escolhe o meio (a pé, de carro, de ônibus) e um itinerário, está elaborando
um algoritmo. Assim como os algoritmos do robô, você executa ações (andar), repete alguma ação até
que uma condição seja atingida (andar até chegar ao destino ou a um ponto intermediário) e toma
decisões (qual caminho tomar, para onde virar em encruzilhadas). Até quando paquera você elabora
algoritmos, embora possa não ter consciência disto. Ele ou ela me interessa? O que fazer primeiro, flertar
ou mandar um bilhetinho? Talvez você repita alguns comportamentos que funcionaram em outras
oportunidades (ou imite o padrão de alguém...).
E se sabe fazer qualquer coisa ao fogão, seja ferver água ou preparar macarrão à bolonhesa, sabe
que, se não executar certas ações em uma determinada seqüência, não vai atingir os resultados desejados.
Mesmo para ler esta página está usando algum algoritmo. Assim, algoritmo para você é mais um nome
novo para algo familiar.
Uma página pode ser lida de várias maneiras: a que aprendemos na escola, a leitura dinâmica, a
fotoleitura. Ou seja, há vários algoritmos de leitura. O mesmo ocorre com os algoritmos de computador;
para um mesmo problema ou resultado desejado, podem haver várias soluções possíveis. Um problema
muito comum é ordenar uma série de valores em ordem crescente ou decrescente, como uma lista de N
nomes de clientes. Uma forma de fazer isto é percorrer a lista à procura do maior e colocá-lo em outra
lista, repetindo isto N vezes, a cada vez escolhendo o maior dentre os que restaram. Para o problema da
ordenação há vários outros algoritmos, como o da bolha, o quick-sort e o heap-sort, cada um apropriado a
um tipo de situação. No caso de ir a algum lugar pela primeira vez, você em geral estará procurando o
melhor algoritmo dentre várias alternativas para chegar lá.
.1.3.1 Representando problemas e situações
Você também já conhece formas de representação de problemas e padrões de solução, como a da

matemática. Lembre-se, por exemplo, das equações do segundo grau, como x 2 − 3 x +1 = 0 . Para
representar todas essas equações, escrevemos. Os coeficientes a, b e c expressam que os valores em suas
posições podem ser quaisquer. Para definir uma equação do segundo grau, portanto, precisamos saber
somente os coeficientes, que são o que varia de uma equação para outra. E para achar as soluções, o
padrão é
− b ± b 2 − 4ac
x=
2a
A fórmula acima indica o que se deve fazer para achar as soluções usando os coeficientes, ou
seja, o padrão de comportamento que se deve seguir, e é um tipo de algoritmo. Designamos com nomes o
que é importante para descrever a situação (a, b, c) e indicamos a solução por meio de algum tipo de
representação das ações que devem ser executadas (operações matemáticas). E quando formos resolver o
problema para algum caso específico, trocamos os nomes pelos respectivos valores e executamos as
operações previstas.
De maneira geral, um algoritmo envolve coisas ou objetos, e ações sobre ou usando esses
objetos. Na equação acima os objetos são os coeficientes, representados por suas letras, e as ações são
elevar ao quadrado, subtrair, somar, dividir. Na história do robô os objetos eram legos, e as ações eram
procurar, pegar, colocar, além de ações de controle, como decisão e repetição. Lembre-se do que acontece
no Windows quando clica com o botão direito sobre um objeto, como um ícone de arquivo: aparece um
menu com as ações ou operações que você pode executar sobre aquele objeto.
Tudo se resume então a duas perguntas: como representar objetos e como representar ações sobre
os objetos, de uma forma mais fácil e mais apropriada. No Windows, representa-se arquivos como ícones
ou pequenas imagens, e esta é uma forma que alguém considerou apropriada para lidar com eles. No
antigo ensino primário, uma incógnita de um problema era representada por um ‫ٱ‬. No nosso contexto
computacional, os objetos são representados de forma semelhante à matemática, usando-se variáveis.
Uma variável é um nome atribuído a um valor ou característica para generalizá-lo. Na equação do
segundo grau, "a" é o nome dado ao coeficiente do termo ao quadrado, que representa todos os
coeficientes possíveis para o termo.
Você já usa variáveis
Veja como usamos variáveis no dia a dia: se você vai comprar um sapato,
o vendedor lhe pergunta: qual é o seu número? Você pergunta: quanto
custa? O número e o preço são variáveis que representam características
de um objeto, um sapato. Outras variáveis de um sapato podem ser de
interesse, conforme a pessoa: cor, marca ou altura do salto. Ao decidir se
paquera ou não alguém, você procura "valores" para certas variáveis de
seu interesse: sexo, idade, cor do cabelo, e por aí vai.
Como você já viu na história do robô, no contexto da programação há mais flexibilidade ao se dar
nomes a variáveis. É muito mais fácil entender nomes como "NomeCliente", "CodigoProduto" (não se
usa acentos nem espaços) e "Contador" do que com NC, CP ou C.
O que se pode fazer com as variáveis de um problema? Genericamente, o que se faz com
variáveis é armazenar valores ("atribuição") e recuperar valores armazenados (através do respectivo
nome). Outras operações dependem do papel da variável. Subtração, por exemplo, é uma ação apropriada
para se fazer com números. No caso de uma pessoa, "pegar" é uma ação apropriada para uma peça de
lego, mas "comer" não parece ser. Assim, as operações sobre as variáveis vão depender do que contém a
variável: se representa um número qualquer, pode-se fazer contas com ele. Se o número representa a
população de uma cidade ou a quantidade de faltas de um aluno, outras coisas podem ser feitas.
E uma vez que se sabe o que fazer, qual é a melhor forma de representar as ações? Para os nossos
propósitos, você pode imaginar um algoritmo como um "ser" ou processador (com memória) que recebe
uma entrada, na forma de variáveis, executa ações e produz uma saída também na forma de variáveis ou
um resultado:
E n t r a d a
S a í o d ur a e s u l t a d o
A ç õ e s
Para a equação do segundo grau, o diagrama seria:
a , cb ,
X , 1X 2
C a lc u la r
r a í z e s
Se o algoritmo visasse um desenho, por exemplo, não haveria uma saída na forma de variáveis (e
talvez você desenhasse o próprio círculo na seta da saída).
Tendo a visão entrada/processamento/saída, basta descrever as ações, para o que há várias

maneiras. O problema da equação do segundo grau, por exemplo, poderia ser descrito em forma de
narrativa: "Uma equação do segundo grau é representada como o produto de a pelo quadrado de x mais o
produto de b por x mais c, tudo isto igual a zero. Para achar a primeira raiz, some menos b com a raiz
quadrada do quadrado de b menos o produto de 4 por a por c, dividindo o resultado pelo dobro de a...". Se
for escolhida a matemática, a solução será indicada pelo fórmula acima. As operações não mudam, só a
forma de indicá-las; ao invés de se escrever "menos", por exemplo, escreve-se "-". O robô da história
entende "Pegar", mas poderia entender como "Pick" se a sua linguagem fosse baseada no inglês.
Compreender o que deve ser feito é mais importante do que a representação.
Assim, para representar uma solução algorítmica não há regras rígidas, você vai escolher a
melhor de acordo com o contexto e com o que conhece. Pode ser a matemática ou uma narrativa, como
acima. Pode ser como os algoritmos do robô. Existem formas mais visuais, como o fluxograma e o
diagrama de Chapin (ver por exemplo Guimarães e Lajes). Se muitas decisões devem ser tomadas em
seqüências, pode-se usar uma árvore de decisão (veja o capítulo 6). Você pode usar uma forma sua de
expressão, pode misturar tudo e pode inventar comandos. As diretrizes principais são usar algo que você
conheça e ficar próximo ao formato estruturado das linguagens de programação (o que você só pode fazer
quando conhecer uma). Elaborar um algoritmo pode ser um grande prazer, que não deve ser prejudicado
por nenhuma regra rígida.
No decorrer do texto representaremos algoritmos de formas livres e

variadas, incluindo comandos parecidos com os da história do robô,
diagramas, pseudo-comandos (como "armazene 1 na variável Contador")
e outros que serão descritos. Confira também as dicas para elaboração e
o apêndice com ferramentas de pensamento.
Exercício 1.12 – Reconhecendo ações sobre objetos

Para cada objeto abaixo, identifique duas operações que você pode efetuar sobre ou com cada um:
a) Televisão
b) Lápis
c) Livro
d) Carro
e) (escolha um)
Exercício 1.13 - Variáveis de uma página

Localize em um processador de textos (Word, WordPerfect, Carta Certa) a parte de configuração de
layout de página, e identifique pelo menos 4 variáveis que o programa usa para representar uma página.
Exercício 1.14 – Variáveis de etiqueta

Observe ou faça um esquema de uma folha para impressão de etiquetas e identifique as variáveis que
seriam importantes caso você fosse fazer um algoritmo para imprimir nesse tipo de folha. Por exemplo:
quantidade horizontal, altura da etiqueta. Indique em uma figura as variáveis encontradas.
Exercício 1.15 – Ordenando

Ordene os seguintes conjuntos, procurando observar como o faz:
a) Os dedos de sua mão, pelo tamanho
b) Idem, pela espessura
c) As palavras desta frase, por quantidade de letras
Exercício 1.16 – Algoritmo para cozinha

Identifique algo simples que saiba fazer na cozinha ("ferver água", "fritar um ovo") e descreva-o como
um algoritmo: entrada necessária, processamento e saída ou resultado.
Exercício 1.17 – Apagando as luzes

Faça um algoritmo para que o robô, no esquema de casa acima, percorra todos os cômodos e verifique se
cada lâmpada está acesa. Se estiver, ela deve ser apagada. Considere a instrução Aceso(objeto), que
retorna verdadeiro ou falso, e Apague(Lâmpada). Para que o robô possa verificar um cômodo, ele deve
dar pelo menos um passo dentro dele.
Exercício 1.18 – Soletrar tem algoritmo?

Observe a seguinte afirmação:
"A estratégia típica de soletração das pessoas é produzir uma imagem interna da palavra e ler cada
letra. Uma evidência disso é o olhar fixo à frente da pessoa enquanto está soletrando".
Você acha que o procedimento descrito pode ser considerado um algoritmo? Se sim, descreva-o em
termos de entrada, processamento e saída.
30
.2 O PROCESSO DE PROGRAMAR
O processo de elaborar um programa-fonte em uma linguagem de alto nível, na verdade, é apenas

uma parte da programação. Saber o que o programa deve fazer, e saber verificar se o programa faz o que
deve e não faz o que não deve são etapas integrantes de qualquer projeto de implementação. E são
independentes da linguagem utilizada.
Neste capítulo você vai ver tópicos que são imprescindíveis a qualquer programador e à
elaboração de qualquer programa. Conhecer e saber usar este material tornará tudo mais fácil, e não
conhecê-los pode realmente tornar todo o resto impossível.
.2.1. Estratégia geral de programação
Pense no seu corpo; o que imagina? Provavelmente pensou no seu corpo inteiro, um todo. Este
todo pode ser visto em um nível de estruturação: cabeça, tronco e membros. Ao ler isso, você deve ter
imaginado essas partes. Agora focalize os membros: estes também podem ser vistos de uma forma
estruturada: braços e pernas. Agora imagine um braço e suas partes... Continuando, passaremos pelo nível
fisiológico e pelos níveis celular, molecular, atômico e é possível descer ainda mais.
De forma análoga, você pode observar o universo, uma galáxia, um sistema solar,
um planeta, um continente, um país, um estado, uma cidade, um bairro, uma casa, um quarto
e...você praticando programação! Videogames têm fases, quebra-cabeças têm peças, livros têm
capítulos e por aí vai.
Assim como tantas coisas na vida, ao programar computadores

precisamos segmentar as coisas até que as partes tenham um tamanho
administrável, ao alcance da nossa inteligência e capacidade atuais. O tamanho de
cada parte vai depender do que queremos e sabemos fazer.
Esta estratégia é usada por um programador em todos os níveis, como você verá nas
seções seguintes.
Exercício 2.1 - Segmentação

Identifique divisões de cada item:
a) Um jornal
b) Um computador
c) Uma escola
d) O tempo
e) Uma frase
3 - O PROCESSO DE PROGRAMAR 31
Como diretriz geral, lembre-se de que, se algum resultado desejado não

estiver sendo atingido, provavelmente é o momento de segmentar, de
dividir o problema em partes menores.
.2.2. Etapas da programação
Você já teve contato com alguns programas prontos. Viu que um programa faz algumas coisas,
outro faz outras diferentes. Viu como são os programas por fora, na visão do usuário, e já sabe que o que
produz esses efeitos no computador é um programa executável, programado originalmente como um
programa-fonte, que foi convertido para linguagem de máquina.
Você já tem noções, portanto, dos elementos fundamentais da programação de computadores: a

especificação, que diz o que o programa deve fazer; o resultado final, que é o programa funcionando no
computador; e o programa-fonte propriamente dito. Um programador está envolvido com esses três
elementos. Ele parte da especificação e projeta um programa, a partir deste projeto implementa um
programa executável e o testa para ver se atende à especificação (figura). Este é o primeiro nível de
segmentação da programação.
E S P E C I F I C A Ç Ã O
PR
OJ
ET
AR
AR
ST
TE
P R O G R A M A P R O G R A M A
F O N T E P R O J E T A D O
I M P L E M E N T A R
A especificação indica os objetivos do programador, o que fazer. O programa projetado é o efeito,

o que será visto por seus usuários, isto é, visto por fora. E o programa-fonte é o como: instrução a
instrução, comando a comando; é a causa que vai fazer com que aconteça o efeito.
.2.3. Especificação do programa

“Pode me dizer, por favor, que caminho devo pegar?”
“Depende para onde você quer ir”, disse o gato.
“Não me importa muito onde...”, disse Alice.
“Então não importa o caminho que você pegue”,
respondeu o gato.
Alice no País das Maravilhas
Lewis Carroll
Uma pessoa pode dirigir um automóvel de pelo menos duas maneiras: com destino ou sem
destino. Se não há destino definido, a pessoa pode andar a esmo por horas a fio, virando para qualquer
direção que lhe der na cabeça, que não fará muita diferença. Porém, se a pessoa sai de casa pretendendo ir
a algum lugar, a direção para onde vai determinará se vai ou não chegar ou se chegará com atraso. Isso
vale também para certos equipamentos domésticos: ao programar a gravação de um videocassete, por
exemplo, você terá em mente uma descrição precisa do que quer, como por exemplo:
“Gravar o programa que será transmitido no dia 25.12.96, das

21:30 às 23 horas, no canal 7".
Você também sabe exatamente qual é o produto final: uma fita gravada com o programa
desejado. Reflita por um momento como você conseguiria programar o videocassete sem alguma das
informações acima.
De forma análoga, muitos programadores sentam-se diante de um microcomputador para

programá-lo, sem definir precisamente aonde vão chegar. Muitos alunos perdem pontos em provas
porque não lêem ou não fazem tudo que está sendo pedido. Isso ocorre também em outras disciplinas que
não programação. E muitos programas profissionais são devolvidos, gerando custos extras e atrasos, pelo
mesmo motivo: fora de especificação. Assim como na vida pessoas sem objetivos em geral dispersam
suas energias, programadores sem uma especificação adequada são via de regra dispersadores de energia,
que podem dedicar horas ou dias para pouco produzir de efetivamente útil.
Portanto, a primeira coisa a se ter em mente ao programar computadores é saber o que será feito,
uma descrição objetiva do que se espera que um programa faça, chamada especificação. Uma
especificação contém as características e detalhes relevantes de um programa: o que entra, o que sai,
instruções para cálculos, podendo incluir também figuras e diagramas ilustrativos. A especificação indica
o objetivo primário do programador. É o ponto de partida e o ponto de chegada. É a referência para ele
saber se está certo ou errado, e se está progredindo ou não. Certo é o que atende à especificação.
Exemplos de especificações simples: “Calcular fatorial”, “Desenhar

um quadrado na tela ou na impressora”, “Ordenar uma lista de 1000
números em ordem ascendente”, “Jogar o jogo-da-velha”. Especificações
mais complexas podem envolver várias folhas, documentos, esquemas e
figuras.
O bom programador é fiel - Você pode ser um programador

esforçado e dedicado, além de extremamente criativo, mas se não fizer o
que foi especificado, estará errado e ponto final. Por isto, deixe que crie
raízes bem fortes na sua mente o princípio da fidelidade à especificação.
Primeiro faça o que lhe foi pedido; depois, se quiser e tiver tempo, dedique-
se a fazer algo a mais.
Características de uma boa especificação - Uma especificação deve ser correta: se o

programador segui-la adequadamente, o programa resultante produzirá resultados confiáveis e de acordo
com o esperado. Por exemplo, a especificação pode conter uma fórmula para o cálculo de juros que
contém um sinal invertido. Você pode ter sido fiel à especificação, mas o programa fará cálculos errados.
Uma especificação também deve ser completa, em termos de seus objetivos. Quando completa,
contém todos os detalhes necessários e suficientes para que o programa possa ser elaborado. Uma das
grandes causas de atrasos no desenvolvimento de programas são especificações incompletas, que obrigam
o programador a rever decisões anteriormente tomadas, com todo o retrabalho que isso pode causar. Por
exemplo, suponha que você entregou o programa dos juros, pronto, para o usuário testar. Ele então
descobre que esquecera de lhe informar que o cálculo dos juros, em uma determinada época, era feito de
forma diferente. Lá vai você então alterar o programa e testar tudo de novo.
O programador deve tomar decisões – No mundo real, existe a possibilidade de que a

especificação esteja incompleta ou errada, por fatores fora do controle do programador, como enganos do
especificador ou erros de digitação.
No caso de especificações incompletas, as informações não serão suficientes para a produção de

um programa completo. Várias omissões ocorrem no ambiente escolar: a especificação normalmente
omite detalhes a respeito de formatação de tela e outros aspectos que não façam parte da essência do
problema. No caso de um programa que calcule as raízes de uma equação do segundo grau, por exemplo,
não importa (exceto se especificado) se o faz em uma janela, se limpa ou não a tela, ou se uma mensagem
de erro fica piscando na tela por 5 segundos, desde que as raízes sejam calculadas corretamente. O
aprendiz deve então decidir por si mesmo como vai implementar o programa, suprindo as omissões.
É importante compreender que, ao ver pela primeira vez uma

especificação, o programador está no grau mais superficial de
entendimento. Este vai aumentando à medida que se lê, se estuda, se
discute e se evolui na implementação.
"Mantenho seis servidores honestos, eles me ensinaram tudo o que sei. Seus nomes são: O quê e Por
Quê e Quando e Como e Onde e Quem".
Rudyard Kipling

Assinale V para as afirmações verdadeiras e F para as falsas:
( ) Uma especificação indica ao programador o que fazer, mas não necessariamente
como.
( ) Eventualmente o programador terá que tomar certas decisões sobre o que fazer no
programa devido a omissões da especificação.
( ) Eventualmente o programador não poderá tomar certas decisões sobre o que fazer
no programa devido a omissões da especificação.
( ) O programador deve modificar a especificação para tornar o programa mais
simples e fácil de implementar.
( ) O programador não deve se importar se a especificação está completa ou não,
sempre poderá culpar depois quem forneceu a especificação.
Exercício 2.3 – Características de especificações

a) Mais importante que ser criativo é o programador ser _______________ à especificação.
b) Uma boa especificação deve ser _______________ e _________________.
c) Uma das grandes causas de atraso na entrega de programas são especificações
____________________.
Exercício 2.4 – Sendo específico

Você pode definir especificações precisas (pelo menos para você) para tarefas domésticas, como:
“Pegar o CD azul da Ennya e reproduzir a faixa 3 duas vezes”
Defina especificações detalhadas para as tarefas abaixo:
a) Preparar um lanche da tarde.
b) Estudar um tópico de uma disciplina (especifique qual).
c) Preparar uma mala para viagem.
Exercício 2.5 – Seu dia

Elabore uma especificação das suas atividades para um próximo dia útil. Após, faça uma crítica da
completeza e correção. Após viver esse dia, verifique o quanto foi fiel ao planejamento feito.
.2.4. Projeto de programas

"Você pode realizar tudo que pode conceber”
Eva Pierrakos, em O Caminho da Autotransformação.
O fato de haver especificações decorre em geral de haver alguém querendo um programa e não
sabe ou não quer fazê-lo, e então pede para um programador. Nesta situação, e em qualquer outra em que
o programa não foi concebido pelo próprio programador, este precisa entender o que o outro quer, para
que possa atendê-lo. A melhor forma de fazer isto é criar uma visão do resultado final, que aqui
chamamos de projetar o programa.
Ao ver pela primeira vez a especificação, você está no ponto em que dispõe da menor quantidade
de informações. Se está começando e não tem muita experiência, pode ter um "branco" ou um "preto"
total. Isto é natural; quando iniciamos algo, você sabe que é previsível que teremos alguma dificuldade,
muito mais pela falta de informação que por falta de habilidade. Também é comum ocorrerem no início
erros de interpretação da especificação, que vão sendo esclarecidos à medida que se prossegue. Não é
nem necessário chamar isto de "erros": se preferir, chame de "interpretações iniciais".
Todos esses fatores remetem a um só ponto: é preciso elaborar um projeto do programa, conceber
como ele ficará quando pronto. Imagine, por exemplo, que um jogo de computador deve ser programado.
Como será mais fácil fazer isto, começando de algumas frases no papel ou depois de já ter "jogado" o
jogo algumas vezes na cabeça? Na verdade, nenhum programador consegue fazer um programa sem tê-lo
na mente; o que às vezes ocorre é que o desenho vem sem que precisemos pensar conscientemente nele, o
que é inclusive evidência de maior maturidade.
Para projetar programas, você precisa saber como são os programas e o que é possível fazer com
eles e com o computador. Parte da experiência você já teve, ao experimentar os programas de
demonstração; veja mais a seguir.
.2.4.1 O que os programas fazem
Basicamente o que os programas fazem são combinações das seguintes operações:
Saída – Programas mostram ao usuário instruções ou resultados, na tela ou em outro periférico de

saída. Podem também fazer algum tipo de formatação ou desenho na tela.
Entrada – Programas efetuam leituras de dados (um número, um texto, uma tecla), normalmente
digitados pelo usuário. Após lido, um dado é guardado na memória para que possa ser usado depois.
Decisões – Diante de alternativas, os programas tomam decisões: o aluno passou? O número lido
é válido, ou seja, está dentro de uma faixa de valores esperada? Qual opção do menu deve ser executada?
Repetição – Por vezes os programas repetem algo que fizeram anteriormente, só parando quando
alguma condição for atingida. Em um menu, por exemplo, o programa só deve parar quando for digitada
a opção que indica o término.
Cálculos e outras computações – algumas coisas que um programa faz podem não estar visíveis.
Por exemplo, em um programa que calcule raízes de equações do segundo grau, na tela vão aparecer
mensagens pedindo para informar os coeficientes da equação e para mostrar os resultados, mas o cálculo
feito não é indicado.
.2.4.2 Tipos de programas
Talvez você esteja familiarizado com programas para Windows, com barras de menus e de
ferramentas, botões, ícones, caixas de diálogos e outros tipos de objetos. Os programas que veremos aqui
não possuem a tela em modo gráfico, como no Windows, e sim em modo texto. Neste modo a tela é
dividida em linhas e colunas, assim:
T E X T O _
X X X X X
X X
X X
- - - X X
| | X X X X X
- - -
Em cada posição da tela podemos apresentar um caractere, como A, i, !, ^, | e outros menos

comuns. Toda tela em modo texto possui um cursor, que fica piscando em alguma posição. Há diferentes
modos texto, sendo o normal 80 colunas e 25 linhas.
Esta tela é característica do sistema operacional MS-DOS (e suas variações), que era o padrão dos
PCs antes do Windows. O DOS executa somente um programa de cada vez, e todos os programas
compartilham a mesma tela, ao contrário do Windows, no qual cada programa tem sua janela. Veja mais
sobre DOS em outro capítulo à frente.
Programas "máquinas de escrever"

Chamamos os programas
de seqüenciais quando sua tela é
formada de maneira parecida com
uma máquina de escrever. O texto Entre nome:
Fulano
aparece de cima para baixo, uma
Entre disciplina:
linha de cada vez. Veja ao lado um Linguagem
exemplo de tela de programa Entre nota:
seqüencial. O programa pede o 6
nome, o usuário digita o nome e Fulano, Você passou em Linguagem
tecla Enter. Depois o programa
pede para digitar a disciplina, a
nota e finalmente informa se o
aluno passou ou não, terminando
em seguida. Após cada digitação o
usuário do programa tecla Enter
para informar a conclusão.
Prática 2.6 – Conhecendo programas seqüenciais

Execute o programa de demonstração. Selecione a opção "Programas por tipo" e depois "Programas
seqüenciais". Execute os programas mostrados.
Programas com menus
Há programas que apresentam algumas opções na tela, e o usuário deve escolher o quer fazer. O
programa de demonstração é um desses. O menu pode ser horizontal ou vertical, e mais ou menos
sofisticado: podem permitir que o usuário escolha o que quer fazer por uma letra ou número, podem
destacar a opção com uma cor diferente ou brilho. Cada seleção pode conduzir a uma ação ou a outro
menu secundário. Um estilo muito fácil de implementar é o de menus simples e verticais, como o da
figura abaixo.
MENU PRINCIPAL
0 - Termina
1 - Cadastro de programas
2 - Programas por tipo
3 - Programas por categoria
Tecle sua opção:_

Prática 2.7 – Conhecendo programas com menus

Execute o programa de demonstração (que é orientado a menus). Selecione a opção "Programas por tipo"
e depois "Programas com menu". Execute os programas mostrados.
Outros tipos
¦ +-----------+
¦ ¦ ¦
Há programas que não seguem ¦ ¦ ¦
¦ +--------+----+ ¦
os padrões vistos; afinal, não há regras ¦ ¦ ¦ ¦ ¦
rígidas sobre como os programas +-------+--------+ ¦ ¦
devem funcionar. Um exemplo é o ¦ ¦ ¦
programa que faz desenhos segundo os ¦ ¦ ¦
¦ ¦ ¦
movimentos que o usuário faz com o ¦ ---------+ ¦
cursor através das setas do teclado, cuja ¦ ¦
tela pode ser vista ao lado. +--------------------+
Prática 2.8 – Conhecendo outros estilos de programas

Execute o programa de demonstração. Selecione a opção "Programas por tipo" e depois "Programas
variados". Execute os programas mostrados.
.2.4.3 Estrutura de programas
Não importa quais operações os programas executem, nem qual o seu tipo; todos tem uma
estrutura, e podem ser vistos de uma forma segmentada. Na visão mais geral, os programas têm 3 partes
ou seções: inicialização, principal e finalização:
C o m a n d o s
S e ç ã o
I n ic ia liz a ç ã o p r in c ip a l F in a liz a ç ã o
Veja o que cada uma em geral pode conter:
Inicialização: Quase todos os programas têm algo a fazer quando iniciam. Pode ser simplesmente
mostrar na tela o que faz ou o nome do programador, e inicialização de algumas variáveis. Alguns, como
o Word ou o Windows, mostram uma tela de apresentação. Os mais elaborados fazem abertura de
arquivos e recuperação de dados da sessão anterior, gravados no disco. Se o programa exige senha, ler e
verificá-la será uma das primeiras coisas a fazer. Há programas que fazem tudo isso.
Seção principal: Aqui é feito o que deve ser efetivamente feito, e pode ser simples ou bem
complexo. Nos programas mais simples, aqui é feita a leitura de algum dado e realizado o que foi previsto
na especificação. Em outros casos, os programas entram em um estado de espera: mostram uma tela com
um menu, por exemplo, e o usuário deve comandar algo ou informar o que quer fazer, seja através de uma
tecla normal ou de função ou cliques de mouse. O programa executa o que foi comandado e volta para
esperar outro comando.
Finalização: Há coisas que precisam ser feitas antes que certos programas possam sair da
memória sem problemas: fechamento de arquivos, mensagens de término, gravação de dados da sessão
para uso posterior. Há um instalador de um programa comercial que, antes de terminar, mostra uma
mensagem baseada na hora e no dia da semana: se de manhã, "Bom dia!", se após meio-dia, "Tenha uma
boa tarde", e se sexta-feira, "Bom fim de semana!".
Nos programas maiores, podemos segmentar o produto final em telas, e cada tela em operações,
como mostrar um texto, ler algo do teclado ou efetuar um cálculo.
Como exemplo, considere a seguinte especificação:
As notas de uma faculdade são atribuídas por bimestre, tendo o primeiro bimestre peso 2 e o
segundo peso 3. A nota semestral deve ser arredondada para o múltiplo de 0,5 mais próximo. Elabore
um programa que calcule a nota final.
O primeiro nível de estruturação do programa fica assim:
C á lc u lo d e
n o t a f in a l
C a lc u la r n o t a
I n ic ia liz a ç ã o f in a l F in a liz a ç ã o
O bloco principal ainda está muito genérico. Calcular a nota com base em quê? E o cálculo da
média ponderada? E o arredondamento? Serão necessários, portanto, outras etapas: ler as notas
bimestrais, calcular a média ponderada, arredondá-la e finalmente mostrar o resultado na tela. O diagrama
fica assim:
C á lc u lo d e
n o t a f in a l
C a lc u la r n o t a
I n ic ia liz a ç ã o F in a liz a ç ã o
f in a l
L e r n o t a Cs a l c u l a r m A é rd r i ea d o n d Ma r o s t r a r n o t a
b i m e s t r a i sp o n d e r a d a m é d i a f in a l
A segmentação até esse nível permitiu identificar os algoritmos que devem ser solucionados:
dadas as notas, como calcular a média ponderada, e dada uma nota, como arredondá-la para o múltiplo de
0,5 mais próximo. Estas são soluções que independem do programa, e podem ser desenvolvidas antes de
se iniciar o programa-fonte.
Exercício 2.9 - Programa comercial

Escolha algum programa comercial que já usou ou use e descreva ações que o programa executa ou você
supõe que ele executa na inicialização e na finalização.
Exercício 2.10 - Diagramas de blocos

Faça um diagrama de blocos para a seguinte especificação:
Elabore um programa que lê um número de 1 a 9 e mostra a tabuada de multiplicação do número. Por

exemplo, para o 5:
5x1 =5
5 x 2 = 10
...
5 x 10 = 50
.2.4.4 Projetando programas
Ao fazer um projeto você está definindo a aparência que o programa terá para o usuário. Você
estará vendo o programa como uma caixa preta, já funcionando. Para isso, você identifica que operações
o programa vai realizar, combina essas operações em uma ou mais telas de saída e, se necessário, faz
diagramas de blocos, tudo isso de uma forma que atenda à especificação. Ao detalhar as situações, defina
dados variados de entrada, que provoquem o programa no máximo de situações possíveis (casos de teste).
Convém identificar também os algoritmos envolvidos no programa, e achar solução para eles antes de
iniciar a implementação propriamente dita.
Você deverá buscar respostas adequadas para as seguintes perguntas:

• O que vou ver ao executar o programa já pronto?
• O que aparece primeiro, e aonde?

• Que informações forneço ao programa? Em qual seqüência? O que acontece após eu
fornecer cada informação? Que informações o programa me apresenta?
• Como termina o programa?
• Que algoritmos ocorrem no programa? Já existe uma solução ou vou desenvolver uma?
• Quais os casos e situações com que vou testar o programa?
Vejamos um exemplo de projeto, dentro dos nossos objetivos. A especificação é a seguinte:
“Elaborar um programa que lê uma lista de valores inteiros positivos e, quando lido zero,
informa qual foi o maior e o menor número lido”
Sentado em frente ao
computador, você executa o
programa. A tela é limpa, e
aparece uma mensagem: “Entre
Cálculo de maior e menor números de uma lista.
um número inteiro”. Você digita Entre um número inteiro positivo
o número 54 (que aparece na 54
tela), e tecla Enter. De novo a Entre um número inteiro positivo
mensagem, abaixo do número 12
Entre um número inteiro positivo
54, e você entra com 12. Isso se 234
repete algumas vezes, até que Entre um número inteiro positivo
você entra com zero e, após 0
teclar Enter, aparecem as O maior número foi 234
O menor número foi 12
mensagens (os números são
exemplos): “O maior número foi
234” e “O menor número foi 12”,
e o programa é encerrado. Para
registrar as informações obtidas,
você poderia esboçar a tela, que
ficaria mais ou menos como na figura.
Para este programa não há uma condição de terminação explícita; ele terminará após mostrar o
menor número.
Opcionalmente você poderia ter começado pela segmentação do programa, identificando os

seguintes blocos:
"Mostrar mensagem informativa da finalidade do programa"
"Ler lista de números, parando quando for digitado zero"
"Mostrar o maior número lido"
"Mostrar o menor número lido"
O programa acima envolve o algoritmo para achar, dentre uma lista de números, o maior e o
menor. O algoritmo será diferente, conforme o programa armazene na memória toda a lista, para depois
buscar a solução, ou se armazena o maior e o menor lidos até o momento.
Em outros casos, você terá mais possibilidades. Considere a especificação abaixo:

"Implementar um programa que repetidamente lê os coeficientes a, b e c de uma equação do

segundo grau e, se o delta for positivo, calcula as raízes; se o delta for zero, calcula a raiz única; se o
delta for negativo, mostra uma mensagem,. O programa termina quando os coeficientes forem zero."
Um esquema da tela (seqüencial) do programa poderia ser como a seguir. Observe que o
detalhamento da tela previu as três situações possíveis para o delta (e quando o programa entrar em testes,
você já terá dados para testá-lo).
Entre zeros para terminar.

Entre coeficientes a, b e c, separados por um espaço:
1 1 1
A equação não possui raízes reais

1 -3 2
As raízes são -1.00 e -2.00

1 -6 9
A única raiz é -3.00

0 0 0
Agora considere uma especificação que diz que o programa deve simular um 'O' se movendo pela
tela, da esquerda para a direita e de cima para baixo. Como você detalharia esta tela? Uma possibilidade é
visualizar mentalmente a tela. Se não conseguir, pode fazer um diagrama da tela com setas indicando
(como for possível) as direções do movimento.
O que é mesmo que este programa faz? - Vamos ver um exemplo de como o projeto que você
define para o programa afeta o usuário. Suponha que você executa um programa e se depara com a
seguinte tela:
Entre opção (1, 2 ou 3, 0 para terminar): _
Para que serve cada opção? Se foi você quem fez o programa, e isto ocorreu recentemente, você
pode até saber, caso contrário ficará com um imenso ponto de interrogação na testa. Compare a tela acima
com esta:
Programa para testar funções matemáticas
Opções:
0 - Fim
1 - Fatorial
2 - Pi
3 - Tangente
Sua opção: _
"Lembre-se dos quebra-cabeças: são muito mais fáceis quando você pode ver toda a figura primeiro".
G. Dryden e Jeanette Vos
Exercício 2.11 – Projetando um churrasco

Você já deve ter vivido a experiência de programar um churrasco, levando várias coisas para o local:
espetos, churrasqueira, carvão, talheres, a carne, etc. Mas durante o churrasco, descobre que acabou
esquecendo alguma coisa importante: talvez a toalha de papel, ou o álcool ou outra coisa necessária para
acender o carvão. O que você poderia fazer para não esquecer nada? Uma coisa a fazer seria, ao planejar
ou pegar os apetrechos, imaginar o churrasco acontecendo: alguém acende o carvão, alguém prepara e
corta a carne, alguém serve a carne, alguém a come, juntamente com arroz, vinagrete e...cadê a farofa?
Quem ficou de trazer a farofa?
Com base no texto da seção, identifique o que fazer churrascos tem em comum com elaborar programas.
Exercício 1.12 – Outras aplicações

O tipo de visualização descrita no texto pode ser aplicado ao planejamento de um churrasco e ao
desenvolvimento de programas, e certamente há outros contextos em que pode ser útil, como por exemplo
para projetar as possíveis conseqüências de uma decisão. Identifique dois outros contextos ou atividades
em que você poderia utilizá-la para planejar algo ou se antecipar a eventuais problemas. Conclua: você
acha que esta técnica pode ser útil em sua vida, de maneira geral?
Exercício 2.13 – Projetando programas simples

Projete programas que atendam às especificações abaixo. “Execute” o programa para pelo menos 2
entradas diferentes.
a) Lê dois números e calcula o seu produto
b) Lê um número qualquer e informa a metade e o dobro do número lido
c) Lê dois números quaisquer e informa sua soma e sua diferença
d) Lê dois números quaisquer e informa sua soma, diferença, produto e quociente,
formatados com 2 casas decimais
e) Lê um número (suponha que é positivo) e informa seu quadrado, raiz, logaritmo e
exponencial, formatados com 4 casas decimais
Exercício 2.14 - Menu

Desenhe um esquema de tela e um diagrama de blocos para um programa que mostra um menu
centralizado na tela, com as opções abaixo:
Título: Menu Relatórios
Opções: 1 - Por nome, 2 - Por código, 3 - Por data, 4 - Fim
Exercício 2.15 – Projetando programas com decisões

Cada especificação abaixo envolve algum tipo de decisão entre alternativas. Faça projetos para cada uma,
com pelo menos situações que incluam todas as alternativas.
a) Lê um número qualquer e informa se o dobro do número lido é maior do que 100
b) Lê dois números quaisquer e informa se o primeiro é maior do que o segundo
c) Lê dois números quaisquer e informa se o primeiro é maior, igual ou menor do que o segundo
d) Lê um número qualquer e informa se o número lido está no intervalo de 0 a 100
e) Lê um número qualquer e informa se o número lido está nos intervalos de 0 a 10 ou 20 a 30
f) Lê três números e informa qual dos três é o maior
g) Lê a renda de uma pessoa e calcula um imposto, com base na tabela de alíquotas abaixo.
Até 1.200,00 isento
de 1.201,00 a 5.000,00 10%
de 5.001,00 a 10.000,00 15%
acima de 10.000,00 20%
Exercício 2.16 – Projetando programas com repetição

As especificações abaixo contém repetição de comandos. Elabore projetos de tela para cada uma.
a) Mostra os números de 1 até 100 e depois, na linha de baixo, de 100 até 1

b) Lê um número e mostra os números de 1 até o número lido, e em seguida na ordem decrescente
c) Mostra todos os valores pares entre dois números lidos
d) Mostra a quantidade de valores pares entre dois números lidos
e) Lê qualquer quantidade de números e mostra a soma dos números lidos. O último é zero
f) Lê qualquer quantidade de números e mostra sua soma, quantidade e a média aritmética dos
números lidos. O último é zero e não deve ser considerado.
g) Lê uma coluna e, se válida, mostra uma “linha” vertical na coluna lida, desenhada com caracteres
“X”
h) Semelhante ao anterior, mas lê o caractere que é usado para desenhar a linha
Exercício 2.17 - Desenho

Elabore um esquema de tela para a seguinte especificação:
Faça um programa que desenha um "O" na linha 5, coluna 1 e depois faz o seguinte, esperando
uma tecla para cada ação (sempre na linha 5):
apaga o "O" da coluna 1 e o mostra na coluna 2
apaga da coluna 2 e mostra na 3
- apaga da 3 e mostra na 4
E assim sucessivamente até a coluna 15.
.2.5. Visão geral de um programa-fonte
O programa-fonte vai ser um resultado direto do projeto: uma vez que você tenha definido as
operações que serão executadas, vai poder identificar as instruções e comandos da linguagem que vai
precisar. Em alguns casos, é imediato, a uma operação corresponde uma instrução. Em outros, serão
necessárias duas ou mais instruções.
Ao elaborar programas-fonte, segmentamos as ações até atingir um nível em que há algum

comando disponível na linguagem. E em geral, o programa-fonte corresponde a uma segmentação mais
detalhada do projeto: é uma continuação.
As instruções em um programa são bem parecidas com as que você viu na história do robô. Por
exemplo, um programa para cadastro de programas, como o de demonstração desta apostila, tem
comandos na seqüência abaixo, representados na forma de pseudo-comandos (têm uma estrutura e
formato uniforme, mas não são comandos de nenhuma linguagem). Compare com a tela a seguir.
repita
"Limpe a tela"
"Mostre na tela o título do menu"
"Mostre a opção 0 do menu"
"Mostre a mensagem 'Tecle sua opção:' "
"Leia do teclado a opção do usuário"
Se a opção for 1, então ... (comandos para executar a opção)

Senão se a opção for 2, então ...(idem)
Senão se a opção for 3, então ...(ibidem)
até que a opção digitada seja 0.
MENU PRINCIPAL
0 - Termina
1 - Cadastro de programas
2 - Programas por tipo
3 - Programas por categoria
Tecle sua opção: _
Em algumas situações nem a tela nem o diagrama de blocos fornecem pistas para os comandos a
usar. Neste caso, deve-se elaborar um algoritmo, tema de um capítulo próximo.
.2.6. Teste e qualidade de programas
Várias coisas que fazemos tem a característica de, a partir de um objetivo, ir ajustando as ações
até atingi-lo. Ao guiar um carro, por exemplo, fazemos todo o tempo pequenos ajustes no volante. Ao
apertar um parafuso, podemos tentar com uma chave de fenda pequena; se não der, pegamos uma maior
ou aplicamos mais força ou colocamos uma substância viscosa no parafuso, ou todas essas alternativas.
Programar computadores tem muito dessa característica de fazer ajustes, já que dificilmente somos
perfeitos ao elaborar mentalmente os programas.
Por isto, uma das etapas mais importantes da programação é a verificação de que o programa
atende aos objetivos, à especificação. Considerando que fazer produtos de qualidade é essencial para
qualquer pessoa que pretenda ganhar a vida, fazer um nome no mercado, realizar-se e tantas outras coisas
que constituem ideais, qualquer programador deve ter em mente um propósito firme e inabalável de testar
bem seus programas e aperfeiçoar-se cada vez mais nesta habilidade.
Tipos de erros - Vários tipos de erros podem ocorrer em um programa:

• Erros devidos a especificações incompletas ou simplesmente erradas;
• Erros de lógica
• Erros devido à falta de domínio da linguagem de programação. Vão diminuindo com a
experiência;
• Erros acidentais, como por exemplo excluir sem perceber uma linha de código, ao fazer uma
alteração.
O custo da correção de um erro em um programa é tanto maior quanto mais adiantado se está no
desenvolvimento. Para corrigir um erro no papel basta reescrever; corrigir um erro de um programa já
compilado exige muito mais alterações e cuidados; e corrigir erros de um programa já em utilização por
seus usuários pode ser desastroso.
O que é testar - Há várias definições de teste, cada uma adequada a uma finalidade. De forma
geral, todas se referem a medidas de qualidade de programas. Para nossos propósitos introdutórios, a
seguinte definição de teste é satisfatória (Myers, 1979):
Testar é o processo de executar um programa com a intenção de encontrar

erros.
Isto implica que, ao testar um programa, você não estará buscando provar que ele está correto ou
que você é um ótimo programador. Você estará com um espírito "destrutivo", o contrário do que fez ao
elaborar o programa. Mas você só poderá saber o que está errado se tiver uma referência do que é certo, e
esta referência é a especificação e seu detalhamento.
A execução do programa não é necessariamente no computador; na verdade, temos duas etapas

em que se busca a qualidade. A primeira é a verificação manual, feita no papel antes mesmo da digitação,
que pode evitar muito desperdício de tempo, e pode ser feita tanto para os algoritmos quanto para o
programa. A segunda, o teste propriamente dito, é feito no programa executável. Ambos devem ser
preparados; se o projeto foi bem feito, os dados de teste já estarão prontos.
Executar manualmente os rascunhos dos programas não é importante

somente para prevenir erros. Ao fazer isso, você vai estar desenvolvendo a
habilidade de seguir e executar mentalmente as instruções, o que
conseqüentemente melhora a sua própria habilidade de programar.
Uma das vantagens da atividade de programar, em relação a outras, é que está dentro do controle
do programador assegurar que o seu produto está correto. Testar adequadamente seus produtos é a grande
garantia que um estudante pode ter de suas notas, e que um programador profissional pode ter de seu
emprego. Além disso, saber que seu produto final será adequadamente testado permite maior liberdade ao
programador, durante o desenvolvimento, de criar, experimentar e arriscar com tranqüilidade. Veja a si
mesmo como um programador profissional e com programas sendo usados por muitos usuários, e
imagine como poderia variar a qualidade do seu sono, por exemplo, em função de ter ou não segurança a
respeito da correção de seus produtos. Garanta a sua qualidade de vida: teste, teste e teste só mais uma
vez para se certificar, e depois peça a um colega para testar também.
Você pode melhorar ou piorar a qualidade do teste simplesmente em função do que pressupõe ao
fazê-lo. Já presenciei situações (e também as vivenciei!) em que um programa não funciona
adequadamente, e o programador responsável fica estático, dizendo algo como “mas não é possível” ou
“mas o programa está certo!”. A conseqüência de pressupor que o programa está correto normalmente é
o programador ficar sem pontos de partida para descobrir erros. E você pode ter uma certeza: se houver
algum erro no programa, ele aparecerá quando estiver em uso. Por isso:
Ao testar um programa, pressuponha que há pelo menos um erro, e que

você deve encontrá-lo - antes que outro menos indicado o faça.
Um comentário final sobre teste de programas: até que seja executado em um computador, um
programa pode conter problemas que, sem experiência, você dificilmente detectaria. Por exemplo,
suponha que você fez um programa, correto, que simula um caractere se movendo pela tela, da direita
para a esquerda e vice-versa. Ao executá-lo, descobre que o caractere se move tão rápido que mal pode
vê-lo! Precisa então incluir instruções que retardem o movimento para uma velocidade compatível com a
capacidade dos olhos humanos. Por isso, e na opinião deste autor, o conhecimento mais consistente que
você poderá obter não virá somente de livros; virá da prática, dos erros, dos problemas e desafios que
você vencer.
Resumo das diretrizes para testar programas:

• Conscientize-se da importância de testar bem seus produtos.
• Verifique manualmente o programa antes de digitá-lo;
• Ao testar, suponha que há um erro e você tem que descobri-lo;
• Aprenda com os erros;
• Conscientize-se que seu emprego vai depender da qualidade dos seus produtos.
Ao testar seus programas, não se esqueça de aplicar e praticar as diretrizes sugeridas. Produtos de
qualidade atraem valorização profissional e melhores oportunidades, e você pode imaginar o que isso
representa.
.2.6.1 O que testar
O que você procura ao testar programas? O programador é o que melhor conhece os caminhos
internos do programa, e potencialmente é o melhor testador. Alguém que está vendo o programa por fora
vai testar as operações que o programa executa. Veja uma lista genérica:
• Se o programa tem menus, teste o acesso a cada opção e teste cada opção.
• Teste todas as entradas com dados variados, procurando descobrir algo que o programa não
prevê.
• Verifique se as mensagens de orientação estão adequadas.
• Se o programa faz cálculos ou gera informações, confira tudo, confrontando com o resultado
feito de outra maneira: à mão, calculadora ou outro meio.
• Se o programa pede números, entre com letras para ver o que acontece.
• Se o programa indica o que deve ser digitado, digite algo diferente.
• Se o programa repete algo, faça-o repetir muitas vezes mais do que o normal.
• Se o programa grava no disco, elimine seus arquivos (faça um backup antes). Termine o
programa e execute-o novamente, e veja se preservou os dados como deveria.
• Faça perguntas provocativas: "O que pode estar errado?", "Como posso furar este
programa?"
Lembre-se de que a referência principal é a especificação; se ela não prevê validações de entrada
de dados, por exemplo, o programa não estará errado se falhar nisto. E se o programa passar nos testes,
não se esqueça de cumprimentar o programador!
Exercício 2.18 – Revisão

Assinale V ou F:
( ) O teste pode ser considerada a etapa mais importante da programação, já que erros nas etapas
anteriores podem ser percebidos nesta.
( ) Pressupor que o programa possui erros é uma atitude mais eficiente ao se testar programas.
( ) Um programador que testa bem seus programas pode ser mais desejável para uma empresa
do que um que programa mais rapidamente.
( ) Programas podem ser escritos sem erros, mas é mais provável que os contenham.
( ) Verificar manualmente os programas acelera a aprendizagem de uma linguagem de
programação.
Exercício 2.19 – Tipos de erros

Descreva os tipos de erro que podem ocorrer em um programa.
Prática 2.20 – Testando programas

A versão atual do programa de demonstração dessa apostila, "apdemo.exe", não é muito robusta, no
sentido de que não está preparada para alguns tipos de problemas. Teste o programa segundo as
orientações desta seção e descubra pelo menos três desses problemas.
Exercício 2.21 – Treinando a imaginação

Você pode melhorar a sua capacidade de projetar um programa por meio de exercícios em outros
contextos. Para avaliar e praticar essa habilidade, concentre-se nas imagens, sons e sensações sugeridas
abaixo, durante pelo menos 15 segundos cada uma:
a) Imagine uma criança jogando bola
b) Imagine um amigo de infância
c) Imagine uma folha sendo levada pelo vento
d) Imagine alguém sorrindo
e) Ouça o som de uma pessoa caminhando pelo asfalto
f) Ouça sua música favorita
g) Ouça o barulho de um trovão
h) Sinta o calor da água no chuveiro
i) Sinta a areia da praia escorrendo entre seus dedos
j) Sinta o peso dos seus sapatos
k) Sinta o cheiro de peixe frito
l) Sinta o sabor de um cubo de gelo
m) Sinta o cheiro de café novo
n) Sinta o sabor de uma fatia de limão
(Fonte: Ana Maria Rossi, Visualização. Ed. Rosa dos Tempos, 1995)
Exercício 2.22 – Identificando omissões na especificação

Descubra as inconsistências ou omissões nas especificações abaixo:
a) Implementar um programa para resolver o seguinte problema: uma sala tem x alunos e y
alunas. Qual é a idade do professor?
b) Escrever um programa que move um X na tela e para quando alguma tecla for
pressionada.
c) Elaborar um programa que calcule raiz quadrada de números reais.
d) Escrever um programa que limpa e desenha na tela uma linha vertical de tamanho 50,
formada por caracteres '|'.
Exercício 2.23 – Reconhecendo comandos

Observe a tela a seguir e indique os pontos onde houve instruções de saída, de entrada, decisão e quais
instruções estão sendo repetidas.
Cálculo de raiz quadrada de números quaisquer
Digite um número real (0 para terminar): 100

A raiz de 100.00 é 10.00
A raiz de 33.00 é 5.74
Digite um número real (0 para terminar): -4
Número inválido
Exercício 2.24 - Você como líder

Imagine que você é o líder ou coordenador de um projeto, e um programador subordinado a você
entregou um programa aos clientes, e estes reclamaram que alguns itens da especificação não foram
atendidos. O que você faria?
Exercício 2.25 - Caixa automático

Faça um projeto para a especificação abaixo.
Um caixa automático precisa calcular quais e quantas notas devem ser entregues ao cliente para efetuar
a retirada desejada. Faça um programa com opções para:
- Receber notas de 10 e 50 (a quantidade inicial é zero para ambas)
- Ler o valor da retirada e mostrar a quantidade de notas de 10 e de 50 a serem
entregues. Se alguma das quantidades não for suficiente, o programa cancela a operação,
com uma mensagem apropriada
- Apresentar relatório com as quantidades de notas e valor total disponível, e
valor total de retiradas efetuadas.
Exercício 2.26 - Atitudes

Em um ambiente profissional de programação há várias situações que afetam as atitudes do programador.
Analise as situações apresentadas abaixo e vivencie antecipadamente algumas delas (aproveite agora que
as conseqüências são menores!):
a) Suponha, faça de conta ou finja que o programa está correto e faça uma auto-observação:
o que tem vontade de fazer?
b) Agora suponha que há um erro no programa e novamente se observe. Há diferenças?
c) Imagine que você é o programador e que está com o nome meio sujo; seu chefe lhe disse
que mais um programa com erros e... rua! Como acha que procederia neste caso?
Há três formas de um programador não conseguir sucesso: não querer,

não conhecer a linguagem de programação ou não saber o que fazer.
51
.3 O AMBIENTE TURBO PASCAL
Você viu no capítulo anterior que todo profissional deve dispor de várias ferramentas para gerar
produtos de boa qualidade, com boa produtividade. Além das ferramentas intelectuais e emocionais, na
caixa do programador deve haver um bom compilador; além disso, quanto melhor você conhecê-lo,
melhor vai produzir.
Neste capítulo você vai conhecer um pouco do Turbo Pascal 7.0, cuja linguagem e recursos de
programação constituem a base deste trabalho.
.3.1. O Turbo Pascal
O Turbo Pascal é mais do que um simples compilador; é um ambiente integrado de

desenvolvimento. Isto quer dizer que, através de uma única interface, você pode fazer tudo que precisa
para implementar programas. Esse ambiente integrado compreende:
• Editor de textos
• Ajuda on-line
• Compilador
• Depurador (debugger)
• Exemplos
• Extensões da linguagem
Veremos aqui, de forma resumida, um subconjunto apenas das opções do ambiente Turbo Pascal
para DOS, o suficiente para você fazer seus primeiros programas. Nos próximos capítulos serão
apresentados outros comandos e funcionalidades. Como em todo treinamento, é impossível passar todos
os detalhes. O melhor que você pode fazer é "fuçar" de vez em quando nos menus e na ajuda, aos poucos
descobrindo as possibilidades.
.3.2. Instalando o Turbo Pascal
O Turbo Pascal 7.0 é apresentado em dois disquetes. Para instalá-lo, é necessário ter no mínimo
um computador 286 com DOS 3.0 (!) e 6 MB livres no disco, já incluído o espaço de trabalho da
instalação. Você não deve ter problemas se instalar e executá-lo sob Windows.
Para iniciar a instalação, insira o primeiro disquete e execute o programa Install.exe, a partir do
Windows ou do DOS. Se você aceitar o diretório padrão (recomendável), o instalador criará o diretório
(pasta) C:/TP e alguns subdiretórios. Após, selecione a opção Start Installation. Troque o disquete
quando solicitado.
Há três compiladores: TPC.EXE (compilador de linha de comando, para ser usado a partir do
prompt do DOS), TPX.EXE e TURBO.EXE, tendo os dois últimos interface de menus. O TPX contém
alguns recursos adicionais que não são necessários neste curso, cujos programas foram todos testados no
TURBO.EXE. Para informar-se melhor sobre o TPX, execute o arquivo README.COM no disquete de
instalação.
.3.3. Acessando o Turbo Pascal
Para entrar no ambiente integrado, se estiver no DOS ou em uma sessão do DOS no Windows,
digite C:\TP\BIN\TURBO na linha de comando e tecle Enter. Se estiver no Windows, clique em
Iniciar/Executar e faça o mesmo ou, se houver um ícone, clique duas vezes no ícone. Caso contrário,
entre no Gerenciador de Arquivos ou no Windows Explorer, clique na pasta de executáveis do Turbo
Pascal (C:\TP\BIN) e clique duas vezes no arquivo turbo.exe. Você estará na tela do editor de textos. É
aqui que você edita, compila, executa e corrige seus programas, e também onde obtém ajuda através do
help on-line. Se estiver no modo tela cheia (full screen), tecle Alt-Enter para execução em janela.
Para criar um ícone para o Turbo Pascal no Windows, abra o Windows

Explorer, arraste com o botão direito o arquivo executável do Turbo
Pascal (turbo.exe) e solte-o na área de trabalho ou em uma pasta,
selecionando, no menu que aparece, a opção "criar atalho aqui". Outra
forma é clicar com o botão direito na área de trabalho ou área vazia de
uma pasta, selecionar "novo" e "atalho" e digitar o caminho
"c:\tp\bin\turbo.exe" (ou o caminho correto, se diferente do padrão).
A tela contém no alto a barra do menu principal. Se houver alguma janela de texto aberta, a tela
deve estar azul, caso contrário estará hachurada com pontos azuis em fundo branco. Você entra comandos
clicando na barra do menu com o mouse ou através da tecla Alt mais uma letra. Cada programa-fonte
ocupa uma janela de texto; você pode abrir vários programas ao mesmo tempo, um em cada janela, o que
não é recomendado, principalmente quando há mais de uma janela para o mesmo programa. Nas linhas
inferiores da tela você tem ajuda para as teclas de alguns comandos mais usados e eventualmente
mensagens ou orientações.
No centro da linha superior de uma janela de programa fica o nome dele no DOS, isto é, como foi
gravado no disco, mas sem a extensão (".PAS"). Se aparece o nome "NONAME00", a janela é de um
novo arquivo, em branco, criado pelo Turbo Pascal, que você pode usar. Ao salvá-lo pela primeira vez,
você dará o nome adequado.
Prática 3.1 – Visão geral do TP

Dê uma "passeada" pelos menus do editor do Turbo Pascal, apenas para ver o que há por lá, e responda:
a) Em que menu está a opção Destination?
b) Em qual opção do menu Options você configura o diretório onde vão ficar os arquivos executáveis?
.3.4. Editando texto
Familiarize-se com a edição de textos no editor do Turbo Pascal executando as práticas a seguir.
Prática 3.2 – Edição de arquivo novo

1. Criando um novo arquivo - Para iniciar a edição de um programa-fonte, crie um novo arquivo; para
isso, no editor do Turbo Pascal, clique File/New (se já houver uma janela com o nome NONAME00,
não é necessário). Dificilmente você usará este comando. Para criar um novo programa, normalmente
você vai preferir abrir um existente, salvá-lo com outro nome e aproveitar o que puder do texto já
digitado.
3 - O AMBIENTE TURBO PASCAL 53
2. Editando texto - Na janela de texto, você digita seus programas. Digite o seguinte texto ou algum
outro que deseje:
A IBM, na década de 50, era a empresa mais bem administrada do mundo, graças, em
grande parte, ao modelo do lendário diretor-presidente, Thomas J. Watson.
Contaram-me um caso que mostra como Watson reagiu ao saber de um erro
multimilionário de um de seus gerentes regionais. Ele chamou o gerente de vendas
à sua sala para trocar algumas palavras. Quando terminou, o infeliz gerente
sentia-se surrado, mutilado.
Experimente as teclas de edição mais usadas:

setas: movem o cursor uma linha ou coluna de cada vez
PgUp, PgDn: página acima e abaixo
Home: cursor para o início da linha
End: cursor para o fim da linha
Ins: alterna entre inserção/sobreposição de caracteres digitados
Backspace, Delete: apagar caracteres
Ctrl-Y: eliminar a linha do cursor
Alt-Backspace (ou Edit/Undo): desfaz a última edição feita em uma linha
(preciosíssima!)
3. Recuperando texto excluído por engano – Posicione o cursor em uma linha qualquer e exclua-a
teclando Ctrl-Y. Experimente teclar agora Alt-Backspace, para recuperar a linha. Se não funcionar,
verifique em Options/Environment/Editor se a opção "Group Undo" está marcada.
4. Salvando um novo arquivo - Quando for salvar pela primeira vez um programa, você tem que dar
um nome a ele. Clique em File/Save as. Na janela que aparece, digite o nome do arquivo onde será
gravado, que tem um nome-base de até 8 letras e um tipo (extensão) de até 3, separados por um
ponto. Para o nome-base, use até oito letras, números e símbolos, sem espaços (regras do DOS); por
exemplo: WATSON (maiúsculas ou minúsculas, dá no mesmo). Não use asterisco (*), ponto (.),
aspas ("), colchetes ([ e ]), barra vertical (|), contrabarra (\) dois-pontos (:), igual (=), ponto-e-vírgula
(;), soma (+), menor e maior que (< e >), circunflexo (^) e interrogação (?). Já os tipos de arquivos
serão sempre .PAS, e o Turbo Pascal o colocará para você.
Clique em OK para gravar o arquivo.
Salvando arquivos no Windows 95/98:
O Windows 95 possui regras diferentes das adotadas pelo DOS para

diretórios (pastas) e arquivos. Para atender os programas para DOS, ele
define um nome dentro das regras deste. Este nome é que deve ser usado
para se salvar arquivos. Para saber qual é, no Windows Explorer, clique
com o botão direito do mouse na pasta desejada e selecione Propriedades.
O nome está indicado na propriedade "Nome do MS-DOS".
5. Fechando - Para encerrar a edição de um programa, clique no botão situado acima e à esquerda da
janela ou tecle Alt-F3. Sempre feche as janelas de programas que não estiver usando, para evitar
possíveis confusões. Faça isto para o programa que digitou.
Prática 3.3 – Editando um arquivo existente

1. Abrindo um arquivo - Se o arquivo já existe, para modificá-lo você deve abri-lo, isto é, carregá-lo
do disco para a memória. Se não houver nenhuma janela de programa aberta, o menu File mostra uma
lista dos últimos arquivos abertos; se o que você quer aparece na lista, basta clicar no nome para abri-
lo.
Para abrir um arquivo, clique em File/Open ou F3. Na janela que aparece, no campo "Name", digite
o nome do programa que quer abrir, neste caso WATSON. Opcionalmente você pode clicar no nome
do arquivo desejado, na lista de arquivos. Neste, o símbolo "..\" quer dizer "o diretório acima". Uma
vez selecionado o arquivo, clique em Open para abrir. Outros arquivos abertos permanecem à
disposição; basta selecionar o desejado no menu Window, opção List. Ou clique na janela desejada
para ativá-la.
Para não ter que localizar o diretório correto todas as vezes em que for
abrir um arquivo, no início de uma sessão clique em File/Change Dir e
configure o diretório desejado.
2. Após abrir o arquivo, complete a digitação iniciada anteriormente, de forma que o texto fique assim:
A IBM, na década de 50, era a empresa mais bem administrada do mundo, graças,
em grande parte, ao modelo do lendário diretor-presidente, Thomas J. Watson.
Contaram-me um caso que mostra como Watson reagiu ao saber de um erro
multimilionário de um de seus gerentes regionais. Ele chamou o gerente de vendas
à sua sala para trocar algumas palavras. Quando terminou, o infeliz gerente
sentia-se surrado, mutilado.
O senhor está me dizendo que quer que eu vá embora? – o gerente perguntou.
- Ir embora? – Watson retrucou, atônito: - De maneira alguma! Imagine, gastei
mais de um milhão de dólares para treiná-lo!
(Charles Wang)
3. Salvando um arquivo existente - Após fazer as alterações, e como o arquivo já tem nome, clique em
File/Save para gravar no disco as alterações. Alternativamente, tecle F2. Se for um arquivo novo
("NONAMEnn"), o editor abrirá a janela do salvar como e você deverá dar um nome ao arquivo.
Salve freqüentemente seu trabalho; coisas misteriosas podem acontecer e

fazê-lo perder precioso tempo de digitação. Computadores que falham ou
travam, programas que não terminam... Fato que presenciei (mais de uma
vez): em um laboratório de informática, uma tomada com mau contato
ligava quatro computadores. Alguém bateu o pé nela e desligou por um
breve e fatal momento os computadores. Outro: alguém terminou o
trabalho e, desatento, desligou o computador... do vizinho! Para não
parecer que estou exagerando: da última vez, alguém inseriu um disquete
no micro do vizinho e pressionou o botão de reset!
Prática 3.4 – Comandos úteis

Experimente outros comandos úteis do menu Window – abra várias janelas de edição e tente alternar
(F6), Dividir (Tile) e os demais.
Prática 3.5 – Impressão de programa-fonte

Você pode imprimir um programa-fonte das seguintes maneiras (experimente cada uma):
a) No Turbo Pascal - Selecione a janela do programa digitado e clique em File/Print para imprimi-
lo. Nesta opção de impressão as palavras reservadas e outros elementos da sintaxe são
destacados, o que pode ser útil ao leitor.
Para imprimir um arquivo, o Turbo Pascal usa um programa chamado PRNFLTR.EXE. Se tiver
problemas, pode ser que ele não esteja no diretório \TP\BIN ou o caminho para este não esteja no
PATH do arquivo autoexec.bat do DOS (que fica no diretório raiz do disco rígido).1
Se tiver problemas na impressão através do Turbo Pascal (como um monte de folhas saindo da
impressora), tente alterar a configuração, em File/Printer Setup, para /HP ou desmarcando o
opção de enviar os caracteres de formatação.
b) A partir do Bloco de Notas – Abra o programa-fonte e imprima-o, lembrando que o Bloco de
Notas usa a impressora padrão do Windows.
c) A partir do Word ou do WordPad – Abra o fonte e imprima-o normalmente. Para preservar a
formatação original, selecione todo o texto e altere a fonte para um não proporcional, como
Courier.
d) No DOS Shell – Entre no DOS Shell (veja à frente neste capítulo) no menu Arquivo e digite
Print <nome do arquivo>. Isto só funciona se o DOS foi instalado. Alternativamente, tente
comandar copy <nome do arquivo> prn.
.3.5. Alternativas para obter ajuda
Você pode acessar a ajuda on-line de várias formas. Com F1 você tem ajuda sobre a janela de
edição. No menu Help, há várias alternativas: Contents (estruturado), Index (alfabético) e até ajuda para
a ajuda. Um dos mais usados é a ajuda sensível ao contexto. Execute as práticas desta seção e veja como
funciona cada tipo.
Prática 3.6 – Ajuda sensível ao contexto

Escreva a palavra ClrScr em qualquer janela de texto e tecle Ctrl-F1. Rapidamente aparece na tela a
descrição da instrução, a unit que a contém, um programa exemplo e outras informações. Digite a palavra
"unit" e faça aparecer o respectivo texto de ajuda. Leia apenas como curiosidade, por enquanto.
Prática 3.7 – Ajuda para os menus

Clique na opção Window do menu. Com a seta e não com o mouse, indique a opção Tile. Pressione F1
para obter ajuda sobre esta opção. Faça o mesmo para a opção Window/Close. Novamente obtenha ajuda
para a opção File/Dos shell.
Prática 3.8 – Conteúdo

Clique em Help/Contents. Você vê uma lista de tópicos de ajuda. Dê uma olhada na lista, depois
selecione o item Menus and hot keys. Mais abaixo você verá uma lista de subtópicos que podem ser
selecionados.
Prática 3.9 – Índice

Para acessar uma lista de tópicos de ajuda em ordem alfabética, clique em Help/Index. Tecle a primeira
letra da palavra desejada para deslocar-se rapidamente para a seção da letra. Por exemplo, para ver uma
lista de nomes de cores usadas em certas instruções de tela, tecle "Y" e <tab> até o cursor chegar na
palavra Yellow. Clique duplo ou tecle Enter para ver o texto.
Prática 3.10 – Descobrindo outros comandos

Usando o help de conteúdo, procure a lista de comandos do editor de textos e preencha a tabela abaixo:
1
Quando nem isto funcionou, criei um arquivo de comandos do DOS que ajustava o PATH e configurei o campo
"arquivo de lote" da guia Programa do turbo.pif (o Windows usa os .pif para configurar programas DOS), para
executá-lo antes.
COMANDO DO EDITOR TECLAS

Copiar para a área de transferência
Shift-Del
Colar da área de transferência
Selecionar texto Shift + tecla de movimento do cursor
Localizar texto
Ctrl-L
Inserir uma linha em branco no modo de inserção
Inserir uma linha em branco no modo de sobreposição
.3.6. O DOS Shell: um pouco de MS-DOS
Se você tem menos que vinte e poucos anos, talvez tenha apenas uma idéia vaga do que é o DOS.
Antes do Windows, ele foi o sistema operacional padrão para os PCs. Executa apenas um programa de
cada vez e não possui interface gráfica. Os comandos são digitados na linha de comando, na qual são
indicados (normalmente) o drive e o diretório atualmente selecionados, como por exemplo:
C:\WINDOWS>_
A contrabarra indica o diretório raiz, e este texto é chamado de prompt do MS-DOS, daí o nome
da opção de abrir uma sessão DOS a partir do Windows.
Os comandos são constituídos de uma palavra seguida de parâmetros. Por exemplo, para alterar o
diretório corrente, você deve digitar CD (de change dir) seguido do nome do diretório, e depois teclar
Enter:
C:\WINDOWS>CD \TP
Se o diretório desejado está abaixo ou é filho do corrente, basta digitar seu nome:
C:\TP> CD BIN
Cada comando do DOS tem sua própria sintaxe. Se o seu computador tem o DOS instalado, você
pode obter ajuda digitando HELP seguido do nome de comando.
A partir do Turbo Pascal, você pode acessar a tela do DOS a qualquer momento através da opção
File/Dos shell do menu. Ao clicar essa opção, você vê a tela DOS normal, com o prompt esperando um
comando. O Turbo Pascal continua na memória. Para confirmar isso, digite exit seguido da tecla Enter:
você volta para o Turbo Pascal, do mesmo jeito que estava quando você saiu.
Vá ao DOS shell, e tecle DIR, seguido de Enter. Você verá uma listagem dos arquivos gravados
no diretório atual. Entre outras coisas, e com algumas diferenças (mais ainda se estiver no Windows),
você deve ver:
WATSON PAS 200 07-31-97
WATSON BAK 37 07-31-97
O primeiro arquivo é um arquivo editado normalmente pelo Turbo Pascal: nome, tamanho em
bytes e data da última gravação. O segundo é a versão anterior do primeiro. Quando você salva um
programa, o Turbo Pascal renomeia a cópia que está no disco para .BAK, e grava a que está na memória
com a extensão .PAS. Se você perder algum programa, a primeira coisa a tentar é ir ao DOS shell,
renomear o .BAK para .PAS (após excluir o antigo) e recuperar o que puder.
Veja exemplos de outros comandos do DOS e suas opções, que você pode precisar:
dir *.pas (listar todos os arquivos com extensão .pas)
dir meu*.* (listar todos os arquivos começados com "meu")
dir meu*.pas (listar todos os arquivos começados com "meu" e
com extensão .pas)
rename nomeant.ext novonome.ext (mudar o nome do arquivo nomeant.ext para
novonome.ext)
copy nome.pas outnome.pas (criar um arquivo chamado outnome.pas, copiando o
conteúdo de outro arquivo chamado nome.pas)
del nome.pas (excluir o arquivo chamado nome.pas)
del *.bak (excluir todos os arquivos com extensão .bak)
del *.* (excluir todos os arquivos do diretório corrente -
cuidado!)
print nome.pas (imprimir)
md nomedir (criar um subdiretório chamado nomedir)
rd nomedir (excluir o diretório nomedir, se estiver vazio)
cd nomedir (mudar o diretório corrente para nomedir)
Lembre-se: para voltar ao Turbo Pascal, digite exit. Se digitar novamente turbo, você pode ter
problemas.
Prática 3.11 – Como recuperar arquivos

Edite um arquivo qualquer, e salve-o pelo menos duas vezes (para que seja criado o .bak). Vá ao DOS
Shell, delete o arquivo com tipo .PAS. Renomeie o .BAK para ter o mesmo nome mas extensão .PAS.
Volte ao Turbo Pascal e abra o arquivo novamente, e veja se está intacto.
Prática 3.12 – Praticando comandos de diretórios

No DOS Shell, mude o diretório corrente para o raiz (\). Crie um diretório com seu nome. Mude para este,
e dentro dele, crie um diretório para esta disciplina. Mude para este e dentro dele crie diretórios para
trabalhos, chamados TRAB1 e TRAB2. Agora remova todos os diretórios criados.
Lembre-se: "passeie" pelos menus e pela ajuda de vez em quando; você

descobrirá recursos úteis e muitas vezes salvadores.
58
.4 PRIMEIROS PROGRAMAS
“O computador faz o que você manda, não o que você quer”
Programas de computador são essencialmente um mecanismo de causa e efeito: você quer um

efeito, programa uma causa. Nesse sentido, só existem resultados: o programador obtém o que foi
programado. Neste capítulo, você dará os primeiros passos para fazer algo acontecer no computador,
escrevendo, compilando e executando pequenos programas em linguagem Pascal.
.4.1. Primeiras instruções
Prática 4.1 – Primeiro programa

a) Abra o Turbo Pascal e digite o programa abaixo. Para o alto da cabeça, use a barra de sublinhado,
e para a parte de baixo, use o hífen.
PROGRAM Careta;
{Feito por Virgílio V. Vilela}
uses CRT;
begin
ClrScr;
Writeln('Este programa simples desenha uma careta na tela.');
Writeln('Pressione qualquer tecla para ver a careta');
Readkey;
Writeln(' ____');
Writeln(' / \');
Writeln('/ O O \');
Writeln('\ ^ /');
Writeln(' \ ~ /');
Writeln(' ----');
Writeln;
Writeln('Pressione qualquer tecla para terminar o programa');
Readkey;
end.
Um programa escrito em uma linguagem de alto nível é um texto, que é

chamado de programa-fonte ou código-fonte.
b) Como o computador não entende Pascal, é preciso converter o texto para linguagem de máquina,
ou seja compilá-lo. Após salvar o arquivo, clique em Compile/Compile ou tecle Alt-F9. Deve
aparecer uma janela parecida com a abaixo. Se aparecer alguma mensagem no alto da tela,
verifique se digitou o programa exatamente como está.
5 - PRIMEIROS PROGRAMAS 59
+----------------- Compiling ------------------+

¦ ¦
¦ Main file: CARETA.PAS ¦
¦ Done. ¦
¦ ¦
¦ Destination: Memory Line number: 0 ¦
¦ Free memory: 239K Total lines: 19 ¦
¦ ¦
¦ ¦
¦ Compile successful: Press any key ¦
+----------------------------------------------+
No Turbo Pascal, não é necessário comandar a linkedição, que é feita de
forma automática.
c) Instruções são inertes se não forem executadas. Dê vida ao programa clicando em Run/Run ou
tecle Ctrl-F9 para executá-lo. Siga as instruções na tela.
Seção de Comentário
cabeçalho (ignorado na
PROGRAM CARETA; compilação)
{Feito por Virgílio V. Vilela}
Seção de
declarações uses CRT; Limpa a tela e posiciona o
cursor no canto superior
esquerdo (vem de "Clear
begin
ClrScr; Screen)
Início da
seção de
comandos
Writeln('Este programa desenha uma careta na tela.');
executáveis Writeln('Pressione qualquer tecla para ver a careta');
Readkey;
Writeln(' ____'); ponto-e-vírgula: fim
Writeln(' / \'); de um comando
Writeln('/ O O \');
Writeln('\ ^ /');
Writeln(' \ ~ /');
Writeln(' ----');
Writeln; Espera uma tecla
Fim dos Writeln('Pressione qualquer tecla para terminar o programa');
comandos ser pressionada
executáveis para prosseguir
Readkey;
(ponto: fim end.
do programa)
Causa problemas não saber:

PROGRAM, begin e end são palavras reservadas; tem um significado para o compilador, e você
não pode usá-las para outra finalidade.
ClrScr, Writeln e ReadKey são identificadores padrão: podem (mas não convém) ser usados para
outras finalidades.
PROGRAM é uma palavra que inicia um programa-fonte. É opcional, mas se você colocar
PROGRAM deve por depois o nome e o ponto-e-vírgula.
Ao final de todo comando ou declaração deve ter um ponto-e-vírgula, exceto antes de end.
O nome do programa é criado por você, seguindo algumas regras:
- deve começar com uma letra
- a partir do segundo caractere, pode conter letras, dígitos ou barra de sublinhado (_), ou seja, não
pode conter espaços
- não há distinção entre maiúsculas e minúsculas (MeuPrimeiro é o mesmo que mEUpRIMEIRO que
é o mesmo que mEupRImeIRo)
- não são permitidas letras acentuadas
Exemplos de nomes válidos de programas: CalculaFatorial, Calc_Dobro_versao_2, emite_som.
Nomes inválidos que impedem a compilação: Calcula Fatorial, 2_Calc_Dobro, EmiteSom!
Exercício 4.2 – Regras para nomes

Assinale os nomes de programas válidos no Pascal:
a) controla_compromissos
b) agenda diária
c) Agenda_v3
d) eMiTeSOm
e) CalcDobroNum
f) v2_SomCrescente
Exercício 4.3 - Program

Escrever a declaração PROGRAM, usando nomes significativos, para os programas abaixo:
a) Pondera notas de listas de exercícios e calcula nota final
b) Controla CDs
c) Gera lista de compras
d) Guarda nomes e telefones
e) Imprime etiquetas de endereçamento
f) Simula um X movendo-se pela tela
g) Converte graus Celsius em graus Fahrenheit
h) Converte graus Celsius em graus Fahrenheit e vice-versa
A declaração PROGRAM é opcional, mas é bom colocá-la para uma

melhor documentação do programa. Nada de nomes como Cesar_1, XYZ
ou Smurfette (este eu vi!); o nome deve dar uma boa idéia do que o
programa faz.
Prática 4.4 – Erros de sintaxe

A sintaxe das linguagens de alto nível é muito mais rígida que a de uma linguagem comum, como o
português. Qualquer palavra fora do lugar adequado ou um símbolo que não faça parte do alfabeto (erro
de sintaxe) impedem a conversão de um programa. Por exemplo, se a sintaxe prevê que um ponto-e-
vírgula deve aparecer no fim de um comando, você deverá inseri-lo. O compilador detecta a ausência,
mas jamais colocará o ponto-e-vírgula para você.
A compilação é feita de cima para baixo, começando na palavra PROGRAM e terminando no ponto após
o end. Cada vez que encontra um erro de sintaxe, o compilador interrompe a compilação e mostra uma
mensagem de erro na primeira linha da tela de edição (em alguns casos, embaixo). Para conhecer melhor
as mensagens do compilador, faça as modificações abaixo, uma de cada vez, e compile (para desfazer use
Alt-Backspace). A cada erro, indique o código de erro de compilação e tecle F1 para ver mais
informações sobre a causa.
a) Troque PROGRAM por PROGRAMA
b) Insira um espaço no meio do nome do programa: CAR ETA
c) Tire o ponto-e-vírgula após CARETA
d) Tire o begin
e) Tire o primeiro apóstrofo de um Writeln
f) Tire o último apóstrofo de um Writeln
g) Tire o end
h) Tire o ponto final
i) Coloque um ponto no meio do programa
Para obter maiores informações sobre um erro de compilação, tecle F1

enquanto a mensagem de erro estiver sendo mostrada.
Prática 4.5 – Finalidade das cores do texto

Observe na tela que as cores das palavras têm diferenças: o editor identifica o tipo de cada uma, conforme
a sintaxe da linguagem e altera sua cor. Esse recurso ajuda a identificação de erros de digitação. Por
exemplo, retire o fecha-chave do comentário e veja o que acontece.
Prática 4.6 – Tela Turbo e tela DOS

a) Você viu anteriormente que no Turbo Pascal há duas telas: a do próprio TP e a do DOS, que é
onde aparecem as saídas dos programas. A tela DOS fica em segundo plano; para vê-la estando
em modo de edição, tecle Alt-F5. Dê uma olhada e pressione qualquer tecla para retornar.
b) No programa CARETA, retire ou comente o último comando antes do end (assim: {ReadKey}).
Compile, execute e veja a diferença. Tecle Alt-F5 para ver a tela DOS.
c) Você pode ver as duas telas ao mesmo tempo, embora menores: clique em Debug/Output. Para
dividir a tela em duas janelas que não se sobrepõem, clique em Window/Tile.
Prática 4.7 - Onde está o programa executável?

O destino da compilação pode ser a memória ou o disco. Quando compila para disco, o compilador cria
um arquivo no disco com o mesmo nome do arquivo do fonte (e não o nome da declaração PROGRAM)
e extensão .EXE. Esse executável é independente do compilador você pode executá-lo diretamente do
DOS ou Windows, conforme o caso, copiá-lo para um disquete e dar de presente, renomeá-lo, etc.
A compilação com destino memória não cria um executável em disco; ele permanece na memória. Se
você sair do Turbo Pascal não poderá executá-lo. Essa é a opção mais usada, já que você normalmente
compila, executa e testa várias vezes, e somente quando concluir os testes é que talvez vá querer um
executável permanente.
Indique o destino da compilação na opção Compile/Destination do menu (se você estiver usando o
compilador tpx.exe esta opção não está disponível). Por default (valor assumido se você não informar
nada), a compilação é para a memória. Se tiver dúvidas sobre qual opção está selecionada, veja na janela
de sucesso da compilação o destino atual.
a) Clique em Compile/Destination para alternar o destino da compilação para disco. Se já estiver,
não faça nada, apenas cancele o menu teclado ESC ou clicando fora dele.
b) Você pode definir o diretório onde ficarão os arquivos executáveis; clique em Options/Directories
e indique um caminho.
Se você estiver em uma rede, pode ser que necessariamente tenha que
informar em Options/Directories, campo EXE & TPU Files, uma pasta
onde tenha autorização para gravar. Você deve informar o nome DOS; o
Turbo Pascal não vai reconhecer o nome do Windows. Para saber qual é o
nome DOS, vá no Windows Explorer, clique com o botão direito na pasta
e selecione Propriedades.
c) Compile o programa. Note que na janela que informa o sucesso da compilação consta o destino.
d) Acesse o DOS Shell (no menu File), altere o diretório corrente para o que você especificou na
letra c) e peça a listagem do conteúdo ("DIR"). Verifique que foi criado um arquivo executável
com o mesmo nome do programa-fonte. Execute o programa digitando seu nome e Enter.
Prática 4.8 - Executando o programa fora do Turbo Pascal

a) Após executar a compilação para disco, vá no Windows e ache o executável. Dê um duplo clique
nele para executá-lo. Você pode também arrastá-lo para o Ambiente de Trabalho e criar um
atalho para ele; é um executável DOS como os outros.
b) Agora copie o executável para um disquete e execute-o de lá.
Prática 4.9 – Onde posso por comentários?

Inclua os comandos abaixo em um programa de teste e indique quais compilam normalmente:
a) PROGRAM {comentários} MeuPrimeiro;
b) PROGRAM MeuPrimeiro {comentários};
c) Write{comentários}('texto');
d) Write('texto'{comentários});
e) Wri{comentários}te ('texto');
Para registrar comentários você pode usar, ao invés das chaves, os

símbolos (* para abrir um comentário e *) para fechá-lo.
.4.2. Mais de Write
Prática 4.10 – Write

Altere o programa CARETA, tirando os "ln" de cada Writeln. Execute-o e veja na tela o que mudou.
Write, Writeln e o cursor

A tela, em modo texto padrão, é estruturada em 25 linhas e 80 colunas, e há um cursor (_) piscando
em alguma posição. A instrução Write começa a mostrar sua saída exatamente na posição atual do
cursor; quando termina, o cursor está na coordenada que segue o último caractere mostrado. Por
exemplo, se o cursor estiver no canto superior esquerdo da tela, e for executada a instrução
Write('Teste da posição do cursor');
a palavra 'Teste' começará a ser mostrada no canto superior esquerdo e, após a execução, o cursor
estará logo após o “r” da palavra “cursor”.
Se o cursor estiver na última linha da tela, e uma instrução Writeln for executada, seu parâmetro será
mostrado nessa linha e todo o conteúdo da tela será movido uma linha para cima e uma linha em
branco será inserida na parte inferior da tela, sendo portanto perdida a linha no alto.
Posição do cursor
após Write
Teste da posição do cursor_

_
Posição do cursor
após Writeln
O texto que está dentro dos parênteses após um Write ou um Writeln é

uma informação que a instrução precisa receber para cumprir sua
finalidade, que é mostrar essa informação na tela; é chamado parâmetro.
Prática 4.11 – Write e os espaços

Sobre o comportamento da instrução Write com relação a espaços (brancos), faça programas que
esclareçam:
a) Espaços (brancos) fora dos apóstrofos fazem diferença? Por exemplo, há diferença entre
os comandos Write('X X') e Write ( 'X X' )?
b) Como fazer para inserir alguns espaços antes do primeiro X do comando acima, na tela,
ou seja, quando a instrução for executada?
c) Um texto dentro de um Write pode continuar em outra linha, ou seja, a apóstrofo inicial
em uma linha e o apóstrofo final na outra?
Prática 4.12 – Maiúsculas e minúsculas

Execute o programa de teste abaixo (se desejar, substitua o texto por algum que prefira).
PROGRAM TesteMaiuscMinusc;
uses CRT;
begin
ClrScr;
Writeln('texto em minúsculas');
Writeln('TEXTO EM MAIÚSCULAS');
Writeln('tExTo VaRiAdO');
ReadKey;
end;
Apóstrofos
A função dos apóstrofos é indicar ao compilador que o parâmetro é uma cadeia de caracteres e deve
ser mostrada exatamente como está escrita. Ou seja, ao contrário das palavras reservadas e
identificadores padrão, no caso de cadeias de caracteres o compilador distingue maiúsculas e
minúsculas; ele não vai criticar o que estiver delimitado pelos apóstrofos.
Prática 4.13 – Identifique a saída

Faça um esquema da tela de saída que será gerada pelo programa abaixo. Depois execute-o e verifique
sua resposta (as instruções estão misturadas para não ficar tão fácil):
PROGRAM QualASaida;
uses CRT;
begin
ClrScr; Writeln; Write('X X' ); Writeln('X X' ); Write('XXXXX' );
Write('X X' ); Writeln('X X' );
end.
Prática 4.14 – Seguir programa

“Execute” manualmente o programa abaixo e faça um esquema da tela resultante (considere os pontos
como espaços, são apenas para indicar sua quantidade). Depois, digite, compile e execute-o,
comparando o resultado obtido com o resultado previsto.
PROGRAM DesenhaAlgo;
uses CRT;
begin
ClrScr; Writeln; Writeln ('#####'); Writeln('..#..');
Writeln('..#..'); Writeln('..#..'); Writeln('..#..');
end.
Prática 4.15 – Pulando linhas com Writeln

Se você quer que algo apareça na tela, esse algo deve estar dentro dos parênteses de um comando Write
ou Writeln. Se omitir um dos parênteses, o programa não será compilado. Mas você pode omitir ambos;
neste caso o resultado da execução será mover o cursor para a linha de baixo. Podemos usar essa
característica para pular linhas (ou para posicionar o cursor no início de uma linha).
Faça um esquema da tela de saída do programa abaixo: Depois digite e execute o programa e veja se
acertou:
PROGRAM QualASaida;
begin
Writeln('Isto está em uma linha');
Writeln;
Writeln('Há uma linha em branco acima desta');
end.
Prática 4.16 – Cadeias são diferentes de números

Digite o programa de demonstração abaixo e veja o que aparece na tela para cada Writeln. A tela deve
resultar como ao lado. Depois veja as explicações adiante.
PROGRAM DemoNumeros;
uses CRT;
begin
ClrScr; 1234
Writeln('1234'); 1234
Writeln( 1234 ); 1.2340000000E+03
Writeln( 1234.0 ); 1.2340000000E+03
Writeln( 1234.0:30 ); 1234.00
Writeln( 1234.0:30:2 ); 1234.00
Writeln( 1234.0: 0:2 );
ReadKey
end.
Números e cadeias de caracteres

O compilador trata números de maneira diferente de cadeias de caracteres: do ponto de vista do
compilador, 1234 é um número, enquanto que '1234' é uma cadeia de caracteres, mesmo sendo
formada só por dígitos.
Números inteiros também são tratadas de forma diferente de números reais. Estes são números com
casas decimais, que são separadas da parte inteira por um ponto.
Números reais são mostrados na tela em notação científica (por exemplo, 1.214x10 3 , sendo o "10
elevado a" representado como a letra E), podendo ser indicadas a quantidade de colunas da tela que
vão ser usadas e a quantidade de casas decimais
PROGRAM DemoNumeros; {explicações}
uses CRT;
begin
ClrScr;
Writeln('1234'); {cadeia de caracteres}
Writeln( 1234 ); {número inteiro}
Writeln( 1234.0 ); {o ponto torna o número real, que é mostrado em
notação científica}
Writeln( 1234.0:30); {indica que é para usar 30 colunas da tela. O
número é alinhado à direita dentro das 30 colunas}
Writeln( 1234.0:30:2 ); {usar 30 colunas como acima, e 2 casas decimais.
Evita a notação científica}
Writeln( 1234.0: 0:2 ); {o zero quer dizer que a quantidade de colunas não
está definida, e o número é mostrado a partir da
posição do cursor}
ReadKey
end.
Prática 4.17 - Inteiros com decimais pode?

Verifique se o comando a seguir, que tenta mostrar um inteiro com casas decimais, compila:
Write(1214:10:2);
Você pode indicar a quantidade de colunas também para cadeias de

caracteres. Por exemplo, para deslocar o cursor vinte colunas, depois
mostrar 'Nome' alinhado à direita em 15 colunas, escreva:
Write(' ': 20, 'Nome':15);

Exercício 4.18 – Revisão de Write com números

Assinale V ou F conforme as afirmativas seja verdadeiras ou falsas:
( ) Números como parâmetros em uma instrução Write não precisam estar entre
apóstrofos.
( ) Números reais são mostrados na tela em notação científica, a menos que seja
indicada outra formatação.
( ) A instrução Write permite vários parâmetros, desde que separados por vírgulas,
mas é melhor usar essa característica quando os parâmetros são de tipos diferentes.
( ) Formatação de quantidade de casas decimais, na instrução Write, não é permitida
pelo compilador para parâmetros que não sejam reais.
Especificação 4.19 – Treinando Write/Writeln

Escreva um programa Pascal com instruções Write ou Writeln que produzam a seguinte tela:
EEEEE
E
EEE
E
EEEEE
Pressione uma tecla para terminar.
Múltiplos parâmetros de Write e Writeln

As instruções Write e Writeln aceitam múltiplos parâmetros, desde que separados por vírgulas. Por
exemplo, a instrução
Write('Esta é uma cadeia', ' E esta é outra cadeia', ' Pode ter uma terceira');
produz na tela a saída

Esta é uma cadeia E esta é outra cadeia Pode ter uma terceira_
Esta característica será mais útil quando quisermos mostrar na tela informações de tipos diferentes,
mesclando cadeias, números e outros elementos que veremos.
Especificação 4.20 – Etiqueta na tela

Elabore um programa que escreve seu nome completo em uma linha, seu endereço na próxima e na
seguinte o CEP e telefone.
Especificação 4.21 - Frases assassinas

Faça um programa que mostra na tela algumas frases assassinas, que são aquelas que fazem com muitas
idéias sejam perdidas antes que amadureçam ou seja aprofundadas. Eis alguns exemplos (bole também os
seus):
"Isto não vai dar certo"
"Você nunca vai conseguir"

"Você vai se estrepar"
"Não vai dar em nada"
"Está tudo errado!"
Especificação 4.22 - Mensagem

Escreva uma mensagem para uma pessoa de que goste. Implemente um programa que mostra na tela essa
mensagem.
Especificação 4.23 - Ao mestre

Escreva um bilhete ao seu professor, informando seus objetivos nesta disciplina e o que espera dela e do
professor. Implemente um programa que mostra seu bilhete na tela.
Especificação 4.24 – Tabela de notas

Escreva um programa que produza a seguinte saída na tela:
ALUNO(A) NOTA
======== =====
ALINE 9.0
MÁRIO DEZ
SÉRGIO 4.5
SHIRLEY 7.0
Especificação 4.25 – Letra grande

Elabore um programa para produzir na tela a letra X usando a própria. Se fosse ‘L’, seria assim:
L
L
L
L
L L L
Especificação 4.26 – Palavra grande

Escreva um programa que produza a tela esquematizada abaixo:
******** ******** *
* * * *
* * * *
******** * * *
* * * *
* * * *
******** ******** ********
Especificação 4.27 – Emoticons

Emoticons são seqüências de caracteres que mostram rostos e expressões, vistos de lado e usados
freqüentemente em correios eletrônicos e bate-papos na Internet. Existem dezenas; veja alguns:
:-) sorriso
:-( tristeza
:-p mostrando a língua
:-o espanto
{:-) cabelo partido ao meio
:-{ usa bigode
:-* beijo
:-**** um monte de beijos
Elabore um programa que mostre na tela os emoticons, um em cada linha, com a descrição de cada um.
Especificação 4.28 – Pinheiro

Implemente um programa que desenhe um "pinheiro" na tela, similar ao abaixo. Enriqueça o desenho
com outros caracteres, simulando enfeites.
X
XXX
XXXXX
XXXXXXX
XXXXXXXXX
XXXXXXXXXX
XXXXXXXXXXXX
XXXXXXXXXXXXXX
XX
XX
XXXX
Especificação 4.29 – Pinheiro v2

Elabore uma versão 2 do programa do item anterior que desenhe o pinheiro com asteriscos (*). [Dica:
use o recurso de localização/substituição do editor para fazer a substituição rapidamente]
.4.3. Turbo Debugger
Um debugger ou um depurador é um programa que permite a execução gradativa e controlada de

um programa, mediante comandos do programador pelo teclado, sendo a sua ferramenta mais valiosa,
depois do cérebro. O Turbo Debugger acompanha o Turbo Pascal, e permite que um programa seja
executado uma linha de cada vez.
Prática 4.30 - Execução linha-a-linha usando o debugger

a) Para começar, execute manualmente o programa abaixo e faça um esquema da sua tela de saída.
PROGRAM QuadradoComX;
{Mostra na tela um quadrado feito com letras X.
Feito por Fulano de Tal, em 11/11/99}
uses CRT;
begin
ClrScr;
Writeln( 'XXXXX' );
Writeln( 'X X' );
Writeln( 'X X' );
Writeln( 'X X' );
Writeln( 'XXXXX' );
end.
b) Agora digite, compile e execute o programa, comparando a tela obtida com a prevista.
c) Agora vamos executar o programa usando o debugger. Com a janela do programa-fonte ativa,
tecle F7. Isto inicia o debugger e a execução linha-a-linha. Uma barra horizontal surge na tela,
posicionada sobre o begin. Essa barra indica qual será a próxima linha de instruções que será
executada. Tecle F7 novamente. A barra estará sobre o ClrScr. A próxima operação a ser efetuada
é limpar a tela. Qual tela? Bem, a tela do seu programa não está aparecendo; você está no editor.
Para ver a tela de saída do seu programa, tecle Alt-F5. Tudo que o seu programa fizer vai
aparecer aí. O que você vê agora, antes da execução da primeira instrução, é a tela DOS,
contendo o que aconteceu antes de você entrar no Turbo Pascal ou o resultado do último
programa executado. Tecle qualquer coisa para voltar ao programa-fonte.
d) Tecle de novo F7, para executar o primeiro Writeln, e novamente Alt-F5. Veja o que houve na
tela DOS e tecle algo para retornar.
e) Novamente F7, para executar o próximo Writeln. Veja o que apareceu na tela.
f) Continue teclando F7, até chegar ao end.
Observe que a figura foi construída na tela uma linha de cada vez na seguinte seqüência:
XXXXX XXXXX XXXXX XXXXX XXXXX
X X X X X X X X
X X X X X X
X X X X
XXXXX
Usar o debugger não é útil somente para encontrar erros, mas também
para você ver as instruções funcionando e assim aprender mais
rapidamente.
Prática 4.31 – Mais debugger

Execute o programa Careta usando o debugger.
.4.4. Expressões aritméticas
Prática 4.32 – Fazendo cálculos

Digite o seguinte programa:
PROGRAM DemoExpressoes;
uses CRT;
begin
ClrScr;
Writeln( 1234 + 1000 ); {expressão aritmética com adição}
Writeln('1234 + 1000'); {não é expressão, é uma cadeia }
Writeln('1234 + 1000 = ', 1234 + 1000);
Writeln( 1234 - 1000 ); {subtração}
Writeln( 1234 * 1000 ); {multiplicação}
Writeln( 1234 / 1000 ); {divisão - resultado é real}
Writeln( 54*13 - 37/11 + 23/5); {expressões aritméticas combinadas -
primeiro * e /, depois, + e - }
Writeln( -43/5 + 12*34 ); { o - inverte o sinal}
Writeln( (1290 + 155) * (980 - 32) ); {primeiro é calculado o que
está entre parênteses}
Writeln( -43/5:10:2); {formatando o resultado real}
ReadKey
end.
Pascal e matemática
No Pascal você pode efetuar operações matemáticas de forma semelhante à matemática, montando
expressões com números e operações. Mas para que você veja o resultado, deve mostrá-lo na tela
através de uma instrução Write ou Writeln, sendo a expressão aritmética avaliada, isto é, calculada, e
o resultado mostrado na tela. Você pode usar parênteses para determinar a precedência de execução
das operações.
Você indica que deseja que uma operação seja efetuada usando um operador. Por exemplo, o
símbolo + é o operador de soma, e indica que se deve somar os dois números ao seu lado (os
operandos). O conjunto operador e operandos forma uma expressão aritmética. No Pascal, o
operador de subtração também é o mesmo da matemática; já a multiplicação e a divisão são
representados respectivamente por * e /. quatro operações para dois números.
O tipo do resultado de uma expressão aritmética depende do tipo dos operandos e dos operadores: o
operador de divisão real / faz com que a expressão que o contém seja do tipo real. Já as expressões
com os operadores +, - e * serão reais se houver algum operando real, caso contrário serão inteiras.
Especificação 4.33 – Treinando números

Escreva um programa Pascal com instruções Write ou Writeln que produzam a tela a seguir (deixe que o
programa faça os cálculos). Para números reais, use a formatação de quantidade de colunas e decimais.
Resultados de operações:
2100 + 541 = 2641
7.82 + 2.04 = 9.86
77/3 + 49/12 = 29.75
Pressione qualquer tecla para terminar.

Prática 4.34 – Operadores DIV e MOD

Outros operadores muito úteis para vários tipos de problemas são div e mod, que são operadores binários.
Ambos efetuam a divisão inteira, mas div calcula o quociente e mod o resto (ambos os operandos de div
e mod devem ser valores inteiros):
13 MOD 5
dá o resto 13532 13 DIV 5 dá
o divisor
Digite o programa de demonstração a seguir e preencha os resultados:

begin
Writeln(45 div 7); {resultado: ___}
Writeln(45 mod 7); {resultado: ___}
Writeln(5 mod 2 + 5 div 2); {resultado: ___}
end.
Exemplo 4.35 – Estudante metódico

. Um estudante muito metódico estava matriculado em 6 disciplinas, e dispunha de 1 hora e 40 minutos
para estudar. Sua intenção era dividir o tempo disponível igualmente para as 6 disciplinas, e descansar
livremente o tempo restante. Conhecendo os operadores mod e div, ele fez o seguinte programa:
PROGRAM CalcTempoEstudo;
uses CRT;
begin
ClrScr;
Writeln('Programa para cálculo de tempo de estudo');
Writeln('Dedique ', 100 div 6 , ' minutos para cada disciplina');
Writeln('Aproveite bem os ', 100 mod 6 , ' minutos restantes.')
end.
a) Calcule os resultados, digite e execute o programa e confira os resultados (lembre-se de teclar F5

para vê-los, após rodar o programa).
b) Modifique o programa para mostrar cada resultado alinhado à direita em 10 colunas da tela.
Prática 4.36 – Revisão de Div e mod

Calcule as expressões abaixo. Depois, faça um programa que lhe permita verificar se você calculou
corretamente.
a) 37 mod 13 =
b) 41 div 7 =
c) 11 div 3 mod 2 =
d) 11 mod 3 div 2 =
e) 5 mod 2 + 5 div 2
Prática 4.37 – Precedência de operações aritméticas

A expressão 5 mod 2 + 5 div 2 do exemplo acima demonstra uma possível fonte de confusão: se houver
vários operadores, qual operação será executada primeiro? Para evitar isso, e da mesma forma que na
matemática, podemos usar parênteses ou a precedência dos operadores, que indicam a seqüência em que
devem ser efetuadas as operações:
PRIORIDADE OPERADOR
1 - unário
2 * / div mod
3 +-
A ordem de precedência acima indica que primeiro são aplicados todos os - unários, em seguida são
efetuadas todas as operações de multiplicação, divisão, resto e quociente de divisão inteiro, e só após
estas são efetuadas as adições e subtrações. Se a expressão contém parênteses, estes têm precedência
superior a todos os operadores, isto é, qualquer expressão entre parênteses é executada primeiro. Se não
há parênteses, e os operadores tem a mesma prioridade, as operações são efetuadas da esquerda para a
direita.
Digite o programa abaixo e confira os resultados:
begin
Writeln(51 div 16 + 48 - 8 mod 5); {Resultado: 3 + 48 - 3 = 48 }
Writeln( (51 div 16) + ((48 - 8) mod 5) ); {Resultado: 3 + 0 = 3}
Writeln( -3*(43/(52 div 3))); {Resultado: -3*(43/17) = -7.588}
Writeln( 6/3*2 ); {Resultado: 4 (real)}
end.
Prática 4.38 – Precedência de operadores

Calcule as expressões abaixo, observando a precedência dos operadores. Em cada caso, dizer se o
resultado final é inteiro ou real. Por fim, elabore um programa que mostre na tela o resultado de cada
expressão, e compare com seus cálculos.
a) 2*6 + 11*5
b) 20/(-2)/5
c) 20/2*2
d) (3+9)/3*4
e) (5*6/(3+2) - 15*4)/6-4
f) 4+32*2 -7*2/(9-2)
Usar a precedência para estabelecer a ordem das operações pode

provocar erros ou tornar as expressões mais complexas muito difíceis de
serem entendidas, mesmo por quem as escreveu.. Use parênteses.
Prática 4.39 – Conta telefônica

Um programador implementou o programa abaixo para a seguinte especificação:
Uma conta telefônica é composta dos seguintes custos:
assinatura: R$ 17,90
impulsos: R$ 0,04 por impulso que exceder a 90
interurbanos
chamadas p/ celular: R$0,20 por impulso
Elabore um programa que calcula o valor da conta para 254 impulsos, R$34,29 de interurbanos
e 23 chamadas para celular.
PROGRAM CalcContaTelefone;
uses CRT;
begin
ClrScr;
Write('Cálculo de conta telefônica');
Write('Assinatura: ', 17.90);
Write('Impulsos: ', 254, ' a R$0,04 por impulso');
Write('Interurbanos: ', 34.29);
Write('Celular: ', 23 , 'chamadas');
Write('Valor da conta: ', 17.90 + 254*0.04 + 34.29 + 23*0.2:10:2);
end.
Embora não haja erros de sintaxe, o programa não foi testado adequadamente. Há um erro no cálculo e a
formatação da tela está horrível. Faça os acertos e melhoramentos necessários.
Especificação 4.40 - Média de notas

Monte uma expressão matemática que calcula a média de suas notas de um período anterior (se não
houver, invente). Faça o cálculo através de um programa, mostrando na tela o resultado, formatado com
duas casas decimais.
Especificação 4.41 - Conversão de temperatura

Faça um programa que calcula e mostra uma tabela de graus Celsius/Fahrenheit de 1 a 10 [fórmula: C =
5/9(F-32)]. Por enquanto (sem comandos de repetição), você deverá escrever as instruções para calcular e
mostrar cada resultado.
Especificação 4.42 - Imposto

Um imposto é calculado com base na seguinte tabela:
de 1.201,00 a 5.000,00 10%
de 5.001,00 a 10.000,00 15%
acima de 10.000,00 20%.
Implemente um programa que calcule os impostos a pagar para um valor em cada faixa. Para cada um,
mostre uma mensagem que identifique na tela a que se refere cada valor.
.4.5. Units
Talvez você já tenha se perguntado o que é aquele "uses CRT;" dos programas que vimos. O
Turbo Pascal guarda as definições de alguns comandos em um arquivo, chamado biblioteca padrão, que é
carregado para a memória junto com o restante do ambiente. Mas outras instruções não estão nesta
biblioteca, e sim em arquivos com extensão (tipo) .tpu chamados units. A extensão .tpu refere-se a Turbo
Pascal Unit.
A unit CRT contém instruções relacionadas à tela e ao alto-falante do computador: limpeza da

tela ou de uma linha, posicionamento do cursor, alteração das cores e outras.
O Turbo Pascal traz várias outras units: uma para imprimir, outra para acessar recursos do DOS,
outra ainda com instruções gráficas (círculos, preenchimentos e texto em modo gráfico). Além disso,
você pode criar suas próprias instruções e guardá-las em units, para usá-las de qualquer programa, como
será visto mais tarde.
Quando você quer usar uma instrução de uma unit, precisa informar ao compilador onde procurar
sua definição, através da palavra reservada uses. Sem a declaração uses, o compilador não reconhecerá as
instruções. Essa declaração deve vir logo após PROGRAM, e você pode indicar várias units, sem a
extensão:
PROGRAM ...
uses CRT, Printer, DOS;
Prática 4.43 – Posicionando o cursor

Na versão abaixo do programa Careta, foram acrescentadas algumas instruções para posicionar o cursor
antes de cada Write.
PROGRAM CARETA_XY;
uses CRT;
begin
ClrScr;
Writeln('Este programa desenha uma careta na tela na linha 10, coluna 40.');
Writeln('Pressione qualquer tecla para ver a careta');
Readkey;
GotoXY(40, 10); Write(' ____');
GotoXY(40, 11); Write(' / \');
GotoXY(40, 12); Write('/ O O \');
GotoXY(40, 13); Write('\ ^ /');
GotoXY(40, 14); Write(' \ ~ /');
GotoXY(40, 15); Write(' ----');
Writeln;
Writeln('Pressione qualquer tecla para terminar o programa');
Readkey;
end.
a) Digite o programa e teste-o.

b) Faça o programa desenhar a careta a partir da coluna 30, linha 15.
c) Use comandos GotoXY para posicionar as mensagens informativas que aparecem antes e depois
da careta.
d) O que acontece quando GotoXY recebe valores inválidos? Verifique alterando o programa
Careta_XY para tentar mostrar a careta nas posições:
100, 5 (coluna inválida)
10, 30 (linha inválida)
Para posicionar o cursor na tela antes de um comando Write, use a

instrução GotoXY (X, Y), onde X é o número da coluna (de 1 a 80, em
(1,1) modo padrão de texto) e Y é a linha (de 1 a 25).
Exercício 4.44 – Erros de sintaxe

Reescreva o programa a seguir, corrigindo os erros de sintaxe:
PROGRAMA QuadradoComX com erros;

{versão com erros de sintaxe;
usar CRT;
begin
ClearScreen;
Goto XY(20, 7); Write( XXXXX );
Goto XY(20, 8) Write( 'X X' );
Goto XY(20, 9); Write( 'X X' );
Goto XY(20, 10); Write( 'X X' );
Goto XY(20, 11); Writel( XXXXX );
End;
Especificação 4.45 – Menu posicionado

Elabore um programa que limpa a tela e mostra o seguinte menu centralizado, e espera uma tecla ser
pressionada para terminar (o traço após "Opção:" é o cursor). Use comandos de posicionamento do cursor
para facilitar.
Menu Relatórios
1 - Por nome
2 - Por código
3 - Por data
4 - Fim
Opção: _
Especificação 4.46 – Triângulo com iniciais

Escrever um programa que desenha um triângulo, aproximadamente centralizado, na tela (que em modo
texto normal tem 80 colunas por 25 linhas), tendo dentro as iniciais do seu nome. Faça o programa limpar
a tela no início. Para otimizar a elaboração, faça previamente um desenho detalhado (incluindo números
de linhas e colunas) da tela resultante do programa.
Prática 4.47 – Sons

a) Execute o seguinte programa:
PROGRAM Som;
uses CRT;
begin
Sound(440);
Delay(30);
NoSound;
end.
b) Agora altere a instrução Sound(440) para Sound(1000) e execute.

c) Agora altere a instrução Delay(30) para Delay(500), e depois Delay(2000);
d) Experimente outros valores para os parâmetros.
e) Duplique as três instruções do programa acima (usando o recurso de copiar e colar) e
experimente emitir 2 sons na faixa de 1000 a 2000 Hz e entre 4000 e 5000 Hz.
Você pode controlar a emissão de sons, no alto-falante do computador (e não em placas de som),
através de três instruções da unit CRT:
Sound(Freq): inicia a emissão de sons na freqüência Freq (inteira);
NoSound: interrompe a emissão de sons;
Delay(Ms): suspende a execução do programa durante aproximadamente Ms milissegundos
(inteiro).
Prática 4.48 – Delay para outra finalidade

Altere o programa QuadradoComX para que antes de terminar espere 2 segundos, incluindo uma
instrução Delay no final.
Especificação 4.49 – Parabéns

Faça um programa que emite as seis primeiras notas do "Parabéns pra você" (6 seqüências de
Sound/Delay/NoSound). Tente as seguintes notas (freqüência em Hz/duração em milissegundos):
[522,200], [522,200], [585,800], [522,400], [693,400], [655,800].
Prática 4.50 – Cores

Para mudar as cores de texto apresentado na tela, o Turbo Pascal para DOS oferece as instruções
TextColor e TextBackground, da unit CRT. Ambas esperam como parâmetro um número que
representa uma cor, mas há constantes (nomes que representam valores) já declaradas para as cores e
você pode usar os nomes das cores em inglês: Yellow, Green, Red, Black, White, etc. Por exemplo, para
escrever em vermelho, sobre fundo amarelo (gosto não se discute...), você deve escrever:
uses CRT;
begin
TextBackground(Yellow);
TextColor(Red);
Write('Texto em vermelho com fundo amarelo');
end.
Para colorir todo o fundo da tela, ajuste a cor de fundo com

TextBackground e comande um ClrScr.
Pesquisa 4.51 – Nomes das cores

Verifique se há na ajuda do Turbo Pascal uma lista de cores e relacione-as. [Dica: procure as constantes
declaradas na unit CRT]
Prática 4.52 – Quadrado colorido

Altere o programa QuadradoComX para que cada linha do quadrado seja de uma cor diferente, sobre um
fundo também diferente (toda a tela). Digite e teste-o.
Especificação 4.53 – Texto colorido

Faça um programa que faz toda a tela ficar amarela e depois mostra um texto qualquer em preto, na
posição 40 (coluna), 1 (linha). O programa espera uma tecla antes de terminar.
Especificação 4.54 – Nome em cantos

Faça um programa que mostra seu nome alternadamente nos quatro cantos da tela.
Prática 4.55 – Imprimindo: unit Printer

A instrução Write pode receber opcionalmente um primeiro parâmetro, chamado arquivo de saída, do tipo
texto. A tela é um destes arquivos e é assumida como o arquivo de saída, caso este não seja informado. A
impressora também é tratada como um arquivo texto, e enviamos texto para ela da mesma forma que para
a tela, bastando apenas usar a unit Printer e informar o arquivo de saída LST. Por exemplo, para imprimir
seu nome, escreva
PROGRAM {...}
uses Printer;
begin
Write(LST, 'Seu nome');
end.
Escolha um programa anterior que tenha implementado e que faça algum desenho na tela e altere-o para
que imprima o desenho.
Especificação 4.56 – Etiqueta

Usando a unit Printer descrita acima, implemente um programa que mostra na tela e também imprime
uma etiqueta com seu nome, endereço e demais dados.
.4.6. Funções
Na matemática, quando se quer indicar o seno de 3,14 radianos, por exemplo, escreve-se
Seno(3,14), sendo 3,14 o parâmetro. Seno é uma função, e você calcula o resultado de uma expressão que
a contém primeiramente calculando o valor do seno, depois trocando a função pelo resultado e depois
continua o cálculo. Por exemplo, na expressão
x = 2 x Seno(3,14) = 2 x 0 = 0,
a função Seno(3,14) foi substituída pelo seu valor (0) antes que se pudesse prosseguir o cálculo.
No Turbo Pascal estão disponíveis funções variadas, incluindo as matemáticas. Todas são usadas
de forma semelhante: o nome da função, e seus parâmetros, no momento da execução, são substituídos
pelo respectivo resultado.
.4.6.1 Funções matemáticas
Um programa que calcule o valor da expressão acima ficaria assim em Pascal:

begin
Writeln( 2*Sin(3.14) );
end.
A chamada da função precede as demais operações; se uma função é um operando de uma

expressão, ela deve ser calculada antes que as demais operações possam ser efetuadas. Observe a
seqüência de execução da instrução acima:
• é calculado o seno;
• é efetuada a multiplicação por 2;
• é mostrado na tela o resultado.
No caso do seno, co-seno e outras funções, a notação é semelhante à da matemática; já certos

operadores da matemática, como o símbolo da raiz, são substituídos no Pascal por funções. Por exemplo,
para calcular a raiz quadrada de 2, você pode usar a função SqRt (de Square Root):
begin
Writeln('A raiz quadrada de 2 é ', SqRt(2) );
end.
Você tem que usar o nome da função reconhecido pelo compilador; tente,
por exemplo, incluir em um programa chamadas do tipo Raiz(20) ou
Seno(5) e veja o que acontece.
Como parâmetros de funções você pode usar expressões e até outras funções. No próximo
exemplo, o parâmetro da função Sin é uma expressão, que contém outra expressão combinando
multiplicação com uma chamada de função:
begin
Writeln( Sin(3.14*2 + SqRt(3) ) );
end.
Neste caso, antes do cálculo da função Sin deve ser avaliada a expressão dentro dos parênteses;
antes que esta possa ser avaliada, deve ser calculada a chamada à função SqRt.
A tabela a seguir lista funções matemáticas disponíveis no Turbo Pascal:

FUNÇÃO DESCRIÇÃO TIPO DE ENTRADA TIPO DE VALOR
RETORNADO
Abs(Num) valor absoluto Real, inteiro mesmo da entrada
ArcTan(Num) arco tangente real (radianos) real
Cos(Num) co-seno real (radianos) real
Exp(Num) exponencial (ex) real real
Frac(Num) parte fracionária real real
Int(Num) parte inteira real real
Ln(Num) logaritmo natural (base e) real real
Round(Num) arredondamento ao inteiro real inteiro
mais próximo
Sin(Num) seno real (radianos) real
Sqr(Num) quadrado real Real
SqRt(Num) raiz quadrada real Real
Trunc(Num) extração da parte inteira real inteiro
Onde é esperado um valor real, você pode usar um inteiro.
Exemplo 4.57 – O eletricista

Um eletricista precisa comprar fio que irá passar, pelo telhado, por toda a diagonal de uma casa de
formato retangular. Como ele não tem condições de medir a diagonal com precisão (ou talvez não
queira...), a solução alternativa que ele encontrou foi medir os lados da casa, sabendo que a diagonal
pode ser calculada com base nos lados pelo Teorema de Pitágoras (a2 = b2 + c2). Considerando que a
casa mede 11,5 x 6,3 metros, faça um programa que calcule a quantidade mínima necessária de fio a ser
comprada, com precisão até centímetros.
A tela é bem simples, vamos mostrar apenas algumas mensagens informativas e o resultado. Para
apresentar a quantidade em centímetros, precisamos de 2 casas decimais, e no total 6 colunas bastam.
Para efetuar o cálculo precisamos elevar ao quadrado e extrair a raiz quadrada. O programa fica assim:
PROGRAM CalcComprimentoFio;
begin
Writeln('Cálculo de comprimento de fio');
Writeln('para paredes de 11,5 por 6,3 m');
Writeln( 'O comprimento mínimo é ', ( SqRt( Sqr(11.5) +
Sqr(6.3) ) ):6:2, ' metros. ' )
end.
Note a ordem de execução das operações matemáticas, quando o programa for executado:
primeiro Sqr(11.5), depois Sqr(6.3), em seguida a soma e só depois é calculada SqRt.
Exercício 4.58 - Sintaxe de funções

Ache dois erros de sintaxe no comando abaixo:
Writeln( Sin(3,14*2 + SqRt(3 ) );
Exercício 4.59 - Tangente?

Suponha que um colega lhe disse que um professor tinha pedido um programa Pascal no qual precisava
ser calculada a tangente de um número, mas que na linguagem não tinha função para calculá-la. O que
você sugeriria?
Exercício 4.60 - Seqüência de execução

Para a instrução Writeln( Sin(3.14*2 + SqRt(3) ) ), numere os comandos segundo a seqüência com que
serão executadas as operações:
( ) *
( ) Sin
( ) +
( ) SqRt
( ) Writeln
Especificação 4.61 - Funções matemáticas

Fornecer o valor retornado pelas operações matemáticas abaixo. Depois, chamando as funções adequadas,
escreva um programa que lhe permita verificar a correção dos seus cálculos:
Raiz quadrada de 169
172
Co-seno(0)
1.65 arredondado para inteiro
Especificação 4.62 - Funções aninhadas

Escrever um programa que calcula a raiz de 3, arredonda o resultado e calcula a exponencial do valor
resultante.
Exercício 4.63 – Expressões com funções

Converta a expressão abaixo para Pascal (não faça cálculos manuais):
e 3 + 1.13 2
sen ( 3)
cos ( 6 )
Prática 4.64 – Formatando a saída

Altere e execute o programa CalcComprimentoFio (acima) para mostrar o resultado:
a) utilizando 5 colunas e 1 casa decimal
b) utilizando 0 colunas e 1 casas decimais.
Pesquisa 4.65 - Odd

Descubra a finalidade da função Odd e faça um pequeno programa para testá-la.
.4.6.2 Números aleatórios
Descubra o padrão das seguintes seqüências:

1 4 9 25 36 49 ...
0 1 1 2 3 5 8 13 21 34 55 ...
1 7 9 33 12 7 87 37 22 3 4 65 ...
Para as duas primeiras você poderá achar o padrão, uma relação entre os números. A primeira
consiste nos quadrados de 1 a 7, e a segunda é a série de Fibonacci, em que cada termo é a soma dos dois
anteriores. Já para a terceira seqüência não se pode determinar que tipo de regra os produziu.
Instruções que produzam números variados sem qualquer padrão, regra ou relação entre si, os
chamados números aleatórios, são importantes para a implementação de jogos ou para gerar grande
quantidade de dados para testar programas. Por exemplo, isto será necessário se um programa sorteia um
número que deve ser adivinhado pelo usuário. E ninguém vai querer um programa de bingo que tem uma
regra para achar os números!
No Turbo Pascal, você pode gerar números inteiros aleatórios através da função Random. Antes
de poder usar Random, você chama Randomize para inicializar o gerador interno de números aleatórios.
Random recebe um parâmetro inteiro N, e o número gerado estará entre 0 e N - 1. Por exemplo, para
gerar e mostrar na tela um número aleatório entre 0 e 100, e depois outro entre 1 e 9, escreva:
PROGRAM TesteNumAleatorio;
begin
Randomize;
Writeln( Random(101) );
Writeln( 1 + Random(9) );
end.
Prática 4.66 – São aleatórios mesmo?

Digite e execute o programa TesteNumAleatorio 10 vezes e verifique se os resultados tem alguma relação
uns com os outros.
Exercício 4.67 – Utilidade de números aleatórios

Descubra ou invente cinco aplicações para números aleatórios.
Exercício 4.68 – Números aleatórios em jogo

Para algum jogo de computador que conheça, identifique algumas partes em que foram necessários
números aleatórios para tornar o jogo mais interessante.
Especificação 4.69 – – Operações com números aleatórios

Faça um programa que multiplica um número aleatório de 1 a 10 por outro de 100 a 1000 e divide o
resultado por outro de 1 a 1000, formatando a saída com 3 casas decimais.
Especificação 4.70 – Sorteio de dados

Faça um programa que sorteia e mostra na tela os valores correspondentes a dois dados.
Especificação 4.71 – Pinheiro refinado

Elabore uma versão do programa do pinheiro (pág. 68) que troca a cor de fundo para branco, colore os
galhos do pinheiro de verde e o caule de outra cor, entre cada linha espera 100 milissegundos e emite um
som diferente com freqüência crescente e espera uma tecla para terminar.
.4.7. Constantes declaradas
Prática 4.72 – Parabéns com constantes declaradas

Digite e teste o programa a seguir.
PROGRAM ParabensComConstantes;
{Toca o início do Parabéns usando constantes declaradas para as notas musicais}
uses crt;
const DO1 = 522;

RE = 585;
MI = 655;
FA = 693;
SOL = 777;
LA = 871;
SI = 976;
DO2 = 1034;
begin
Sound(DO1); Delay(200); NoSound;
Sound(RE); Delay(800); NoSound;
Sound(FA); Delay(400); NoSound;
Sound(MI); Delay(400); NoSound;
end.
Constantes
O Pascal nos permite definir nomes para valores, de forma a tornar os programas mais fáceis de
serem entendidos e para facilitar certas modificações. Isso é feito na seção CONST (de constantes).
Em um programa Pascal podem ser declaradas constantes numéricas, constantes para cadeias de
caracteres e várias outras. Quando o compilador encontra um nome declarado na seção de
constantes, ele simplesmente troca o nome pelo respectivo valor. Sempre que você estiver repetindo
algum valor em um programa, pense em declarar uma constante para ele. Para facilitar a
identificação de uma constante em um programa, pode-se adotar padrões, como começar cada
constante com um "c". Exemplos:
const
MeuNome = 'Fulano';
cVersaoPrograma = '2.1';
cPI = 3.1415;
cTurma = 'A';
Especificação 4.73 – Escala musical

Usando como base o programa acima, faça um programa que "toca" a escala de notas, de um DÓ até o
próximo, tendo as notas a mesma duração, escolhida por você.
Pesquisa 4.74 – Constantes predefinidas

O Turbo Pascal oferece algumas constantes que você pode usar sem declarações. Descubra o que são e os
valores das constantes:
a) PI
b) MaxInt
Especificação 4.75 – Quadrado de novo

Reescrever o programa QuadradoComX, declarando uma constante para o caractere e utilizando somente
essa constante para mostrar o caractere na tela.
Pesquisa 4.76 – Outras instruções da unit CRT

Procure na Ajuda do Turbo Pascal e descreva as instruções da unit CRT relacionadas abaixo. Faça um
pequeno programa de demonstração de cada uma.
a) ClrEol
b) DelLine
c) Window
Prática 4.77 - Indentação

A organização visual do programa, com letras minúsculas e maiúsculas, linhas em branco, um comando
por linha e deslocamentos para a direita ("indentação") facilita para nós percebermos sua estrutura; para o
compilador nada disto faz diferença, desde que você separe os nomes adequadamente (a exceção são os
parâmetros tipo texto de Write/Writeln: maiúsculas e minúsculas são respeitadas). Você precisa por um
espaço após a palavra PROGRAM, por exemplo, para o compilador saber que a palavra terminou: o
espaço é um caractere separador. Já depois de um ponto-e-vírgula não é preciso um espaço, já que é
também um separador. Uma vez que haja um separador, quaisquer espaços adicionais são ignorados.
Verifique isto editando o programa QuadradoComX para que fique como abaixo (não quebre texto entre
apóstrofos em duas linhas); depois compile, execute e comprove:
PROGRAM QuadradoComX; {Mostra na tela um quadrado feito com letras X.
Feito por Fulano de Tal, em 11/11/99} begin Writeln; Writeln( 'XXXXX' );
Writeln( 'X X' ); Writeln( 'X X' ); Writeln( 'X X' ); Writeln( 'XXXXX' );
end.
Especificação 4.78 – Apresentação de texto

Um estudante ia participar de uma feira de ciências e seu projeto tinha o tema "fotossíntese". Ele
conseguiu um notebook emprestado, e queria um programa que lhe permitisse apresentar um texto
dividido em partes, cada parte em uma tela, e o programa deveria mudar para a próxima tela ao toque de
uma tecla. A tela inicial deve ser a palavra "FOTOSSÍNTESE" escrita com letras grandes. Faça o
programa para o estudante, usando o texto abaixo, no qual cada parágrafo deve aparecer em uma tela
diferente. Use cores para melhorar a apresentação.
Como o estudante não entende muito de operação de computadores, você tem que também gerar um
arquivo executável, copiá-lo para o outro computador e incluir um ícone para fácil execução sob
Windows.
Texto:
"A água e os sais minerais absorvidos pelas raízes sobem através dos vasos
lenhosos do caule e chegam às folhas.
Nas folhas, existe uma substância verde, a clorofila, que absorve a energia
luminosa do sol. Ao mesmo tempo, por meio dos estômatos presentes nas folhas, a
planta absorve gás carbônico do ar.
Usando a energia solar, o gás carbônico e o hidrogênio contido na água retirada
do solo, após complicadas reações químicas, a planta produz açúcares (glicose)."
Prática 4.79 – Mais comandos do debugger

Pesquise nos menus ou na ajuda os comandos do debugger para:
a) Reiniciar uma sessão de depuração
b) Encerrar uma sessão de depuração
c) Após posicionar o cursor em algum ponto do programa, executá-lo até a posição do

cursor.
Prática 4.80 – Imprimindo a tela de saída do programa

Você pode precisar imprimir a tela de saída de algum programa, para documentar trabalhos, por exemplo.
Veja as alternativas para isso, no Windows:
• Tecle Alt-Print Screen para enviar a tela da janela ativa para a área de transferência (Shift-Print
Screen copia toda a tela). Abra um editor de textos, como o Word ou WordPad, ou um editor de
figuras (Photo Editor, Paint), cole a figura e imprima. No caso do editor de textos, altere a fonte
para uma não-proporcional, como Courier, para preservar a formatação original.
• Execute o programa, a partir do Turbo Pascal ou de seu arquivo executável, em uma janela (se
não estiver, tecle Alt-Enter). Use o recurso de seleção e cópia para a área de transferência, que
dessa forma é feita em modo texto. Para isso use os botões da barra de ferramentas, no alto da
janela. Cole o texto selecionado em um editor (pode ser o Bloco de Notas ou até o do TP) e
imprima-o normalmente.
Pesquisa 4.81 – Units

Procure na ajuda do TP quais são as units padrão. Para cada uma, relacione para que serve e dê exemplos
do respectivo conteúdo.
Pesquisa 4.82 – Units no disco

Usando o Windows Explorer ou outro utilitário, procure no diretório (pasta) do Turbo Pascal arquivos
.tpu e liste seus nomes.
85
.5 MEMÓRIA E ENTRADA DE DADOS
Você já deve ter observado, pelos exercícios dos capítulos anteriores que, com comandos
simples, já se pode fazer várias coisas num computador, através de uma linguagem de alto nível
como o Pascal. Mas para elaborar programas mais úteis é necessário tirar proveito da memória do
computador.
Quando o usuário de um programa digita dados do teclado, onde são guardados esses
dados? E como? Pode-se guardar dados na memória a qualquer momento? E como recuperá-los?
Que problemas podem ocorrer? É preciso conhecer a fundo a memória do computador? Neste
capítulo você verá como podemos tornar os programas muito mais flexíveis, usando variáveis.
.5.1. Comandos de memória
Prática 5.1 - Vendo por fora

a) Digite e compile o programa a seguir.
PROGRAM EqSegundoGrau;
{Calcula raízes da equaçao do segundo grau com coeficientes a, b e c.
Não trata delta negativo}
uses CRT;
var a, b, c : integer; {coeficientes}

Raiz1, Raiz2 : real; {raízes}
Delta : real;
begin
ClrScr;
Writeln('Entre coeficiente a: ');
Readln(a);
Writeln('Entre coeficiente b: ');
Readln(b);
Writeln('Entre coeficiente c: ');
Readln(c);
Delta := Sqr(b) - 4*a*c;
Raiz1 := (-b + SqRt(Delta) )/(2*a);
Raiz2 := (-b - SqRt(Delta) )/(2*a);
Writeln('Primeira raiz é ', Raiz1:0:2);
Writeln('Segunda raiz é ', Raiz2:0:2);
ReadKey;
end.
b) Execute o programa para cada equação do segundo grau descrita pelos conjuntos de coeficientes
(1, 0, -1), (1, -1, -6) e (1, 4, 4).
c) O programa não está preparado para tratar deltas negativos. Verifique o que acontece neste caso
executando-o para os coeficientes (1, 2, 5).
d) Prepare outras equações e experimente submetê-las ao programa. Uma forma simples é calcular
(x - R1)(x - R2), onde R1 e R2 são as raízes.
e) Execute o programa novamente, e quando for solicitado o coeficiente a, digite uma letra ou algo
não numérico, e veja o que acontece.
Variáveis
Variáveis armazenam valores, e são o mecanismo de uso da memória. Você só precisa informar o
nome de cada uma e o tipo de dado; o compilador cuida do gerenciamento da memória. Pode-se
fazer o seguinte com variáveis:
Declarar: na seção var informe o nome das variáveis que o programa vai precisar e o tipo de dado
que cada uma vai armazenar. O nome de uma variável deve seguir as mesmas regras que você viu
para nomes de programas: começar com uma letra, seguida de letras, dígitos ou barra de sublinhado.
Não podem, da mesma forma, ser usadas palavras reservadas como begin. No Pascal, toda variável
usada em um programa deve ser declarada. Omitir a declaração provoca um erro de compilação, com
a mensagem “unknown identifier” (identificador desconhecido).
Atribuir: com o sinal := você guarda um valor diretamente na variável. O nome da variável sempre
aparece à esquerda, e a direita pode ter qualquer expressão cujo resultado possa ser armazenado na
variável.
Recuperar o valor: onde for preciso usar o valor da variável, basta inserir o nome dela.
Ler um valor do teclado: com a instrução Readln pode-se ler algo digitado do teclado, sendo o valor
lido guardado na variável indicada entre parênteses.
Variáveis armazenam somente um valor de cada vez. A cada atribuição ou leitura, o valor anterior é
perdido.
Exercício 5.2 – Reconhecendo ações com variáveis

No programa-fonte acima, identifique a seção de variáveis, as atribuições, as recuperações de valor e as
leituras.
Lendo atribuições
Você pode ler atribuições, digamos, Lin := 1, das seguintes maneiras:

“Atribua 1 a Lin”, “Lin recebe 1” , “Lin é igual a 1” (há linguagens em
que o símbolo de atribuição é o “=“), ou ainda “Faça Lin igual a 1”.
Prática 5.3 – Xeretando a memória

a) Vamos ver mais de perto as variáveis em ação. Execute o programa usando o debugger (F7), até
que a barra fique sobre o primeiro Readln. Tecle Ctrl-F7. Aparece uma janela com o título "Add
Watch". Digite "a" (sem as aspas) e clique em Ok. Deve aparecer uma janela embaixo chamada
"Watches". Faça o mesmo para "b" e "c". Você está indicando ao debugger que deseja
acompanhar os valores dessas variáveis. Para garantir que tanto a janela do fonte quanto a de
variáveis estarão visíveis,você pode clicar em Window/Tile.
b) Agora execute o Readln. Digite um valor para o coeficiente e tecle Enter. Observe na janela
Watches o valor indicado para a variável a. Faça o mesmo para os demais coeficientes.
c) Inclua as variáveis Delta, Raiz1 e Raiz2 na janela Watches. Tecle F7 novamente
(alternativamente você pode teclar INS quando a janela Watches estiver ativa) enquanto observa
o que muda no conteúdo de cada variável.
d) Na janela Watches você pode inserir e observar também expressões. Experimente observar o
valor da expressão Delta > O.
6 - MEMÓRIA E ENTRADA DE DADOS 87
Quando você vai usar este recurso de executar uma linha de cada vez?
Tipicamente quando, ao testar um programa, você achar erros e precisa
de informação sobre o que o programa está fazendo. Use-o também para
aprender e fixar o funcionamento de uma instrução nova.
Prática 5.4 - Explorando o exemplo

Experimente introduzir no programa EqSegundoGrau os seguintes erros (um de cada vez) e compilar;
indique o erro ocorrido:
a) tire o var
b) tire a vírgula entre duas variáveis na seção var
c) tire o ponto e vírgula ao final da linha do var
d) idem, os dois pontos (:)
e) escreva a palavra real como "rial" ou outra errada
f) retire uma variável da declaração
Mais de Readln
A instrução Readln, quando encontrada no fluxo de execução de um programa, lê o que for digitado
no teclado e o armazena na variável indicada entre parênteses. O programa é suspenso para que o
usuário digite. Ao digitar, o usuário pode usar as teclas Backspace, Delete e as setas (como instrução
de entrada de dados, Readln é muito limitada; posteriormente criaremos outra melhor).
A variável usada para a leitura deve ser compatível com o valor esperado. Se o variável indicada é
real e for digitado texto ou valor numérico inválido (por exemplo, 2.3.1), o programa será
interrompido e uma mensagem de erro será mostrada. Se o tipo do dado digitado for incompatível
com o da variável, como por exemplo letras quando é esperado um número, a execução do programa
também será interrompida.
Você pode chamar Readln sem variáveis, quando quiser por exemplo fazer uma pausa. Neste caso,
não ponha parênteses.
Readln, quando usada para ler números, permite que várias variáveis sejam lidas de uma vez:
Readln(Var1, Var2, Var3...);
Neste caso, na digitação, os valores devem ser separados por espaços ou tabs.
Exercício 5.5 – Nomes de variáveis

Indicar os nomes de variáveis inválidos no Pascal, explicando para cada um porque não é válido:
a) B52
b) 14Bis
c) Nota_1
d) NotaTiradaPeloAlunoNaDisciplina
e) %Lista
f) Program
g) Nota-1
h) AsiaA2_LP
i) Dia Mes Ano
j) Mês
k) Var_1
l) Var
Nomes de variáveis são importantes
Dê nomes significativos às variáveis (como PlacaCarro, NomeCliente) de

forma a tornar o programa mais legível e de compreensão mais rápida,
para você e para seu professor! E dê nomes estranhos ou codificados (PC,
NC, seu nome) quando não quiser que alguém o entenda...
.5.2. Tipos de dado
Quando declara uma variável, você tem que informar também o tipo de dado, que indica ao
compilador a natureza dos valores que a variável pode conter. Porque isto? Você já sabe que a memória
do computador não é como um pedaço de papel ou um quadro de giz, em que você pode escrever e
registrar vários tipos de símbolos: números, letras, rabiscos e qualquer desenho de que você seja capaz.
Ela é muito mais limitada: cada byte pode armazenar apenas um número de 0 a 255, e isto é tudo o que
temos para registrar informação. Se o que temos a registrar são números de 0 a 255, ótimo, usamos uma
variável de 1 byte. Mas e se for um número maior do que 255? E se for negativo? E se tiver casas
decimais? Como faço para representar uma letra? Como armazenar uma figura?
Devido à variedade de tipos de informação a serem representados, e à estrutura limitada da

memória de um computador, as linguagens de programação oferecem várias alternativas para esta
representação. O que todas têm em comum é a classificação da informação em tipos de dados. Do ponto
de vista de uma linguagem de programação, um número real é diferente de um número inteiro. Um
número, seja real ou inteiro, é diferente de uma seqüência de caracteres. Desta forma, um número inteiro
é de um tipo de dado, um número real é de outro tipo, assim como uma seqüência de caracteres quaisquer
é de outro tipo distinto. Portanto, uma variável, além de ter um nome, será caracterizada pelo tipo de
dado que pode conter, que deve ser informado quando declararmos a variável.
De maneira geral, os tipos de dado de uma linguagem de programação são variações dos tipos
inteiro, real, lógico (verdadeiro ou falso) e texto.
Os conceitos relacionados a variáveis e tipos de dado são usados em todas

as linguagens de programação; tudo que você assimilar aqui terá
aplicação em qualquer delas, ainda que com nomes diferentes e pequenas
variações. Em qualquer linguagem nova, uma das primeiras coisas que o
programador faz é verificar quais são os tipos de dado disponíveis.
.5.2.1 Tipos de dado do Turbo Pascal
Veja na tabela a seguir os principais tipos de dado não estruturados, o respectivo domínio e a
quantidade de byte ocupadas na memória.
TIPOS DE DADO DO TURBO PASCAL

TIPO DE VALOR TIPO DE DADO VALORES POSSÍVEIS BYTES
PASCAL
Número inteiro Byte 0..255 1
Shortint -128..127 1
Integer -32768..32767 2
Word 0..65535 2
Longint -2.147.483.648..2.147.483.647 4
Número real Real -2.9e-39..1.7e38 6
Texto Char um caractere 1
String Texto 1 a 255
Lógico Boolean False, True 1
Portanto, se você precisa armazenar um valor numérico com casas decimais, deve declarar uma
variável do tipo real. Se o dado a representar é um número inteiro, você deve escolher entre os cinco tipos
disponíveis: byte, integer, word, smallint e longint, cujas diferenças são basicamente a faixa de
números suportada.
Para armazenar um único caractere (letra, dígito, sinal, caractere de controle) no Pascal, use o
tipo char. Por exemplo, se você quer registrar se algum dado se refere a uma pessoa física ou jurídica,
referidas como 'F' ou 'J', pode declarar uma variável do tipo char. O mesmo tipo se aplica se quisermos
armazenar um caractere correspondente a uma tecla, como retornado pela função ReadKey.
Já para representar dados como o nome de uma pessoa, seu endereço ou uma frase qualquer, é
preciso declarar variáveis do tipo string, que permite declarar cadeias de até 255 caracteres. Você pode
indicar o comprimento desejado entre colchetes: string[30], string[100]. Se não indicado, será assumido o
máximo. O tamanho máximo de uma variável string é diferente do seu tamanho dinâmico: uma variável
pode ter um máximo de 50 caracteres e num determinado ponto da execução do programa estar
armazenando 19 caracteres.
O critério para escolher tipos de dado é buscar o que melhor representa a

informação a ser armazenada, consumindo o mínimo de memória.
Para distinguir cadeias de caracteres de outros nomes do programa, como nomes de variáveis,
representamos uma cadeia entre apóstrofos, como em 'Texto'. Se não o fizermos, o compilador tentará
interpretar o nome ou seqüência de caracteres como identificador (de variável, função ou outro elemento)
ou como número, conforme comece com letra ou dígito. Assim, em um programa, 'Idade' representa
uma cadeia de caracteres, enquanto Idade representa uma variável. O caractere apóstrofo, quando
necessário, é representado duplicado, como em 'caixa d''água'. A expressão '''' representa uma cadeia
com um único caractere apóstrofo.
Já variáveis do tipo boolean (lógico) podem assumir somente dois valores: True e False
(verdadeiro e falso). Normalmente são usadas para armazenar resultados da avaliação de expressões
lógicas, usadas para verificações: “o contador já atingiu 100?”, “o aluno tirou nota maior do que 5”?
O tipo de dado de uma variável determina e limita o conjunto de valores que ela pode assumir e
as operações que podem ser executadas com a variável. Mas sempre a especificação do programa é que
esclarecerá, em várias situações, qual será o tipo de dado mais adequado. Se a especificação pede que
você calcule valores inteiros para áreas, usar o tipo real pode ser inadequado.
Uma variável real pode armazenar um valor inteiro, mas não o contrário.
Exemplo 5.6 – Quadrado com linha e coluna aleatórias

"Implementar um programa que desenha um quadrado de lado 5 na tela, feito com letras X e tendo o
canto superior esquerdo em uma linha e uma coluna sorteadas.”
Você já sabe que pode usar as instruções GotoXY e Write para posicionar o quadrado na tela. Sabe
também que pode usar a instrução Random para sortear a linha e a coluna. Os passos seriam os seguintes:
“Sortear a linha”
“Sortear a coluna”
“Desenhar o quadrado na linha e na coluna sorteadas”
Para a especificação acima, vamos precisar de duas variáveis, às quais chamaremos Linha e Coluna.
Quais os tipos de dado das variáveis Linha e Coluna? Linha está entre 1 e 25, e Coluna entre 1 e 80.
Podemos escolher shortint ou byte, mas daremos preferência a este porque os valores tem natureza
eminentemente positiva. Note que você pode até escolher os tipos integer, word ou longint, mas estará
usando memória desnecessariamente. O programa:
PROGRAM QuadradoSorteado;
{Desenha um quadrado com X em linha e coluna sorteadas}
uses CRT;
var Lin, Col : byte;
begin
Randomize;
ClrScr;
Lin := 1 + Random(21); {sorteia linha de 1 a 21}
Col := 1 + Random(76); {sorteia coluna de 1 a 76}
GotoXY(Col, Lin); Writeln( 'XXXXX' );
GotoXY(Col, Lin+1); Writeln( 'X X' );
GotoXY(Col, Lin+4); Writeln( 'XXXXX' );
ReadKey;
end.
Exemplo 5.7 – Quadrado com caractere lido

Escrever um programa que desenha um quadrado com o canto superior esquerdo em uma linha e coluna
lidas, usando um caractere também lido. Antes de terminar o programa espera ser teclado Enter.
Um projeto, na forma de uma tela-exemplo de saída do programa, pode ser:
Este programa desenha um quadrado com um caractere.

Digite o caractere: +
Digite a linha: 10
Digite a coluna: 30
+++++
+ +
+ +
+ +
+++++
Tecle Enter para terminar.
Veja o programa que implementa essa especificação:

PROGRAM QuadradoComCaractere;
{Desenha um quadrado formado por um caractere lido, a partir de
linha e coluna lidas}
uses CRT;
var Lin, Col : byte;

Ch : char;
begin
ClrScr;
Writeln('Este programa desenha um quadrado com um caractere.');
Write('Digite o caractere: '); Readln(Ch);
Write('Digite a linha: '); Readln(Lin);
Write('Digite a coluna: '); Readln(Col);
GotoXY(Col, Lin); Write(Ch, Ch, Ch, Ch, Ch);
GotoXY(Col, Lin + 1); Write(Ch, ' ', Ch);
GotoXY(Col, Lin + 4); Write(Ch, Ch, Ch, Ch, Ch);
Writeln; Write(Tecle Enter para terminar.');
Readln;
end.
Exercício 5.8 – Odad ed sopit

Numere a segunda coluna (variáveis) de acordo com a primeira (tipos de dado, com as letras
embaralhadas).
I - ebyt ( ) Idade de uma pessoa, em anos
II - aler ( ) Valores False ou True
III - grints ( ) Habitantes de um país
IV - rach ( ) A raiz quadrada de um número
V - noebola ( ) Uma letra do alfabeto
VI - ginnolt ( ) Um texto qualquer
Prática 5.9 – Blocos

Faça um diagrama de blocos para o programa QuadradoComCaractere.
Prática 5.10 – Compatibilidade de tipos

O fato de haver diferentes tipos de dados tem implicações e limita as atribuições que podemos comandar.
Assim, variáveis declaradas como do tipo integer são incompatíveis com um número real ou com uma
constante do tipo char ou string e assim por diante.
Digite o programa de teste abaixo e verifique quais das atribuições são inválidas (faça uma de cada vez).
Indique o código de erro de compilação para esse tipo de erro.
var Numero : integer;
Nome : string[10];
Ch : char;
N : byte;
begin
Numero := 3.1415;
Numero := 'X';
Nome := 1215;
Nome := '1215';
Ch := 'Texto';
Ch := 0;
N := 32000;
end.
Exercício 5.11 – Declaração de variáveis

Reescrever as declarações abaixo, corrigindo os erros de sintaxe:
a) Var Número, Coeficiente : real;
b) var integer N1, N2
c) var Nome, E-mail : string[300];
d) var Passou, {Indica se o aluno passou na disciplina}
e) VAR Alterou {registra se em alguma passagem algum dado foi alterado} : boolean;
f) vaR Incremento, °Celsius : real;
Exercício 5.12 - Complete

Complete a tabela com o nome da variável e o tipo de dado mais adequado:
TIPO DE VALOR NOME DA VARIÁVEL TIPO DE DADO PASCAL
a) Quantidade de funcionários QtFunc word
b) Salário de um funcionário VrSalario Real
c) Nome de um aluno NomeAluno String[30]
d) Nome de uma disciplina
e) Média de notas das disciplinas de um período
f) Data de nascimento
g) Placa de um carro
h) Área de um círculo
i) Nome de arquivo do DOS, com extensão e

sem subdiretórios
j) Saldo de uma conta bancária
k) Número de habitantes de uma cidade qualquer

TIPO DE VALOR NOME DA VARIÁVEL TIPO DE DADO PASCAL

l) Tipo de pessoa (valores: 'F' para pessoa física
e 'J' para pessoa jurídica)
m) CPF de uma pessoa, sem símbolos

delimitadores (somente os dígitos) e incluindo
os dígitos verificadores
Exercício 5.13 – Variáveis de objetos

Identifique variáveis e respectivos tipos de dado para representar 3 características de cada um dos
seguintes objetos:
a) fita de vídeo
b) carteira de identidade
c) sua casa ou apartamento
d) livro
e) carro
f) calça jeans
g) sapato ou tênis
h) lápis
i) planta
j) folha de cheque
Exercício 5.14 – Variáveis codificadas

Ao preencher um cadastro de um banco ou de uma loja, você já deve ter preenchido campos codificados:
ao invés de uma informação, você deve escrever o código correspondente. Por exemplo, sexo (masculino
1, feminino 2), tipo de pessoa (física 'F', jurídica 'J'). Esse tipo de codificação pode ser mais ou menos
fácil de ler e entender; por exemplo, sexo com valores 'M' ou 'F' ou com números. Para as informações
abaixo e seus valores possíveis, elabore uma codificação e declare uma variável com o tipo adequado de
dado:
a) Datilografia (nada, catilógrafo, dez dedos)
b) Estado civil (casado, solteiro, viúvo, desquitado, divorciado)
c) Tipo de moradia (própria, alugada, cedida, hipotecada, outros)
d) Fumante (sim ou não)
e) Conhecimentos de inglês (fala/escreve, lê, todos)
Exercício 5.15 - Competição

Forme 2 grupos de colegas. Escolham um objeto comum e vejam qual grupo consegue identificar mais
variáveis do objeto em 2 minutos.
Exercício 5.16 – Instruções com variáveis

Codificar instruções Pascal isoladas para as ações abaixo (pressuponha que as variáveis necessárias foram
declaradas). Siga o modelo:
a) Mostrar na tela o conteúdo das variáveis Codigo, Nome e Preco, separadas por espaços
Solução: Write(Codigo, ‘ ‘, Nome, ‘ ‘, Preco);
b) Somar 10 à variável N e armazenar o resultado na própria variável N

c) Calcular o resto da divisão inteira da variável N por 13 e atribuir o resultado à variável Resto
d) Calcular o seno do conteúdo da variável N, extrair a parte inteira e mostrar o resultado na tela
e) Atribuir à variável Delta o resultado do cálculo b2 - 4ac.
f) Mostrar na tela o valor do co-seno da raiz quadrada da exponencial da variável N
g) Ler do teclado uma cadeia de caracteres e armazená-lo na variável string S.
h) Ler um número para a variável Num.
i) Ler um caractere para a variável Ch.
j) Sortear um número que pode ser 0 ou 1 e armazenar o resultado na variável Sorteio.4
Exercício 5.17 – Expressões aritméticas com variáveis

Forneça expressões aritméticas em Pascal que representem as seguintes fórmulas (use variáveis com
nomes apropriados):
a) Média aritmética de 3 números
b) Soma dos N primeiros números inteiros [fórmula: N (N+1)/2)]
c) Valor em graus Celsius correspondente a uma temperatura em graus Fahrenheit [fórmula:
C = 5/9(F-32)].
Prática 5.18 – Ache o erro

O programa abaixo deveria implementar a seguinte especificação:
"O critério de notas de uma faculdade consiste de uma nota de 0 a 10 em cada bimestre, sendo a
primeira nota peso 2 e a segunda peso 3. Elabore um programa que lê as notas bimestrais e calcula a
nota do semestre."
Ocorre que há um erro de lógica. Descreva o erro, corrija-o e teste o programa.
PROGRAM CalcNotaSemestral;
uses CRT;
var Nota1, Nota2 : real;
begin
ClrScr;
Writeln('Cálculo da nota final a partir das notas bimestrais, pesos 2 e 3.');
Write('Entre nota do 1o. bimestre: ');
Readln(Nota1);
Readln(Nota2);
Write('Nota final: ',(Nota1*2 + Nota2*3/5):0:1);
Readkey;
end.
.5.3. Mais do tipo de dado char
Prática 5.19 – Conhecendo char

Digite e execute o programa abaixo, inicialmente sem e depois com o debugger.
PROGRAM DemoChar;
{demonstração do tipo de dado char e algumas operações com variáveis desse tipo}
uses CRT;
var Ch1, Ch2 : char;

S : string;
begin
ClrScr;
Write('Digite um valor para o caractere 1: '); Readln(Ch1);
Writeln('Veja o que pode ser feito com variáveis do tipo char.');
Writeln('Pressione uma tecla após conferir um resultado.'); Writeln;
Ch2 := 'x';
Writeln('A variável Ch2 não foi inicializada. O comando Ch2 := ''x'' atribui');
Writeln('o caractere x a Ch2. Confira, o valor dela agora é: ', Ch2);
ReadKey;
Writeln('Transforme o valor da variável em maiúscula.' );
Ch2 := UpCase(Ch2);
Writeln('Após o comando Ch2 := UpCase(Ch2), essa variável agora contém: ', Ch2);
ReadKey;;
Write('Concatenação (junção), usando o operador +: Ch1 + Ch2 = ');
Writeln(Ch1 + Ch2); ReadKey;
Write('A mesma operação, usando a função Concat(Ch1, Ch2): ');
Writeln(Concat(Ch1, Ch2)); ReadKey;
Writeln('Entre com um caractere na leitura a seguir, usando o teclado numérico.');
Writeln('Pressione Alt e tecle 178, solte Alt e tecle Enter.');
Readln(Ch1);
Writeln('Ch1 agora contém: ', Ch1); ReadKey;
Writeln('A instrução FillChar preenche uma string com caracteres.');
Writeln('Vamos preencher a string S com 70 vezes Ch1. O comando é FillChar(S, 70, Ch1)');
Writeln('Veja como ficou S (tecle algo):'); ReadKey;
FillChar(S, 70, Ch1); Writeln(S); ReadKey;
end.
Prática 5.20 – Upcase sem maiúsculas

Faça um pequeno programa de teste e veja o que a função Upcase retorna quando recebe caracteres que
não a maiúscula correspondente, como '!' e '#".
Prática 5.21 – Lendo teclas com ReadKey

Digite e execute o programa abaixo, depois siga as explicações.
PROGRAM MostraTecla;
{demonstra uso de ReadKey como função e procedimento}
uses CRT;
var Ch : char;
begin
Writeln('Pressione uma tecla');
Ch := ReadKey;
Writeln('Você pressionou a tecla ', Ch);
Writeln('Pressione outra tecla para terminar');
ReadKey;
end.
Vimos usando ReadKey como um procedimento, mas ela é na verdade uma função, que retorna o
caractere correspondente à tecla pressionada. Uma vantagem de usar ReadKey para ler um caractere é que
o usuário não precisa teclar Enter, como no Readln. Sendo uma função, podemos chamar ReadKey dentro
de um Write ou atribuir seu resultado a uma variável. Veja o exemplo:
O programa acima funcionará para teclas de caracteres normais, como alfabéticos e numéricos. Para
teclas de função ou normais alteradas por uma tecla de controle, como Shift, Alt e Control, ReadKey
retornará zero e será necessário chamá-la novamente parar obter um segundo código. Para tratar essa
situação, precisamos de instruções que veremos no próximo capítulo.
Armazenando caracteres na memória

Se em um byte de memória podemos apenas representar números de 0 a 255, como então representar
letras e outros caracteres, que constituem os valores dos tipos de dado char e string?
Letras e outros símbolos não numéricos são armazenados na memória também na forma de
números, sendo a correspondência feita através de tabelas que associam letras a códigos numéricos.
Nos computadores padrão PC é usada a tabela ASCII (American Standard Code for Information
Interchange), que vai de 1 a 255 (1 byte, portanto). Nela, além de letras, números e sinais de
pontuação, existem códigos numéricos para caracteres de controle (por exemplo, o 13 corresponde
ao ENTER e o 27 ao ESCAPE) e desenhos de linhas simples e duplas (retas horizontais e verticais,
cantos). Para letras, há códigos distintos para maiúsculas e minúsculas: o código 66 corresponde a
'B', e o 98 corresponde a 'b'. Há um código também para o caractere 'espaço', o 32.
Assim, o número 66 armazenado num byte de memória é interpretado de forma diferente, conforme
o tipo de dado com que foi definido a variável ali armazenada. Se o dado for, por exemplo, de um
tipo numérico que ocupa um byte, é o número 66 mesmo. Se o byte for parte da representação de
uma cadeia de caracteres, é interpretado como o caractere 'B'. Para o compilador, letras não se
misturam com números. No caso de um dado do tipo cadeia de caracteres, mesmo se o número
armazenado for 50, é interpretado como o caractere '2', e não o número 2. Para representar a
seqüência de caracteres '65', são necessários 2 bytes: um para o '6' e outro para o '5'.
Veja a tabela ASCII no apêndice D.
Exercício 5.22 – Familiarização com a tabela ASCII

Numere a segunda coluna de acordo com a primeira, segundo a correspondência do caractere ASCII com
o respectivo código:
a) $ ( ) 43
b) + ( ) 55
c) 7 ( ) 90
d) X ( ) 36
e) Z ( ) 88
f) ~ ( ) 126
Prática 5.23 – Obtendo caracteres ASCII

No editor do Turbo Pascal, em um texto qualquer, e usando o teclado numérico, obtenha os caracteres
correspondentes a alguns códigos na faixa de 180 a 200 (veja como no programa-tutorial acima).
.5.4. Mais do tipo de dado string
Prática 5.24 – Conhecendo strings

Digite e execute o programa abaixo, inicialmente sem e depois com o debugger.
PROGRAM DemoStrings;
{demonstração do tipo de dado string e algumas operaçÕes com variáveis desse tipo}
uses CRT;
var S1 : string; {uma cadeia (string) de tamanho máximo 255}

S2 : string[30]; {tamanho máximo 30}
S3 : string[3]; {tamanho máximo 3}
begin
ClrScr;
Write('Digite um valor para a string 1 (até 255 caracteres): ');
Readln(S1);
Write('Digite um valor para a string 2 (até 30 caracteres): ');
Readln(S2);
Writeln('Digite um valor para a string 3 (até 3 caracteres; ');
Write('O que passar disso será desprezado na leitura: ');
Readln(S3);
Writeln('Veja o que pode ser feito com variáveis do tipo string.');
Writeln('Pressione uma tecla após conferir um resultado.');
Write('Concatenação (junção), usando o operador +: S1 + S2 = ');
Writeln(S1 + S2); ReadKey;
Writeln('A mesma operação, usando a função Concat: ');
Writeln(Concat(S1, S2)); ReadKey;
Writeln('Para calcular o tamanho atual de uma variável string, use a função Length.');
Writeln('Por exemplo, S1 tem atualmente ', Length(S1), ' caracteres.');
Writeln('Para obter um caractere de uma string, use colchetes após o nome da variável.');
Writeln('O primeiro caractere de S1 é S1[1]: ', S1[1]); ReadKey;
Writeln('O terceiro de S2 é S2[3], que é ', S2[3]); ReadKey;
Writeln('O último caractere de S2 é obtido com S2[ Length(S2) ]: ',
S2[ Length(S2) ]);
ReadKey;
Writeln('Você pode mudar somente um caractere de uma variável string,');
Writeln('basta indicar o número dele entre colchetes na atribuição.');
S3 [1] := '!';
Writeln('Apos o comando S3[1] := ''!'', S3 ficou assim: ', S3); ReadKey;
Writeln('Para extrair uma subcadeia, use a função Copy(VarString, PosInicial,
Qtde).');
Write('Copy(S2, 3, 2) obtém, a partir do terceiro, 2 caracteres (se houver): ');

Writeln(Copy(S2, 3, 2)); ReadKey;
Writeln('Procure outras instruções para strings: ');
Writeln('Pos: pesquisa uma subcadeia em uma cadeia');
Writeln('FillChar: preenche uma variável string com um caractere');
ReadKey;
end.
Inteiro ou string? - Em alguns casos pode haver um dilema na

representação de um dado que só contém dígitos: como string ou como
inteiro? Esse é o caso de um número de telefone. Outros dados possuem
dígitos e sinais mas o armazenamento dos sinais é desnecessário, como em
um CEP ou um CPF. Em princípio, você pode aplicar a regra: se não
serão feitas operações matemáticas com o dado, use o tipo string, a menos
que tenha um bom motivo para não fazê-lo. Nessa questão (como em
várias outras), a experiência será seu melhor professor.
Exercício 5.25 – RG é inteiro?

Você representaria um número de identidade como um inteiro ou como uma cadeia de caracteres?
Explique.
Prática 5.26 – Atribuição de texto

Para atribuir cadeias de caracteres a variáveis tipo string, ou um caractere a uma variável tipo char,
escrevemos a cadeia ou o caractere entre apóstrofos. Se o caractere apóstrofo faz parte da cadeia, deve
aparecer duplicado. Assim, quando forem executadas as instruções do programa:
var Nome : string[30];
Ch : char;
begin
Nome := 'Fulano de Tal';
Ch := ''''
end.
será atribuído à variável Nome o conteúdo 'Fulano de Tal', e à variável Ch um apóstrofo. Digite o
programa acima e comprove, usando o debugger.
Até que tenha sido armazenado um valor pela primeira vez em uma
variável, seu conteúdo é indefinido, e pode ser qualquer coisa; você é que
deve cuidar disso.
Prática 5.27 – Range check

Procure no menu Options/Compiler uma opção que ativa/desativa a verificação de faixa (range
checking). Acesse a ajuda e veja o que significa. Faça um pequeno programa que apenas lê um valor para
uma variável do tipo byte e mostra seu conteúdo na tela. Compile inicialmente com a opção de
verificação ativada, execute o programa e digite um valor maior que 255. Depois desative a verificação de
faixa e compile novamente, executando da mesma maneira. Descreva o que observou de diferente e os
possíveis impactos em programas.
Exercício 5.28
Represente cada descrição como uma única instrução Pascal:
a) Converter a variável Ch para maiúscula e armazenar o resultado na própria variável Ch.
b) Alterar o último caractere da variável string Cad para 'Z'.

c) Converter o último caractere da variável Cad para maiúsculo.
d) Extrair o caractere da variável Nome, na posição indicada pela variável N, e atribuir o
resultado à variável Ch.
Prática 5.29 – Problema com Write

Um estudante de programação estava com o seguinte problema: um Writeln devia mostrar uma linha de
hífens com 80 caracteres, mas ele não queria que o texto do programa-fonte fosse além da margem direita
da tela (facilita a visualização e a descoberta de erros). Ao tentar quebrar a cadeia em duas linhas, como
abaixo, o compilador não permitiu:
Writeln('----------------------------------------
----------------------------------------');
Pesquise e teste três soluções para o problema:
a) Usando Write
b) Usando o operador '+'
c) Usando a função FillChar.
.5.5. Descobrindo variáveis
Você vai identificar as variáveis de um programa, em geral, ao iniciar a implementação do

programa-fonte, após ter pelo menos parte do projeto. Em geral, procuramos valores que mudam de uma
execução do programa para outra. Por exemplo, uma equação do segundo grau, cujo programa já vimos,
tem a forma
ax2 + bx + c,
que representa genericamente todas as equações dessa ordem. O que muda de uma para outra?
Exatamente os coeficientes a, b e c. Portanto, um programa que resolva equações do segundo grau precisa
ter variáveis para os três coeficientes (no mínimo).
Considere agora que um programa que inverte uma cadeia de caracteres lida pelo teclado. Isto é,
se o usuário entrar com 'cadeia a inverter', o programa mostrará na tela a cadeia 'retrevni a
aiedac'. Quais as variáveis? Pelo menos uma será necessária, para armazenar a cadeia digitada no
teclado. Dependendo da implementação, pode ou não ser necessária uma outra variável para armazenar a
cadeia invertida, conforme o programa mostre-a diretamente na tela ou armazene-a em uma variável para
mostrar depois.
Se o programa simula um 'X' se movendo pela tela, da esquerda para a direita e de cima para
baixo, não são necessárias variáveis para armazenar dados fornecidos pelo teclado. Mas internamente o
programa seguidamente posiciona o X em linhas e colunas diferentes, portanto haverá pelo menos duas
variáveis.
Use se necessário as perguntas abaixo.

1. O que sai, isto é, quais informações são apresentadas pelo programa ao usuário?
1.1. O que é mostrado na tela?
1.2. O que é impresso?
1.3. O que sai do programa por outros meios?

2. Que informações entram, isto é, o que é fornecido pelo usuário?
3. O que é calculado pelo programa?
4. Que informações são constantes ou estáveis durante uma execução do programa?
5. Que informações podem ser diferentes em duas execuções do programa?
6. Que informações intermediárias é preciso representar para obter a saída?
Exemplo 5.30 – Descobrindo variáveis de entrada 1

Ache as variáveis de entrada para cada especificação abaixo, isto é, variáveis que devem ser declaradas
para receber dados via teclado:
a) Elabore um programa que lê três valores e calcula a média geométrica dos números
lidos (divisão do produto pela quantidade de valores).
Solução: N1, N2 e N3, do tipo real (se fosse escolhido um tipo inteiro não estaria errado, já que a
especificação é omissa quanto a isto).
b) Escrever um programa que lê um caractere, as iniciais de um nome (3 caracteres), uma
linha e uma coluna e depois desenha na tela um triângulo eqüilátero formado com o caractere,
tendo dentro as iniciais lidas. O caractere no ápice do triângulo deve estar na linha e coluna
lidas, e a altura do triângulo deve ser no máximo 5 linhas.
Solução: Ch (char), Iniciais (string[3]), Lin e Col (byte).
Exemplo 5.31 – Descobrindo variáveis de entrada 2

Ache as variáveis de entrada para a especificação abaixo:
“Um salário tem os seguintes componentes:

- valor nominal
- adicional devido a horas extras
- valor descontado para o INSS (10% do valor a receber, limitado a 150 reais).
O valor adicional devido às horas extras é calculado dividindo-se o valor nominal por 176 (22
dias de 8 horas), multiplicando-se pela quantidade de horas e ainda com um acréscimo de
50%.
Escrever um programa que lê os valores necessários, calcula e mostra na tela os componentes
do salário e o salário líquido resultante para o empregado. Não é preciso prever
arredondamentos, mas os valores devem ser mostrados na tela com duas casas decimais.
Exemplos: para um salário de R$ 1.000,00, com 30 horas extras, teremos R$ 255,68 de horas
extras [(1.000/176)*30*1,5], R$ 125,57 de INSS e um salário líquido de R$ 1.130,11. Para um
salário de R$ 2.000,00 e 20 horas extras, seriam R$ 340,91 de horas extras, R$ 150,00 de
INSS (e não os 10%), com um salário líquido de R$ 2.190,91.”
Solução: O valor nominal deve ser lido, bem como a quantidade de horas extras. Todos os demais
valores serão calculados pelo programa.
Exercício 5.32 - Ache variáveis na especificação

Identifique variáveis para a especificação abaixo:

valor de interurbanos
Elabore um programa que lê os impulsos excedentes, valor de interurbanos e quantidade de
chamadas para celular e calcula o valor da conta.
Especificação 5.33 - Tempo livre

Reescreva o programa CalcTempoEstudo (pág. 71) de forma que trate qualquer disciplina e qualquer
quantidade de tempo livre. Assim, o estudante entra com esses valores e o programa efetua os cálculos
necessários. Teste com valores variados.
Especificação 5.34 - Comprimento de fio

Altere o programa do eletricista (pág. 79) para que as medidas sejam lidas do teclado.
Especificação 5.35 - Nota musical

Elaborar um programa que lê uma freqüência (em Hertz) e uma duração (em milissegundos) e emite um
som na freqüência com a duração.
Especificação 5.36 - Etiqueta

Escreva um programa que lê do teclado seu nome completo, endereço, CEP e telefone, limpa a tela e
mostra , centralizados, seu nome na primeira linha, seu endereço na segunda, e o CEP e telefone na
terceira.
Especificação 5.37 - Média aritmética

Escrever programa que lê três notas inteiras e calcula a sua média aritmética.
Especificação 5.38 - Menu posicionado

Implemente um programa que mostra o menu abaixo a partir de uma linha lida do teclado:
Menu de Consultas
0 - Fim
1 - Clientes
2 - Produtos
3 - Faturas
4 - Estoque
Opção: _
Especificação 5.39 - Média ponderada

Implemente um programa que lê três valores e calcule a média ponderada para pesos 1, 2 e 3,
respectivamente (multiplique cada nota pelo seu peso, some os produtos e divida o resultado pela soma
dos pesos).
Especificação 5.40 - Aritmética básica

Implemente um programa que lê dois números quaisquer e informa sua soma, diferença, produto e
quociente, formatados com 2 casas decimais.
Especificação 5.41 - Funções matemáticas

Elabore um programa que lê um número (suponha que será positivo) e informa seu quadrado, raiz,
logaritmo e exponencial, formatados com 4 casas decimais
Especificação 5.42 - Losangos

Implemente um programa que desenhe os losangos abaixo na tela, sendo que o topo do primeiro losango
é colocado em uma linha e uma coluna lidas do teclado, e o topo do segundo fica 15 colunas à direita do
primeiro.
X X
XXX XXX
XXXXX XXXXX
XXXXXXX XXXXXXX
XXXXXXXXX XXXXXXXXX
XXXXXXX XXXXXXX
XXXXX XXXXX
XXX XXX
X X
Especificação 5.43 - Triângulo com iniciais

Escrever um programa que lê um caractere, as iniciais de um nome (3 caracteres), uma linha e uma
coluna e depois desenha na tela um triângulo formado com o caractere, tendo dentro as iniciais lidas. O
caractere no ápice do triângulo deve estar na linha e coluna lidas, e a altura do triângulo deve ser no
máximo 5 linhas.
Especificação 5.44 - Conversão de temperatura

Um canal de notícias internacionais, a cabo, previa temperatura máxima para Brasília de 85 graus
Fahrenheit. Escrever um programa que lhe permita converter esta temperatura (e qualquer outra) para
graus Celsius, sabendo que a relação entre elas é C = 5/9 (F -32).
Especificação 5.45 - Despesas de casal

Um casal divide as despesas domésticas mensalmente. Durante o mês cada um anota seus gastos e as
contas que paga; no final eles dividem meio a meio. O casal deseja um programa que facilite o acerto:
eles digitariam os gastos de cada um, e o programa mostraria quem deve a quem. Atualmente eles fazem
o acerto manualmente, na forma da seguinte tabela:
ITEM MARIDO ESPOSA TOTAL
DESPESAS PAGAS 1200,00 950,00 2.150,00
% PAGO 55,81 44,19 100
VALOR DEVIDO 1075,00 1075,00 2150,00
SALDO -125,00 125,00
Portanto, os saldos devem ser iguais, e quem tiver o saldo negativo deve pagar o valor para o outro. Faça
um programa que leia os valores adequados e efetue os cálculos. O total é a soma das despesas
individuais; um percentual é o gasto individual dividido pelo total, multiplicado por 100; o valor devido
por cada um é o mesmo e igual à metade do total; finalmente, cada saldo corresponde ao valor devido
menos o valor pago.
Uma tela para o programa pode ser, com os mesmos dados da tabela acima:
Este programa rateia despesas de casal (50% para cada).
Digite valor das despesas do marido: 1200

Digite valor das despesas da esposa: 950
ITEM MARIDO ESPOSA TOTAL

============== ======= ======= =======
Despesas pagas 1200.00 950.00 2150.00
% pago 55.81 44.19 100
Valor devido 1075.00 1075.00 2150.00
Saldo -125.00 125.00
a) Elabore um programa para a especificação descrita.

b) Altere o programa de forma que o marido arque com 60% das despesas e a esposa com o restante.
c) Suponha que o casal, ao invés de dividir meio a meio as despesas, vai dividi-las
proporcionalmente à renda de cada um. Altere o programa de forma que este leia também a renda
de cada um e use a proporção das rendas para a divisão
Especificação 5.46 - Adivinha

Escrever um programa que implementa uma brincadeira de “adivinhar” um número pensado por uma
pessoa. Veja exemplo do diálogo:
- Pense um número (o outro pensou o 7).
- Multiplique por 2 (Ok)
- Some 6 ao resultado (Ok)
- Divida o resultado por 2 (Ok)
- Quanto deu?” (O outro informa 10).
- Você pensou o número 7 (Ohhh!!!)
[Dica: problemas desse tipo dão origem a uma expressão aritmética, e você pode alterar as operações à
vontade, desde que a expressão resultante admita uma inversa. Normalmente estruturamos o problema
de forma que a expressão permita uma simplificação que facilite os cálculos. Para a seqüência do
exemplo, a expressão é (sendo n o número pensado e R o resultado): (n*2+6)/2 = R, donde n = (R*2-
6)/2 = R - 3. Ou seja, basta subtrair 3 do resultado fornecido pela pessoa para "adivinhar" o número].
Especificação 5.47 - Conversão cm/pol

a) Faça um programa que mostra 10 linhas de uma tabela de conversão centímetro/polegada, a partir
de um valor lido e variando de 10 em 10 centímetros (uma polegada equivale a 2,54 centímetros).
b) Altere o programa para que a variação também seja lida do teclado.
Especificação 5.48 - Notas do professor

Um professor avalia seus alunos através dos seguintes critérios:
1) Duas notas de exercícios de 0 a 10, sem casas decimais, peso 1 e peso 2, respectivamente, com peso
de 20% na nota final.
2) Uma nota de prova de 0 a 10, com uma casa decimal e peso de 80% na nota final.
Elabore um programa que lê as notas de um aluno, calcula e mostra na tela sua nota final, formatada com
uma cada decimal e devidamente ponderada pelos pesos (uma média ponderada é calculada somando-se
os produtos de cada valor pelo seu peso e dividindo-se a soma resultante pela soma dos pesos). Exemplo:
Um aluno tirou 5 e 6 de exercícios e 8,5 na prova. Sua nota de exercícios é (5*1 + 6*2)/3 = 5,667. Sua
nota final é (5,667*2 + 8,5*8)/10 = 7,9.
Especificação 5.49 – Muitas notas musicais

Elaborar um programa que lê uma freqüência (em Hertz) e uma duração (em milissegundos) e emite 10
sons com a duração lida, sendo o primeiro com a freqüência lida e os seguintes 10% maiores que o
anterior.
Especificação 5.50 - Conta telefônica

valor da assinatura: R$ 21,40
Elabore um programa que lê os impulsos excedentes, valor de interurbanos e quantidade de chamadas
para celular e calcula o valor da conta. Declare o valor da assinatura e as tarifas como constantes.
Ao definir a tela, imagine que está fazendo um produto para ser avaliado por um cliente, juntamente com
o de concorrentes, para uma eventual compra.
.5.6. Declarando seus próprios tipos de dado
Nem sempre os tipos de dado disponíveis na linguagem atendem perfeitamente às necessidades

do programa. Uma característica que distingue o Pascal de outras linguagens é a possibilidade que o
programador tem de declarar seus próprios tipos de dado. Uma vez que declarou o novo tipo, pode
declarar quantas variáveis quiser daquele tipo. Há várias possibilidades para isso no Pascal; aqui,
ficaremos restritos a uma delas, que consiste em declarar um novo tipo como um subconjunto de um tipo
disponível na linguagem: esse é o tipo subfaixa (subrange). A idade de uma pessoa, por exemplo, é um
subconjunto do tipo byte. As letras maiúsculas são um subconjunto do tipo char.
Declaramos um tipo de dado através da palavra reservada type, normalmente antes da seção var,
embora possa vir também depois. Para o tipo subfaixa, informamos o nome do tipo, o limite inferior e o
limite superior (que deve ser maior ou igual ao limite inferior), separados por dois pontos. Para a idade e
para as letras maiúsculas, podemos declarar tipos da seguinte forma:
type
tIdade = 1..120;
tMaiusc = 'A'..'Z';
Agora podemos declarar variáveis dos novos tipos:

var Idade : tIdade;
Ch1, Ch2 : tMaiusc;
Uma boa aplicação para a definição de tipos é para cadeias de caracteres. Em um programa típico,
costuma-se declarar várias variáveis de um mesmo tipo, como você verá no capítulo sobre criação de
instruções. Se você declarar um nome como string[30], por exemplo, se tiver que mudá-lo deve percorrer
todo o programa para substituir o tamanho onde quer que ele ocorra. Alternativamente, pode-se declarar
um tipo para o nome:
Type tNome : string[30];
Agora, basta mudar a declaração do tipo para alterar todas as declarações de variáveis desse tipo.
Exercício 5.51 - Subfaixa

Declare tipos de dado subfaixa para representar:
a) Nomes de livros
b) Idade de pessoas, podendo estar incluídos personagens bíblicos
c) Linha da tela em modo texto padrão (25x80)
d) Data em formato "AAAAMMDD"
Prática 5.52 – QuadradoSorteado v2

Reescreva o programa QuadradoSorteado, declarando um tipo de dado subfaixa para a linha e outro para
a coluna. Teste.
.5.7. Conversões entre tipos de dados
Muitas vezes precisamos efetuar conversões entre tipos de dados: de inteiro ou real para string ou
vice-versa, um caractere para o código ASCII correspondente e vice-versa. Por exemplo, para evitar erros
na entrada, podemos ler um número como texto e depois convertê-lo para número para efetuar operações
matemáticas.
Códigos ASCII
Para converter um código numérico no respectivo caractere da tabela ASCII, você pode usar a
função padrão Chr ou o símbolo #. Os primeiros dois comandos abaixo fornecem a mesma saída, ou
seja, o caractere 'J'. O terceiro emite um bip no alto-falante:
Writeln( Chr(74) );{Mostra 'J'}
Writeln( #74 ); {idem}
Writeln( #7 ); {emite bip}
A função inversa é Ord, que recebe um caractere e retorna o código ASCII correspondente. Assim, a
instrução abaixo mostrará na tela o número 74.
Writeln( Ord('J') );
Responda: o que será mostrado na tela pela instrução abaixo?
Write (Chr(Ord('H')));
Exemplo 5.53 – De ASCII para caractere

Escreva um programa que lê três números e mostra na tela uma cadeia formada pela concatenação dos
caracteres ASCII de cada número.
Uma tela para o programa pode ser assim:
Entre três números de 0 a 255: 74 75 76

JKL
_
Precisamos de três variáveis inteiras para os números. Como os códigos ASCII vão de 0 a 255, o tipo byte
é apropriado. Para converter cada código para o respectivo caractere, usamos a função Chr, e para
concatená-las usamos o operador +. O programa fica assim:
PROGRAM Concat3CodAscii;
uses CRT;
var N1, N2, N3 : byte;
begin
ClrScr;
Write('Entre três números de 0 a 255: ');
Readln(N1, N2, N3);
Writeln(Chr(N1) + Chr(N2) + Chr(N3));
end.
Exemplo 5.54 – De caractere para ASCII

Elabore um programa que lê um nome de até 15 caracteres e mostra a inicial e seu código ASCII, e a
última letra e seu código.
Uma tela resultante da execução do programa pode ser:
Entre um nome: Fulano
Inicial: F, cujo código ASCII é 70
Ultima: o, cujo código ASCII é 111
Precisamos de variáveis para o nome (string), para a letra inicial e para a última (Char). O programa:
PROGRAM InicialEUltimaLetra;
uses CRT;

Inicial, Ultima : char;
begin
ClrScr;
Write('Entre um nome: ');
Readln(Nome);
Inicial := Nome[1];
Writeln('Inicial: ',Inicial, ', cujo código ASCII é ',
Ord(Inicial));
Ultima := Nome[Length(Nome)];
Writeln('Ultima: ', Ultima, ', cujo código ASCII é ', Ord(Ultima));
ReadKey;
end.
Prática 5.55 – Otimizando o uso de variáveis

Altere o programa InicialEUltimaLetra para fazer as mesmas coisas porém sem as variáveis Inicial e
Ultima. Teste-o para situações variadas.
Especificação 5.56 - Iniciais

Escreva um programa que lê nome e sobrenome, e mostra na tela as iniciais.
Especificação 5.57 - Finais

Reescreva o programa anterior para mostrar na tela as letras finais do nome e sobrenome (use a função
Length).
Especificação 5.58 - Componentes de data

Escrever um programa que lê uma data no formato ‘dd/mm/aa’ e mostra dia, mês e ano separados.
Especificação 5.59 - Sorteio da LBV

A LBV fez um sorteio cujos bilhetes continham números de 6 dígitos. O sorteio foi baseado nos dois
primeiros prêmios da loteria federal, sendo o número sorteado formado pelos três últimos dígitos do
primeiro e do segundo prêmio. Por exemplo, se o primeiro prêmio fosse 34.582 e o segundo 54.098, o
número da LBV seria 582.098. Escreva um programa que lê os dois prêmios e retorna o número sorteado
(use a função Copy).
Especificação 5.60 - Subcadeias

Escreva um programa que lê uma cadeia de caracteres de tamanho 20, separa-a em duas e mostra na tela
as duas metades.
Exercício 5.61 – Relembrando instruções de caracteres e cadeias

Associe cada procedimento ou função à sua finalidade. Assinale com um F os quadrados cujas instruções
são funções e por isto podem ser usados em expressões:
Upcase
 • Obter uma subcadeia
Concat
 • Obter o caractere correspondente a um código ASCII
Pos
 • Obter o código ASCII de um caractere
Length
 • Concatenar uma ou mais cadeias
Copy
 • Obter o tamanho de uma cadeia
FillChar
 • Pesquisar uma subcadeia em uma cadeia
Chr
 • Converter um caractere para maiúscula
Ord
 • Repetir um caractere
Pesquisa 5.62 – Chamando funções como procedimentos

No programa MostraTecla, a função ReadKey é chamada como função (dentro do Writeln) ou como
procedimento. Isto é permitido somente quando uma certa opção de compilação está ativada. Descubra no
menu Options/Compiler do Turbo Pascal qual é essa opção, desative-a, tente compilar o programa e
descreva o que ocorreu.
Especificação 5.63 – Animação vertical

Faça um programa que desenha um "O" a partir de uma linha e coluna lidas do teclado e depois faz o
seguinte 10 vezes, esperando uma tecla antes de cada vez (sempre na linha lida):
- apaga o "O" da coluna atual e o mostra na coluna seguinte
Especificação 5.64 - Animação horizontal

Elabore um programa semelhante ao anterior, mas variando a linha.
Especificação 5.65 - Metades de cadeia

Implemente um programa que lê uma cadeia de caracteres de tamanho até 255 e mostra na tela as metades
da cadeia. [Dica: basear os cálculos no tamanho da cadeia]
Especificação 5.66 - Música é linear?

A respeito do programa do parabéns (pág. 76), deseja-se saber se a melodia é preservada somando-se um
valor constante a cada freqüência. Faça um programa que lê esse valor (por exemplo, 100) e faz soar as
notas somando o valor a cada freqüência.
Pesquisa 5.67 – Mais comandos do debugger

Localize no seu ambiente de desenvolvimento Pascal os seguintes comandos:
a) Excluir uma variável da janela Watches (tente o botão direito do mouse)
b) Dividir a tela em duas janelas: a do programa e a das variáveis (menu Window)
c) Marcar um ponto de um programa para interrupção da execução (breakpoint)
d) Desmarcar breakpoint.
Prática 5.68 – Readln com boolean

Faça um pequeno programa de teste e investigue se uma variável do tipo boolean pode usada em uma
instrução Readln.
Pesquisa 5.69 – Inc

Em atribuições, ao invés de construções do tipo Quant := Quant + 1, você pode usar a instrução Inc (de
increment), que permite aumentar o valor de uma variável inteira. Pesquise na ajuda como usá-la e faça
um pequeno programa de demonstração.
110
.6 ALTERNATIVAS E DECISÃO
Imagine um programa que calcula raiz quadrada de um número qualquer, lido do teclado. Se o
usuário digitar um número negativo, ocorre um erro e o programa termina. Para que isso não ocorra, é
preciso que o programa verifique se o número é negativo e somente calcule a raiz se isso não ocorrer. Ou
inversamente, somente calcular a raiz se o número lido for maior ou igual a zero.
Assim como pessoas, programas que fazem verificações e tomam boas decisões são mais
produtivos. Veja neste capítulo como os programas podem fazer essas verificações e, com base no
resultado destas, executar ou não um bloco de instruções.
.6.1. Decisão e expressões lógicas: IF
Prática 6.1 – IF 1
a) Digite o programa abaixo, cuja especificação é a seguinte:
Elaborar um programa que lê um número qualquer e calcula sua raiz quadrada. O cálculo
somente é efetuado se o número for maior ou igual a zero. Se não for, é mostrada uma mensagem
de erro.
PROGRAM CalculaRaiz;
uses CRT;
var Num : real;
begin
ClrScr;
Writeln('Cálculo de raiz quadrada');
Write('Digite o número: ');
Readln(Num);
if Num >= 0 then
Write('A raiz de ', Num:0:2, ' é ', SqRt(Num):0:2 )
else
Write('Número inválido');
Write('Pressione qualquer tecla');
ReadKey;
end.
a) Execute o programa para os números 0, 3, -2.

b) Repita o passo anterior, desta vez usando o debugger.
7 - ALTERNATIVAS E DECISÃO 111
IF
O comando Pascal que permite execução condicional de instruções é o IF..THEN..ELSE, cuja
sintaxe é:
if <expressão lógica> then
<comando 1>
else
<comando 2>
Uma expressão lógica constitui uma comparação cujo valor pode ser somente Verdadeiro ou Falso
(True ou False, para o Turbo Pascal). Para a comparação usamos os operadores:
= (igual)
< (menor que)
> (maior que)
<= (menor ou igual)
>= (maior ou igual)
<> (diferente)
O comando if funciona assim: se a <expressão lógica> for verdadeira, é executado o comando após o
then, caso contrário (expressão é falsa), é executado o comando após o else. Veja um exemplo
simples:
if N >= 0 then
Write('N é positivo')
else
Write('N é negativo');
O comando acima será executado assim:
- O valor de N é recuperado da memória (suponhamos que foi 121);
- A expressão lógica 121 >= 0 é avaliada, sendo o resultado True (verdadeira);
- Como a expressão lógica após o if é verdadeira, será executado o comando que estiver após o then,
no caso é o primeiro Write;
- O fluxo de execução segue para o comando que estiver após a última instrução do else (o comando
após ou dentro deste é ignorado).
- Quando a expressão lógica após o if é avaliada como falsa (por exemplo, quando o valor de N for
-77), será executado o que estiver após o else, e o que estiver após o then é ignorado.
O comando if determina que ou serão executadas as instruções após o then ou as após o else, mas
nunca ambas as possibilidades, em uma mesma passagem do fluxo de execução.
Não coloque ponto-e-vírgula antes do else, você estará indicando para o

compilador que terminou o comando if, e ele não entenderá a cláusula
else.
Prática 6.2 – IF 2
a) Digite o programa abaixo, cuja especificação é a seguinte:
"O critério de notas de uma faculdade consiste de uma nota de 0 a 10 em cada bimestre, sendo a
primeira nota peso 2 e a segunda peso 3. Elabore um programa que lê as notas bimestrais e
calcula a nota do semestre. Se alguma nota lida estiver fora da faixa válida, é mostrada uma
mensagem de erro"
PROGRAM CalcNotaSemestral;
uses CRT;
var Nota1, Nota2 : real;
begin
ClrScr;
Writeln('Cálculo da nota final a partir das notas bimestrais, pesos 2 e 3.');
Readln(Nota1);
if (Nota1 >=0) and (Nota1 <=10) then
begin
Readln(Nota2);
if (Nota2 >=0) and (Nota2 <=10) then
Write('Nota final: ',((Nota1*2 + Nota2*3)/5):0:1)
else
Write('Nota inválida');
end
else
Write('Nota inválida');
Readkey;
end.
a) Execute o programa para as notas (7, 8), (11, ?), (8, 12).
begin e end
Se houver mais de um comando após then ou else, será necessário delimitar todos eles com
begin..end, que indicam um comando composto:
if N >= 0 then
begin
Write('N é positivo');
ReadKey;
end
else begin
Write('N é negativo');
ReadKey;
end;
Prática 6.3 – Erros de compilação do IF

Registre as mensagens de compilação para as seguintes situações no programa CalcNotaSemestral:
a) Retire um then
b) "Esqueça" de por um else
c) Ponha um ponto-e-vírgula antes do else
d) Ponha um ponto-e-vírgula após o then (esta situação é peculiar: o ponto-e-vírgula não causa erro,
porque não é necessário haver um comando após then ou else, mas este não será reconhecido por
estar sem um if)
e) Retire os parênteses de uma das expressões lógicas.
Exemplo 6.4 – Cálculo de conceito

Uma universidade atribui conceitos aos alunos com base na nota obtida em cada disciplina, segundo a
tabela abaixo. Escreva um programa que lê a nota e informa o conceito obtido.
NOTA CONCEITO
--------- ----------------
90..100 A
75..89 B
50..74 C
40..49 D
0..39 E
Agora há várias decisões a serem tomadas: se não for um conceito, pode ser o outro e assim por diante.
Veja o programa e as explicações a seguir:
PROGRAM CalculaConceito;
{ Lê uma nota de 0 a 100 e calcula o conceito: A, B, C, D ou E}
uses CRT;
var Nota : byte;

Conceito : char;
begin
ClrScr;
Write('Digite a nota:');
Readln(Nota);
if Nota > 100 then
Writeln('Nota inválida')
else
begin
if Nota >= 90 then
Conceito := 'A'
else if Nota >= 75 then
Conceito := 'B'
Conceito := 'C'
Conceito := 'D'
else
Conceito := 'E';
Writeln('O conceito é ', Conceito);
end;
Readkey
end.
Note na solução acima:

- Não é necessário testar se a nota é negativa, já que sua variável é do tipo byte;
- Testar a validade da nota antes permite simplificar as decisões seguintes (o limite superior de cada
faixa não é verificado)
- Foi declarada uma variável auxiliar para o conceito, para chamar Writeln somente uma vez. Se for
preciso alterar a forma como o conceito é mostrado, isso será feito em um comando somente.
- O else do primeiro if precisou do par begin..end, já que tem dois comandos: um if e um Writeln.
Prática 6.5 – CalculaConceito

Teste o programa CalculaConceito nas seguintes situações:
a) Nota inválida
b) Uma nota no meio de cada faixa de conceitos
c) Uma nota nos limites de cada faixa.
Combinação de expressões lógicas

Quando for necessário fazer uma ou mais verificações combinadas, como "N1 = 0 e N2 = 0", "N < 0
ou N > 9". podemos juntar duas ou mais expressões lógicas através dos conectivos lógicos and (e) e
or (ou). Para o operador and, uma expressão será verdadeira somente quando todas as expressões
que a compõem forem avaliadas como verdadeiras. Para o operador or, toda a expressão é verdadeira
quando qualquer uma das expressões resultar verdadeira. Eles podem ser usados em expressões
lógicas dos comandos if, while e qualquer outro que contenha expressões desse tipo. As expressões
parciais sempre têm de estar entre parênteses. Por exemplo:
Para saber se um número é de um dígito:
if (Numero >= 0) and (Numero <= 9) then {...}
No Pascal você não pode construir expressões lógicas do tipo 0 ≤ Numero ≥ 9, como na
Matemática; você deve usar and ou or.
Para verificar se uma variável caractere contém 'F' ou 'J':
if (TipoPessoa = 'F') or (TipoPessoa = 'J') then {...}
Verificar se um número está entre duas faixas: 0 a 100 ou 200 a 300:
if ((Num>0)and(Num<100))or(Num>200) and (Num<300)) then {...}
Um operador muito interessante e conciso é in, através do qual você verifica se um valor ou
resultado de expressão pertence a um conjunto, definido entre colchetes e no qual podem constar
valores ou faixas. Veja como os comandos acima ficam mais simples com esse operador:
if TipoPessoa in [ 'F', 'J' ] then ...
if Num in [ 0..100, 200..300 ] then ...
Prática 6.6 - And ou Or?

No programa CalcNotaSemestral, troque o primeiro and por or. Execute o programa para valores
inválidos e veja o que acontece.
Exercício 6.7 - In
Altere o comando abaixo para que aceite também as letras minúsculas correspondentes:
if TipoPessoa in [ 'F', 'J' ] then ...
Exercício 6.8 – Elaborando if

Elabore comandos if que façam o seguinte (invente nomes apropriados de variáveis):
a) Se pessoa é maior de idade, mostra mensagem apropriada.
b) Se aluno passou em uma disciplina, mostre na tela "Parabéns!", senão, "Dançou!".
c) Se a opção digitada é 'A', 'I' ou 'E', mostra mensagem de 'opção válida', senão, 'opção inválida'.
d) Se a temperatura está no intervalo de 0 a 100, informa 'estado líquido'.
Exercício 6.9 – Revisão do IF

Assinale V ou F:
( ) Há situações em que ambos os comandos após o then e o else são executados em seqüência.
( ) Antes de else sempre deve ter um ponto-e-vírgula.
( ) As expressões em ambos os lados dos operadores and e or devem estar entre parênteses.
( ) Se houver somente um comando após o then, não é necessário o par begin..end.
( ) Se houver mais de um comando após o else, é necessário o par begin..end.
Prática 6.10 – Compare

Abaixo foi repetido o trecho do programa acima, só que sem o desalinhamento das instruções
("indentação"). Apenas fique olhando para um e outro durante alguns segundos, como quem não quer
nada...
if Nota > 100 then
Writeln('Nota inválida')
else
begin
if Nota >= 90 then
Conceito := 'A'
Conceito := 'B'
Conceito := 'C'
Conceito := 'D'
else
Conceito := 'E';
Prática 6.11 – Watch em variáveis booleanas

Para variáveis booleanas ou lógicas, podemos atribuir somente os valores False ou True, diretamente ou
como resultado da avaliação de uma expressão lógica. Digite o programa abaixo e observe as variáveis
através da janela Watches do debugger.
var Passou, Terminou : boolean;
Nota : byte;
begin
Terminou := False;
Nota := 10;
Passou := Nota > 5;
Passou := Nota – 9 > 5;
Passou := Terminou;
End.
Exercício 6.12 – Revisão de expressões lógicas

Sobre expressões lógicas:
a) Para que servem? Qual tipo de valor resulta de sua avaliação?
b) Quais podem ser os operandos de expressões lógicas?
c) Descreva os operadores and e or. Dê exemplos de sua utilização em expressões lógicas
compostas.
d) O que é melhor do que a precedência de operadores para estabelecer a seqüência de operações?
Exercício 6.13 – Expressões lógicas inválidas

Marque com um X as expressões lógicas inválidas (N é do tipo real):
a) N <= 10
b) N >< 0
c) N = 3.1415
d) N => -1
e) 0 =< N <= 9
Exercício 6.14 – Elaborando expressões lógicas

Forneça expressões lógicas em PASCAL, utilizando variáveis, constantes e operadores de comparação
apropriados, que possam ser usadas para verificar as condições abaixo. Modelo:
Idade de uma pessoa é a mesma que a de outra pessoa
Resp: Idade1 = Idade2
a) Pessoa é maior de idade (mais que 17 anos)
b) Aluno passou em uma disciplina (nota mínima 7).
c) Média aritmética das notas de 3 disciplinas é superior a 7,5.
d) A opção digitada é 'A', 'I' ou 'E' (alterar, incluir, excluir)
e) Uma temperatura está no intervalo de 0 a 100
f) Um número está nos intervalos de 0 a 10 ou 20 a 30
Pesquisa 6.15 – Operador not

Descubra para que serve o operador lógico not e forneça dois exemplos de sua utilização.
Exercício 6.16 - Avalie

Com base na pesquisa acima e supondo que A = True, e B = C = False, avalie:
a) A and not B or C
b) (A and not C) or (not A and C)
c) A = False and (C or not B)
d) A or B or C
e) A and (B or C)
f) not A or not B
Pesquisa 6.17 - Ordem de execução das operações

Em uma expressão lógica podem aparecer diversos tipos de operadores, lógicos e aritméticos; em que
ordem são executadas as operações? Quando não houver parênteses que determinem uma seqüência de
execução, o compilador aplica as regras de precedência. Pesquise qual é essa precedência e preencha a
tabela abaixo:
PRECEDÊNCIA OPERADORES
1
2
3
4
5
6
Sugestão: use parênteses para definir a ordem de execução das operações

e durma tranqüilo.
Prática 6.18 – Equação do segundo grau

O programa abaixo, embora sintaticamente correto, não funciona corretamente. Corrija-o e teste-o para
equações com delta positivo, negativo e zero. O que acontece quando o delta é negativo? O que pode ser
feito para evitar o problema? Faça uma nova versão do programa com a correção.
uses CRT;
var a, b, c : integer;
Delta, Raiz1, Raiz2 : real;
begin
ClrScr;
Writeln('Cálculo de raízes da equação do segundo grau');
Writeln('Entre coeficientes inteiros a, b e c,');
Writeln('teclando Enter a cada um');
Readln(a); Readln(c); Readln(b);
Delta := b*b - 4*a*c;
Raiz1 := ( b + SqRt(Delta) )/2;
Raiz2 := ( b - SqRt(Delta) )/2;
end.
.6.2. Múltiplas alternativas: CASE
Prática 6.19 – Tipo de caractere

Execute o programa abaixo com e sem o debugger, fornecendo como entrada uma letra, depois um dígito,
um operador aritmético e finalmente um outro (#, $, etc.).
PROGRAM TipoCaractere;
{Lê um caractere e informa se é letra, dígito, operador aritmético ou nenhum deles}
uses CRT;
var Ch : char;
begin
ClrScr;
GotoXY(10, 8);
Writeln('Entre um caractere qualquer: ');
Readln(Ch);
case Ch of
'A'..'Z', 'a'..'z' : begin
GotoXY(10,10);
Writeln('Letra');
end;
'0'..'9' : begin
GotoXY(10,10);
Writeln('Dígito');
end;
'+', '-', '*', '/' : begin
GotoXY(10,10);
Writeln('Operador');
end;
else begin
GotoXY(10,10);
Writeln('Caractere especial');
end;
end;
Writeln('Pressione qualquer tecla');
ReadKey
end.
Case
Considere um trecho de programa que deve oferecer um menu de opções na tela. Se o usuário digitar
1, o programa faz algo; se 2, outra coisa, e assim por diante. Com base na opção do usuário, o
programa deve decidir o que fazer. Mas agora não são meramente dois caminhos; podem ser 3, 7 ou
dez alternativas.
Para esses casos, ao invés de usar o comando if, é melhor usar o comando case, que tem o seguinte
formato:
case <expressão> of
<caso 1> : <comando 1>;
<caso 2> : <comando 2>;
<caso 3> : begin
<comando 4>;
<comando 5>
end;
...
else
<comando 6>
end;
Em cada caso, você pode por uma constante (1, 'A'), várias constantes separadas por vírgulas ('A',
'B') ou subfaixas: 'a'..'z', 0..10; não pode por expressões ou variáveis. Os valores em cada caso devem
ser compatíveis com o tipo da expressão, que não pode ser real nem string. Se houver mais de um
comando em um caso, ele deve ter o seu próprio par begin..end.
Quando um comando case é executado, o valor da expressão é avaliado. Se seu valor for igual ao
caso 1, é executado o comando 1; se igual ao caso 2, é executado o comando 2, etc. Se não houver
igualdade, é executado o comando após o else. Este é opcional.
Se mais de um comando precisa ser executado em algum caso, você deve usar o comando composto
begin..end, um para cada caso e também um par para o else.
Múltiplas instruções if podem ficar melhor codificadas através de um comando case, quando o tipo
da expressão lógica permitir.
Exemplo 6.20 – Calculadora

A calculadora de Luciana pifou, justo quando ela precisa fazer vários cálculos. Ela tem um computador,
mas não sabe que um dos acessórios do Windows é uma calculadora. Sendo estudante de Pascal,
Luciana resolveu fazer um programa. A especificação que bolou prevê que programa lê dois números
inteiros (o que atende suas necessidades) e em seguida um caractere. Se este for '+', o programa soma os
números, se '–', subtrai, se '*', multiplica e se '/', divide. Se o caractere for diferentes desses, é mostrada
uma mensagem de erro. O programa, antes de dividir, critica se o divisor é zero e mostra uma
mensagem, se for. Implemente a especificação de Luciana.
Como se parece a tela de saída do programa? Vamos “executá-lo” algumas vezes para várias
possibilidades:
Entre dois números inteiros:
40 34
Entre operação (+, -, * ou /):
+
40 + 34 = 74

50 45
X
Erro: operação inválida

32 0
/
Erro: divisor inválido
O próximo passo é identificar as variáveis. Para a entrada precisamos de duas variáveis inteiras para
armazenar os números e uma do tipo char para armazenar a operação. Para a saída não precisaremos de
variáveis, já que podemos calcular e mostrar o resultado diretamente na tela. Observando a tela de saída,
verificamos que o programa está estruturado da seguinte forma:
"Ler números"
"Ler operação"
"Decidir qual operação será efetuada e mostrar o resultado na tela ou uma mensagem de erro"
Veja o programa a seguir. Como exercício, execute-o manualmente para as entradas usadas no
detalhamento da tela e verifique se a tela de saída produzida está correta.
PROGRAM Calc4Operacoes;
{Lê dois números reais e uma operação, e efetua a operação indicada}
uses CRT;
var N1, N2 :integer;

Op : char;
begin
ClrScr;
Writeln('Entre dois números inteiros:');
Readln(N1, N2);
Writeln('Entre operação (+, -, * ou /):');
Readln(Op);
case Op of
'+' : Writeln(N1, ' + ', N2, ' = ', N1 + N2);
'-' : Writeln(N1, ' - ', N2, ' = ', N1 - N2);
'*' : Writeln(N1, ' x ', N2, ' = ', N1 * N2);
'/' : if N2 <> 0 then
Writeln(N1, ' / ', N2, ' = ', N1 / N2)
else
Writeln('Erro: divisor inválido')
else
Writeln('Erro: operação inválida');
end;
ReadKey;
end.
Prática 6.21 – CalcOperacoes

Teste o programa CalcOperacoes nas seguintes situações:
a) Adição
b) Subtração
c) Multiplicação
d) Divisão, divisor válido
e) Divisão, divisor inválido
Ao projetar programas, preveja todas as situações e alternativas, e ao

testar programas com comandos de decisão, teste todos os caminhos
possíveis do fluxo de execução.
Prática 6.22 – Erros de compilação do case

Verifique a mensagem de erro de compilação nas seguintes situações:
• retire o case
• retire o of
• retire o Ch do case Ch of
• retire um dois-pontos de algum caso
• retire o end do case
• troque a expressão após o case por uma variável real qualquer
• idem, variável tipo string
Exercício 6.23 - Tipos de expressões do Case

Que tipos de expressões você pode e quais não pode inserir como opções (casos) em um comando CASE?
Prática 6.24 – Códigos ASCII

Altere o programa ExemploMenu abaixo para que a opção 1 seja ler um caractere e mostrar seu código
ASCII (função Ord) e a opção 2 seja ler um código ASCII e mostrar o respectivo caractere (função Chr).
Implemente o código adequado para tratar as opções e teste o programa.
PROGRAM ExemploMenu;
uses CRT;
var Opcao : char;
begin
ClrScr;
Writeln('1 – Ação 1');
Writeln('3 – Fim');
Write('Entre opção: ');
Readln(Opcao);
case Opcao of
'1' : {Ação 1};
'2' : {Ação 2};
else begin
Writeln("Opção inválida");
ReadKey
end
end;
end.
.6.3. Reconhecendo decisões
Comandos de decisão são necessários quando há alternativas para o fluxo de execução. É como
uma estrada: se não há encruzilhadas ou trevos, você vai seguindo sem precisar decidir nada sobre o rumo
a tomar, mas se há opções, uma decisão deve ser tomada.
Dicas e perguntas para reconhecer a necessidade de um comando IF ou CASE, na especificação,

no projeto ou na implementação:
- A especificação normalmente contém indicações: "se o número for inválido...", "um menu...".
- Cada entrada de dados cria alternativas. Criticá-las ou não pode depender da especificação.
- Há decisão neste programa?
- Que verificações e restrições são pedidas na especificação ou necessárias neste programa?
- Que valores inválidos podem ser digitados?
- Que tipo de ocorrência pode provocar um erro em tempo de execução?
- Posso usar o comando CASE? Se sim, qual é o mais simples de usar, IF ou CASE? Qual deles
organiza melhor o código? Qual fica mais elegante?
Especificação 6.25 – CalculaConceito com case

Altere o programa CalculaConceito, deste capítulo, para escolher o conceito usando case, ao invés de if.
Especificação 6.26 - Maior de 2

Elaborar programa que lê dois números quaisquer e mostra na tela uma mensagem indicando qual é o
maior, ou se são iguais.

Faça um programa que lê três números diferentes e mostra na tela uma mensagem indicando qual é o
maior.
Especificação 6.28 - Divisão

Escrever um programa que lê dois números e efetua uma divisão, mas somente se o divisor for diferente
de zero; quando isto ocorrer, é mostrada uma mensagem de erro apropriada.
Especificação 6.29 - Categoria de altura

Elaborar programa que lê uma altura e mostra uma mensagem conforme a faixa de altura:
menos que 1,60 “baixinho”
de 1,60 a 1,85 “altura normal”
mais que 1,85 “faz frio aí em cima?”
Especificação 6.30 - Aprovação

Elaborar programa que lê uma disciplina e respectiva nota final, múltipla de 0,5, e informa o que ocorreu.
Se a nota for de 5 a 10, aprovado; se 4 ou 4,5, segunda época e, caso contrário, reprovado.
Especificação 6.31 - Aprovação v2

Altere o programa acima para que, se a nota estiver fora da faixa válida ou se não for múltipla de 0,5, seja
emitida uma mensagem de erro.
Especificação 6.32 - Aprovação v3

Altere o programa acima para que leia também a quantidade de aulas ministradas e a quantidade de faltas
do aluno. Se o aluno não obteve 75% de freqüência, ele está reprovado, independentemente da nota.
Especificação 6.33 - Dia da semana

Construa um programa que lê um número de 1 a 7 e informa o dia da semana correspondente, sendo
domingo o dia de número 1. Se o número não corresponder a um dia da semana, é mostrada uma
mensagem de erro.
Especificação 6.34 - Quadrado ou triângulo

Implemente um programa com 2 opções (letra ou número): desenhar um quadrado ou um triângulo na
tela, em linha e coluna lidas pelo teclado. Elabore o quadrado e o triângulo como achar melhor. Faça o
programa mostrar uma mensagem de erro se o usuário escolher uma opção inválida ou informar valor
inválido para linha ou coluna.
Especificação 6.35 - Conta telefônica

valor de impulsos: R$ 0,04 por impulso que exceder a 90
valor de chamadas p/ celular: R$0,09 por impulso
Elabore um programa que lê valor de interurbanos, quantidade total de impulsos normais e para celular, e
calcula o valor da conta. Lembre-se de que o valor dos impulsos só é cobrado para os impulsos
excedentes.
Especificação 6.36 - Imposto

de 1.201,00 a 2.500,00 10%
de 2.501,00 a 5.000,00 15%
acima de 5.000,00 20%.
Implemente um programa que leia o valor base e calcule o imposto a pagar.
Especificação 6.37 - Múltipla escolha 1

Elaborar uma questão de múltipla escolha, de uma disciplina que esteja cursando ou um tema de
interesse, com um enunciado e cinco alternativas, sendo uma correta ou incorreta. Escrever um programa
que mostra a questão na tela, pede a resposta correta e informa ao usuário se este acertou ou errou. Antes
de decidir qual questão usará, elabore pelo menos três possibilidades.
Especificação 6.38 - Múltipla escolha 2

Enriqueça o programa acima da questão de múltipla escolha, incluindo uma outra questão de outro tema.
No início do programa, ofereça ao usuário a escolha de qual questão quer responder.
Especificação 6.39 - Salário

Um salário tem os seguintes componentes:
- valor nominal
- adicional devido a horas extras
- valor descontado para o INSS (10% do valor a receber, limitado a 150 reais).
O valor adicional devido às horas extras é calculado dividindo-se o valor nominal por 176 (22 dias de 8
horas), multiplicando-se pela quantidade de horas e ainda com um acréscimo de 50%.
Escrever um programa que lê os valores necessários, calcula e mostra na tela os componentes do salário e
o salário líquido resultante para o empregado. Não é preciso prever arredondamentos, mas os valores
devem ser mostrados na tela com duas casas decimais.
Exemplos: para um salário de R$ 1.000,00, com 30 horas extras, teremos R$ 255,68 de horas extras
[(1.000/176)*30*1,5], R$ 125,57 de INSS e um salário líquido de R$ 1.130,11. Para um salário de R$
2.000,00 e 20 horas extras, seriam R$ 340,91 de horas extras, R$ 150,00 de INSS (e não os 10%), com
um salário líquido de R$ 2.190,91.
Especificação 6.40 - Adivinhe 1

Faça um programa que sorteia um número de 1 a 5 e pede ao usuário que o adivinhe, lendo do teclado o
palpite. Caso o usuário acerte ou não, é mostrada uma mensagem apropriada.

Modifique o programa acima para que o usuário possa tentar novamente se errar na primeira vez.
Especificação 6.42 - Nota musical

Elaborar um programa que lê uma freqüência em Hertz e uma duração em milissegundos e emite um som
na freqüência com a duração. Limite a freqüência até 5.000 Hz e a duração a 2 segundos.
.6.4. Organizando o pensamento: árvores de decisão
Quando várias decisões têm que ser tomadas, pode ocorrer que não consigamos organizar
mentalmente todas elas; nesses casos, uma ótima ferramenta é uma árvore de decisão, descrita no
exemplo abaixo.
Exemplo 6.43 – Árvore de decisão

Um jogo consiste em se retirar duas bolas de uma caixa contendo bolas brancas e pretas. Dependendo
da combinação de cores das bolas retiradas, o jogador será pago na seguinte proporção:
Primeira Bola Segunda Bola Rateio
Branca Branca 0
Branca Preta 2/3
Preta Branca 1
Preta Preta 2
Ou seja, com duas bolas brancas o jogador perde tudo, com uma branca e uma preta recebe 2/3 do que
apostou, com um preta e uma branca recebe seu dinheiro de volta e com duas pretas recebe o dobro.
Elaborar um programa que lê as cores das duas bolas e calcula o rateio.
O passo principal do programa é, a partir das cores das duas bolas (variáveis Cor1, Cor2), deduzir o valor
do rateio (variável Rateio). Definimos que as cores serão representadas por 'P' ou 'B', conforme cada bola
seja preta ou branca, respectivamente. Podemos escrever um if para cada linha da tabela acima, como:
if (Cor1 = 'B') and (Cor2 = 'B') then
Rateio := 0
else if (Cor1 = 'B') and (Cor2 = 'P')
Rateio := 2/3
{...}
Codificar expressões complexas dessa maneira pode ser trabalhoso e sujeito a erros. A forma de tratar
gradualmente a solução é montar uma árvore de decisão, na qual organizamos as várias possibilidades.
Escrevemos a primeira decisão, com as opções Sim e Não. Depois, para a opção Sim, escrevemos a
próxima decisão e suas opções Sim e Não. Assim vamos detalhando cada possibilidade, até que cada
ramo tenha uma ação associada:
nada
Sim
Cor2 é branca?
Sim
Não 2/3
Cor1 é branca?
Sim 1
Não
Cor2 é branca?
Não 2
Para converter para Pascal, basta traduzir a árvore em comandos if..then..else: cada pergunta
resultará em um comando if; a cada 'sim' corresponde um then e cada 'não' estará associado a uma
cláusula else. Teremos o seguinte trecho de programa:
if Cor1 = 'B' then
if Cor2 = 'B' then
Rateio := 0 {branca, branca}
else
Rateio := 2/3 {branca, preta}
else
if Cor2 = 'B' then
Rateio := 1 {preta, branca}
else
Rateio := 2; {preta, preta}
Exercício 6.44 – Árvore para o TipoCaractere

Elaborar uma árvore de decisão para o algoritmo do programa TipoCaractere, deste capítulo
Especificação 6.45 - Jogo de bolas

Conforme a especificação do exemplo deste capítulo, implemente um programa que lê as cores das duas
bolas e calcula o rateio.
Especificação 6.46 - Jogo de bolas v2

Altere o programa anterior para que leia também o valor apostado, limitado a $100, e informe o valor a
ser recebido pelo apostador.
Especificação 6.47 - Jogo de bolas v3

Modifique o programa do jogo de retirada de bolas, de forma que o jogador retire três bolas. Atribua
valores de rateio para todas as combinações de cores. Implemente um programa que lê o valor apostado,
sorteia as cores, calcula o rateio obtido pelo jogador e o valor que ele receberá.
Especificação 6.48 - Menor cadeia

Escrever uma função que recebe duas cadeias de caracteres e retorna a menor em ordem alfabética.
Especificação 6.49 - Ano bissexto

Um ano é bissexto se for divisível por 4 exceto os séculos, que são bissextos se forem múltiplos de 400.
Escreva um programa que determina se um ano é bissexto.
Especificação 6.50 – Códigos estendidos de teclas

Você viu na página (programa MostraTecla) que a função ReadKey retorna, para certas teclas, dois
códigos, sendo o primeiro Chr(0), para o qual não há código correspondente. Faça um pequeno programa
para mostrar códigos ASCII de teclas: se o primeiro código for diferente de zero, a tecla lida é mostrada,
caso contrário o segundo código é lido e mostrado. Usando este programa, ache os códigos estendidos das
quatro teclas de direção (as setas, muito usadas em jogos).
Especificação 6.51 - Menção

Uma faculdade atribui menções aos alunos conforme a faixa de notas que tenha atingido:
9,0 a 10: SS (superior)
7,0 a 8,9: MS (médio superior)
5, 0 a 6,9: MM (médio)
3,0 a 4,9: MI (médio inferior)
0,1 a 2,9: II (inferior)
0: SR (sem rendimento).
Faça um programa que lê a nota e calcula a menção. [Dica: como o comando case não aceita expressões
reais, a princípio você deve usar if; mas você ainda pode usar o case, se multiplicar por 10 todos os
números envolvidos]
Pesquisa 6.52 – Operadores aplicados a strings

Investigue se operadores >, >=, etc. podem ser aplicados a variáveis e constantes string. Faça um pequeno
programa que demonstre isso.
Especificação 6.53 - Imposto em cascata

de 1.201,00 a 2.500,00 10%
de 2.501,00 a 5.000,00 15%
acima de 5.000,00 20%.
Implemente um programa que leia o valor base e calcule o imposto a pagar. A diferença agora é que o
imposto é calculado em cascata, isto é, de um salário de 10.000, os primeiros 1.200 estão isentos, a faixa
de 1.201 a 2500 paga 10% e assim por diante.
Prática 6.54 – Pos: pesquisando em cadeias

Se é preciso verificar se uma cadeia está presente em outra, pode-se usar a função Pos. Ela recebe a
subcadeia a pesquisar e a cadeia onde será pesquisada a subcadeia, retornando um valor do tipo byte
indicando a primeira posição da cadeia (da esquerda para a direita) onde foi encontrada a subcadeia ou
zero, se nada foi encontrado. Por exemplo, para testar se a variável Nome possui um espaço, escreva:
if Pos(' ', S) > 0 then ...
Uma das utilidades de Pos é em validações de entrada, como no exemplo abaixo.
Elaborar um trecho de programa para criticar se o valor da variável Op está correta. Os valores
permitidos são '+',' '-',' *' e '/'.
Solução:
if Pos(Op, '+-/*') = 0 then
Write('Operação inválida')
else
{...}
Elabore um programa para testar o trecho do exemplo acima. O programa efetua as operações
matemáticas indicadas.
Prática 6.55 - Cadeias para números: Val

Como vimos, para o compilador um número é diferente de uma cadeia. Eventualmente, em programas,
precisamos converter um valor expresso como uma cadeia de caracteres em um tipo de dado numérico.
Para isso usamos o procedimento Val, que recebe uma string contendo a cadeia que representa o número
(como '-233.54'), uma variável inteira ou real para receber o número convertido e uma outra variável do
tipo integer para receber um código de erro, como em:
Val(VarString, VarNumerica, PosErro);
Se a string passada não for um número válido (como '12,1,3' ou 'a2b2'), a variável PosErro conterá a
posição onde o erro foi descoberto, caso contrário será zero.
Uma situação útil para usar Val é quando se quer evitar que um programa pare quando é lido um valor
inválido para uma variável numérica. Neste caso, pode-se ler o valor como string e convertê-lo para
número.
a) Digite o programa a seguir.
PROGRAM VerificaData;
{lê uma data no formato 'dd/mm/aaaa' e verifica se o dia está entre 1 e 31 e o
mês está entre 1 e 12}
uses CRT;
var Data : string[10];

Dia, Mes : byte;
Erro : integer;
begin
Write('Entre data no formato dd/mm/aaaa: '); Readln(Data);
Val(Copy(Data,1,2), Dia, Erro); {Converte dia para numérico}
if Erro = 0 then
begin
Val(Copy(Data,4,2), Mes, Erro); {Converte mês para numérico}
if Erro = 0 then
begin
if (Dia >= 1) and (Dia <= 31) then
{verifica validade do dia e do mês}
if (Mes >= 1) and (Mes <= 12) then
Writeln('Data válida')
else Writeln('Mês inválido')
else Writeln('Dia inválido')
end
else Writeln('Erro no mês')
end
else Writeln('Erro no dia');
end.
b) Teste o programa para as seguintes situações:

− Data válida
− Dia não numérico
− Mês não numérico
− Dia inválido
− Mês inválido
− Barras fora de posição
c) Altere o programa para que verifique também se há barras (/) na terceira e na sexta posições.
Especificação 6.56 - Atenção

Pesquise o que faz o procedimento Delete. Execute manualmente o programa abaixo e informe os valores
assumidos pelas variáveis S, P e N durante a execução do programa. Na tabela de variáveis, tachar um
valor quando for substituído por outro. Onde se lê '999', troque pelos três últimos dígitos do seu número
de matrícula. Depois digite o programa e verifique se acertou.
PROGRAM PraticaCaracteres;
var S : string;
I, P, N : byte;
C : integer;
begin
S := 'Questao 1';
Insert(' ',S, Length(S)+1);
S := S + '999';
for I := 2 to 5 do S[I] := Upcase(S[I]);
Delete(S, Length(S)- 1, 2);
P := Pos('1', S);
if P > 0 then
begin
Val(Copy(S, P+2, 1), N, C);
if (C = 0) and (N <> 0) then
Delete(S, N, 1);
end;
end.
Prática 6.57 - Números para cadeias: Str

O procedimento Str permite converter números inteiros e reais em cadeias de caracteres (strings),
inclusive formatando números reais da mesma maneira que Writeln. Str recebe dois parâmetros: o
número ou uma variável numérica e uma variável string que recebe o valor convertido. Veja os
exemplos:
begin
Str(2, S); {S conterá '2');
Str(2.1, S); {S conterá ' 2.1000000000E+00');
Str(2.1:4:2:, S); {S conterá ' 2.10');
end.
Faça um pequeno programa para testar o funcionamento da instrução Str (leia/calcule/mostre) e alimente-
o com valores variados.
129
.7 REPETIÇÃO
Todo programa realmente útil precisa repetir uma ou mais instruções. Veja neste capítulo as três
opções do Turbo Pascal para repetição controlada de um bloco de comandos.
O Turbo Pascal possui três opções de comandos de repetição:
while..do: quantidade indefinida de vezes.
repeat..until: quantidade indefinida de vezes, executa pelo menos uma vez.
for..do: quantidade definida de vezes.
Veremos o while primeiro. Ele serve para todas as situações, os outros são maneiras melhores
para situações particulares.
.7.1. While
Prática 7.1 – Primeiro contato

a) Digite o programa abaixo, que é semelhante ao do capítulo anterior acrescido de um comando de
repetição.
PROGRAM CalculaRaiz;
{repetidamente calcula raiz quadrada, terminando quando lido zero}
uses CRT;
var Num : real;
begin
ClrScr;
Num := 1;
while Num <> 0 do
begin
Readln(Num);
if Num >= 0 then
Writeln('A raiz de ', Num:0:2, ' é ', SqRt(Num):0:2 )
else
Writeln('Número inválido');
end;
end.
a) Execute o programa para os números 2, -1 e 0 para terminar.

Prática 7.2 – Segundo contato

Digite o programa abaixo e execute-o sem e com o debugger, para algumas entradas. Se necessário, veja
algumas explicações sobre o algoritmo a seguir.
PROGRAM ObtemPrenome;
{Lê um nome completo e mostra na tela o prenome, isto é, o primeiro nome.
Assume que o nome nunca começa com um espaço}
uses CRT;

Ap : byte;
begin
ClrScr;
Writeln('Entre um nome completo:');
Readln(Nome);
Ap := 1;
{procura posição do primeiro espaço}
while (Nome[Ap] <> ' ') and (Ap < Length(Nome)) do
Ap := Ap + 1;
{obtém subcadeia do primeiro caractere até
a posição encontrada e mostra-a na tela}
Writeln('O prenome: ', Copy(Nome, 1, Ap - 1));
end.
O primeiro nome é formado pelas primeiras letras do nome, até o primeiro espaço. Uma variável
armazenar o nome lido. Para localizar a posição do primeiro espaço do nome, é usando um apontador
(inteiro). Iniciando em 1, variamos o apontador até a posição do primeiro espaço, através de um comando
while. Sabendo onde o espaço está, usamos a função Copy para obter os caracteres do nome até o espaço
(sem incluí-lo).
Observe que o apontador Ap foi limitado também pelo tamanho máximo do nome, para o caso em que
não houver sobrenome.
While
O while (enquanto) é o comando de controle de repetição que serve para qualquer situação. Sintaxe:
while <expressão lógica> do
begin
<comandos>;
end;
O comando funciona assim: quando no fluxo de execução é encontrado um while, a <expressão
lógica> é avaliada; se for verdadeira, os <comandos> após o do são executados e o fluxo retorna
para reavaliar a expressão lógica; se for falsa, é executado o que estiver após o end. Ou seja,
enquanto a expressão lógica for verdadeira, os comandos internos vão ser repetidos.
Na expressão lógica que vem depois do while pode-se usar os mesmos operadores descritos para o
comando if: =, <, <=, >, >= e <>, além dos conectivos lógicos and, or e not e do operador in.
Prática 7.3 – Entrada no While

Para que um comando While seja executado, na primeira vez a expressão lógica deve ser verdadeira, e é
por isto que no programa CalculaRaiz acima foi atribuído um valor diferente de zero. Retire a atribuição
N := 1 e veja o que acontece.
8 - REPETIÇÃO 131
Exercício 7.4 – Números na tela

Um programador deve programar o seguinte trecho de especificação:
"...mostrar na tela os números inteiros de 1 a 10".
Identifique qual das opções abaixo atendem à especificação:
a) N := 1;
while N <= 10 do
begin
Write(N);
N := N + 1
end;
a) N := 0;
while N < 10 do
begin
N := N + 1
Write(N, ' ');
end;
a) N := 1;
while N < 10 do
begin
Write(N, ' ');
N := N + 1
end;
a) N := 1;
while N <= 10 do
Write(N, ' ');
Prática 7.5 – Insira while

Ao usar o programa EqSegundoGrau, abaixo, o usuário deve reexecutá-lo para cada equação. Inclua um
comando while para que o programa volte para novo cálculo sempre que algum coeficiente seja diferente
de zero, ou seja, o programa termina quando todos os valores lidos forem zero. Para isso, faça o seguinte:
a) Determine as instruções que serão repetidas.
b) Determine a expressão lógica do while. Considere a primeira que achar que é, depois você vai
verificá-la.
c) Escreva o while, o begin e o end e faça uma verificação manual. Se achar que está em ordem,
teste o programa para alguns cálculos.
uses CRT;
var a, b, c : integer;
Delta, Raiz1, Raiz2 : real;
begin
ClrScr;
Writeln('Cálculo de raízes da equação do segundo grau');
Writeln('Entre coeficientes inteiros a, b e c,');
Readln(a, b, c);
Raiz1 := ( -b + SqRt(Delta) )/2*a;
Raiz2 := ( -b - SqRt(Delta) )/2*a;
end.
.7.2. Repeat
Prática 7.6 – Conhecendo o REPEAT

Digite o programa abaixo sem e com o debugger, observando o retorno do fluxo de execução e a saída do
ciclo.
PROGRAM RaizQuadradaComRepeat;
{repetidamente calcula raiz quadrada, terminando quando lido zero}
uses CRT;
var Num : real;
begin
ClrScr;
repeat
Write('Digite o n£mero: ');
Readln(Num);
if Num > 0 then
Writeln('A raiz de ', Num:0:2, ' é ', SqRt(Num):0:2 )
else
Writeln('Número inválido');
until N = 0;
end.
Prática 7.7 – Erros de compilação do repeat

Erros às vezes difíceis de descobrir estão relacionados às palavras reservadas. Experimente compilar o
programa acima nas seguintes situações:
a) Escreva errado o repeat
b) sem o repeat
c) sem o until
d) sem a expressão lógica do until
e) troque until por até
f) coloque o until antes do else
8 - REPETIÇÃO 133
Prática 7.8 – Ponto-e-vírgula e REPEAT

Verifique:
a) Se faz diferença por um ponto-e-vírgula após o repeat.
b) Se o ponto-e-vírgula antes de until é opcional.
Repeat
A diferença do comando repeat para o while é que no primeiro as instruções internas serão
executadas pelo menos uma vez. O comando repeat tem a forma
repeat
<comando 1>;
<comando 2>;
...
until <expressão lógica>;
Quando é encontrado um comando repeat, são executados os comandos até o until. A expressão
lógica deste é então avaliada; se for falsa, o fluxo de execução retorna para a instrução após o
repeat; se for verdadeira, o comando de repetição é encerrado e é executada a instrução após o
until, se houver alguma.
Aspectos a destacar no comando repeat:
- as instruções internas ao comando são executadas pelo menos uma vez;
- a decisão de repetir ou parar é tomada após a execução das instruções dentro do comando;
- o comando é encerrado quando a expressão for verdadeira;
- não é preciso inserir o comando composto begin..end quando houver mais de uma instrução a
repetir.
Prática 7.9 – Mais REPEAT

Altere o programa abaixo para que somente calcule a divisão se o Numero2 for diferente de zero. Teste-o
com números variados, incluindo a condição de saída.
PROGRAM Aritmetica;
{repetidamente lê dois números e calcula e mostra na tela sua soma, subtração,
multiplicação e Divisao}
var Numero1, Numero2 : integer;
begin
repeat
Write('Digite o primeiro número: '); Readln(Numero1);
Write('Digite o segundo número: '); Readln(Numero2);
if numero1 <> 0 then
begin
Writeln (Numero1+Numero2);
Writeln (Numero1-Numero2);
Writeln (Numero1* Numero2);
Writeln (Numero1/Numero2)
end
until Numero1=0
end.
Prática 7.10 – Melhorando para o usuário

No programa Aritmética acima, mesmo quando o usuário deseja encerrar o programa, é obrigado a digitar
um valor para o segundo número. Altere o programa para que ele não precise fazer isto.
.7.3. For
Quando sabemos a quantidade de repetições, seja uma constante, o valor de uma variável ou um
valor calculado, é mais simples usar o comando FOR. A sintaxe deste comando inclui uma variável de
controle, que é incrementada ou decrementada automaticamente, conforme usemos FOR..TO ou
FOR..DOWNTO.
Prática 7.11 – FOR..TO

Digite e execute o programa abaixo, inicialmente sem o debugger, depois com ele. Ao executar o
comando for, observe as variáveis N, NumIni e NumFim na janela Watches. Se necessário, confira as
explicações em seguida.
PROGRAM Numerador;
{Lê o número inicial e o final e mostra na tela os números inteiros do inicial
até o final. Se o número final for menor que o inicial, é mostrada uma mensagem
de erro}
uses CRT;
var NumIni, NumFim, N : integer;
begin
ClrScr;
Write('Entre números inicial e final: ');
Readln(NumIni, NumFim);
if NumIni < NumFim then
for N := NumIni to NumFim do
Write(N, ' ')
else
Writeln('O número final deve ser maior que o inicial');
end.
Esclarecimentos: As variáveis NumIni e NumFim armazenam os números fornecidos pelo

teclado. A instrução a repetir é imprimir um número com um espaço depois. Precisamos também de uma
variável que vá de NumIni até NumFim. Como esta variável varia de 1 em 1, e sabemos a quantidade de
repetições (NumFim - NumIni + 1), podemos usar o comando for.
O programa acima é executado assim:
• a primeira ação executada é a limpeza da tela;
• é mostrada a mensagem que pede os números;
• os números são lidos e armazenados nas variáveis NumIni e NumFim; suponha que foram digitados os
valores 100 e 200;
• como o número inicial é menor que o final, a expressão do if é verdadeira e o fluxo de execução segue
para o comando após o then;
• no início da execução do comando for, é atribuído 100 à variável N;
• em seguida, o valor de N é comparado com o conteúdo da variável NumFim, que é 200. Como é menor, o
fluxo de execução segue para o comando após o do;
8 - REPETIÇÃO 135
• é mostrado o valor de N, que é 100, seguido do espaço;
• a variável de controle N é incrementada de 1 unidade (automaticamente; não há instrução explícita para

isso), passando a valer 101;
• novamente é avaliado se N <= NumFim. Como N contém 101 e NumFim contém 200, novamente é
executado o Write;
• isto se repete (incrementa, mostra) até N = 201; como agora N é maior do que o valor final, o comando
após o do não é executado e o fluxo de execução segue para a instrução após o fim do comando for, que é
o fim do programa.
FOR
Neste comando de repetição escolhemos uma variável de controle e informamos o seu valor inicial e
seu valor final. O compilador se incumbe de atualizar o valor da variável de controle (de 1 em 1 ou
de -1 em -1) a cada iteração, e compara seu valor com o valor final indicado. Tipicamente este
comando será usado quando soubermos a quantidade de iterações (constante ou uma variável) ou ela
puder ser calculada. A sintaxe:
for <variável> := <valor inicial> to {ou downto} <valor final> do
begin
<comando 1>;
<comando 2>;
...
end;
A variável do for (variável de controle) deve ter sido declarada e normalmente é de um tipo inteiro
(há outras possibilidades, que não nos interessam aqui). No caso de ser usado to, quando um
comando for é encontrado no fluxo de execução:
- à variável de controle é atribuído o resultado da expressão correspondente ao valor inicial
e seu valor é comparado com o resultado da avaliação da expressão que indica o valor final;
- se o valor inicial é menor ou igual ao valor final, as instruções após o do são executadas, e
automaticamente a variável de controle é incrementada de uma unidade, e novamente o valor da
variável é comparado com o valor final.
- se o valor inicial é maior que o valor final, nenhuma instrução após o do é executada, e o fluxo
segue para a próxima instrução.
- se houver só um comando após o do, não é necessário o par begin..end. Exemplos:
for GrauCelsius := 0 to 100 do
Write (GrauCelsius, ' ');
for I := Num to Num*4 do

X := X + Y;
for X := -10 to 10 do
begin
Writeln(X);
Writeln
end;
Quando usado downto, as diferenças são: o valor final deve ser menor que o inicial, a variável de
controle é decrementada de uma unidade, e o teste verifica se o valor da variável é menor que o
valor final.
Prática 7.12 – FOR..DOWNTO

Execute o pequeno programa abaixo e verifique com o debugger como funciona o comando for com
downto. A tela produzida pelo programa é esta:
10 9 8 7 6 5 4 3 2 1
PROGRAM ContaDe10Ate1;
{Mostra os números inteiros de 10 até 1}
uses CRT;
var N : byte;
begin
ClrScr;
for N := 10 downto 1 do
Write(N, ' ')
end.
Uso do FOR
Quando usamos for? Este será útil quando soubermos, no momento da

programação, quantas vezes o trecho irá se repetir, seja se for um número
constante de vezes, ou a quantidade de iterações estiver disponível em uma
variável, e também a variável de controle varia de 1 unidade de cada vez.
Esse é o caso do programa do numerador: antecipadamente sabemos que
a instrução Write será executada (NumFim - NumIni + 1) vezes e, apesar
de podermos usar qualquer um dos comandos de repetição, o for é mais
apropriado.
O comando for resulta em instruções mais simples e deve ser usado

sempre que a quantidade de iterações for conhecida e a variável de
controle variar de 1 em 1. Neste comando, em outras linguagens, é
permitido indicar o passo (variação da variável de controle). No Pascal
padrão o passo será sempre 1 ou -1; se diferente, você deverá usar outro
comando de repetição.
Prática 7.13 – Preenchendo a tela

Execute o programa abaixo, observando os valores das variáveis de controle dos comandos for. Para
agilizar a execução em algum ponto, você pode usar o comando F4 do debugger (go to cursor): posicione
o cursor e tecle F4 e o debugger executará o programa até parar na linha do cursor.
8 - REPETIÇÃO 137
PROGRAM PreencheTela;
{Preenche 24 linhas da tela com um caractere lido, enquanto emite sons com
freqüência crescente de 1 em 1, a partir de 100 e uma duração de 20
milissegundos. Não execute se houver alguém dormindo, é insuportável...}
uses CRT;
const Tempo = 20;
var Ch : char;
Freq : word;
L, C : byte;
begin
ClrScr;
Writeln('Entre um caractere:');
Readln(Ch);
ClrScr;
Freq := 100;
for L := 1 to 24 do
for C := 1 to 80 do
begin
GotoXY(C,L); Write(Ch);
Sound(Freq); Delay(Tempo); NoSound;
Freq := Freq + 1;
end;
ReadKey;
end.
Explicações: para este programa precisamos de dois comandos de repetição, uma para apontar cada linha
e outra para cada coluna. Para cada linha percorremos todas as colunas. Como sabemos quantas iterações
ocorrerão (24x80), usamos dois comandos for. A cada vez que mostramos um caractere na tela, também
incrementamos a freqüência. Note que o comando for de dentro é executado completamente para cada
iteração do primeiro for.
Prática 7.14 - SeguindoFor

Para o programa abaixo:
a) Executá-lo manualmente e identificar o valor da variável Atual após a execução. Depois, digitar,
testar com o debugger e conferir sua execução.
PROGRAM SeguindoFor;
var Anterior, Atual, Seguinte, I : byte;
begin
Anterior := 1; Atual := 1;
for I := 3 to 5 do
begin
Seguinte := Atual + Anterior;
Anterior := Atual;
Atual := Seguinte
end
end.
a) Reescrever o programa para usar repeat.

b) Reescrever o programa para usar while.
Prática 7.15 – Numerador com repetição

Altere o programa Numerador de forma que fique repetindo a leitura e a numeração, só parando quando o
usuário entrar com zeros.
Prática 7.16 – Desenho com caracteres

Elaborar um esquema da tela de saída para o seguinte programa. Depois, execute-o e confira:
PROGRAM CaracteresProgressivos;
uses CRT;
var N, I, J : integer;
Ch : Char;
begin
ClrScr;
Writeln('Entre número de linhas: '); Readln(N);
Writeln('Entre caractere: '); Readln(Ch);
I := 1;
while I <= N do
begin
for J := 1 to I*2 do
Write(Ch);
Writeln; {move cursor para início da próxima linha}
I := I + 1
end
end.
Prática 7.17 – Mais caracteres

No mesmo programa, alterar a expressão I*2 por I, prever qual será o resultado e confirmar, executando o
programa.
Prática 7.18 - Convertendo cadeia para maiúsculas

Identifique dentre os grupos de instruções abaixo quais efetivamente convertem a cadeia S para
maiúsculas (na própria ou em outra variável). Teste cada opção no Turbo Pascal.
a) for Ap := 1 to Length(S) do S[Ap] := Upcase(S[Ap]);
a) Smai := '' ;
for Ap := 1 to Length(S) do
Smai := Smai + Upcase(S[Ap]);
a) S := Smai;
for Ap := Length(S) downto 1 do
S[Ap] := Upcase(S[Ap]);
.7.4. Casos freqüentes e problemas com comandos de repetição
Pausas - Se você quiser fazer o programa esperar o usuário pressionar uma tecla antes de
continuar, pode usar a função KeyPressed (da unit CRT), que retorna True se uma tecla foi acionada e
False caso contrário. Com esta função, podemos escrever
repeat until KeyPressed;
ou
8 - REPETIÇÃO 139
while not KeyPressed do;
A função KeyPressed apenas consulta o buffer do teclado; o código da tecla digitada continua lá.
Se tiver que ler posteriormente do teclado e não precisar da tecla, limpe o buffer com a instrução
ReadKey.
"Loops" - Você pode observar que, no comando acima, se nenhuma tecla for pressionada, o
comando nunca terminará, exceto se o computador for desligado ou houver uma condição de erro. Isso
sempre ocorrerá quando a condição de terminação nunca for atingida (dizemos que o programa “entrou
em loop”). Observe o seguinte trecho de programa:
X := 1;
repeat
Writeln(X);
X := X + 2
until X = 100;
A variável de controle X será sempre ímpar; consequentemente, a expressão lógica do until

nunca será verdadeira e o comando não terminará normalmente. Isso pode ocorrer também quando a
variável de controle não é alterada dentro do comando de repetição, como no caso abaixo:
X := 1;
while X <= 100 do
Write (X, ' ');
Outro erro de conseqüências por vezes desagradáveis é esquecer o par begin..end. Suponha que o
programador, ao corrigir o erro acima, faça assim:
X := 1;
while X <= 100 do
Write (X, ' ');
X := X + 1;
O desavisado programador, iludido pelas aparências, acha que corrigiu o problema, mas nada
mudará: o incremento do X está fora do comando de repetição e jamais será executado.
Esteja atento à condição de terminação e sempre verifique manualmente o código antes de

executá-lo.
Se seu programa entrar em loop, tecle Ctrl-Break para interromper sua

execução.
Impedindo entradas erradas - Uma outra aplicação de comandos de repetição é quando você
quer ler um valor e só continuar o programa após o valor lido estar correto. Por exemplo, para ler um
número na faixa de 1 a 6, você pode escrever:
Repeat
Readln(Num)
until (Num >= 1) and (Num <= 6);
Nesse caso é bom prever uma mensagem de erro para o usuário, para ele não ficar sem saber o
que fazer. Como você faria isso?
Blocos de controle - Comandos de repetição são muito usados para repetir a seção principal de
um programa, permitindo o usuário usar o programa e só parar quando for informada uma condição de
saída.
No caso mais simples, já visto aqui, o programa executa apenas uma ação básica. Esse é o caso
do cálculo do fatorial, para o qual uma estrutura de controle típica seria:

repeat
Readln(Numero);
if Numero > 0 then
begin
{Calcular fatorial}
{Mostrar fatorial}
end
until Numero = 0;
É claro que uma estrutura while..do também pode ser usada (faça como exercício). Já se o
programa implementa duas ou mais ações distintas, o usuário deve informar qual quer executar, e a
estrutura típica de controle é um comando case:
PROGRAM ExemploMenuIncompleto;
uses CRT;
var Opcao : char;
Begin
ClrScr;
repeat
Writeln('3 – Fim');
Write('Entre opção: ');
Readln(Opcao);
case Opcao of
'1' : {Ação 1};
'2' : {Ação 2};
'3' : {fim}
else begin
Writeln("Opção inválida");
ReadKey
end
end;
until Opcao = '3'
end.
.7.5. Programando repetições
A elaboração de algoritmos contendo repetição de comandos envolve experiência anterior e

respostas certas para perguntas adequadas. O "normal" é fazer uma versão inicial e ir aperfeiçoando ou
corrigindo. Quanto mais experiência você tiver, mais rapidamente vai programar.
Veja nesta seção algumas perguntas que você pode fazer se precisar, divididas em dois blocos. O
primeiro para repetições simples, como a de menus, e o segundo para algoritmos. Nem sempre será
preciso fazer todas, use-as quando achar necessário. Independentemente da qualidade das perguntas, fazer
a verificação manual antes da digitação pode lhe economizar muito tempo.
Bloco 1: repetições simples

Há repetição?
Quais os comandos que serão repetidos?
Qual é a condição de terminação (saída)?
Bloco 2: algoritmos com repetição.

Pode ser usado um comando de repetição?
8 - REPETIÇÃO 141
Quais são as variáveis necessárias?

Qual é o passo intermediário que, repetido, conduz à obtenção do resultado global da
repetição? Como pode ser descrito em linguagem comum?.
Quais são as variáveis que se alteram a cada passagem? Quais são seus valores inicial e
final? Qual é a instrução que efetuará cada modificação (elabore uma tabela com essas
informações).
Quantas vezes ocorrerá a repetição?
Qual é a variável ou expressão lógica de controle? Qual é o valor inicial da expressão de
controle? Valor final? Há outras variáveis candidatas?
Qual é o melhor comando de repetição a ser usado?
A seqüência dos comandos que são repetidos está apropriada?
Partindo-se das condições iniciais e executando-se a parte repetitiva, o resultado
desejado é obtido?
O algoritmo funcionou como esperado? Se não, o que deve ser modificado? O que está
passando ou faltando? Que situações podem ocorrer em que o algoritmo falharia?
Exemplo 7.19 – Teste de nota

Responda às perguntas de repetição para a seguinte especificação:
Elaborar programa que lê uma disciplina e respectiva nota (de 0 a 10, com uma casa decimal), e
informa se o aluno passou na disciplina, repetindo o ciclo até que a nota lida seja zero. O aluno
passa quando tira 7 ou mais.
Há repetição?
Sim. O programa deve processar tantas notas quanto o usuário queira.
Quais os comandos que serão repetidos?
Ler a nota e a disciplina
Verificar se o aluno passou.
Mostrar o resultado na tela.
Quantas vezes ocorrerá a repetição ou, se não se sabe, qual é a condição de terminação?
Quantidade indefinida de vezes (o usuário é que determina). Termina quando a nota lida
for zero.
Depois de obtidas essas respostas, basta decidir qual o comando de repetição a ser usado. Note
que você poderia ter feito um projeto e a partir deste obter as respostas.
Exemplo 7.20 – Média de idades

Um professor, após obter informações de uma turma, deseja saber a média de idade. Escrever um
programa que lê as idades até que o idade lida seja zero, quando então é mostrada a média (o zero não é
considerado para a média).
Há repetição: uma quantidade indefinida de idades devem ser lidas. Para poder calcular a média temos
que ter a soma das idades e a quantidade de idades. Assim, as instruções que serão repetidas são a leitura
da idade, a atualização de um contador e o cálculo da soma total lida. A repetição deve terminar quando a
idade for zero.
Juntando tudo isso, a estrutura do programa é:
"Atribua um valor qualquer à Idade, diferente de zero"

enquanto "a idade for diferente de zero" faça
Leia a próxima idade
Se a idade lida for diferente de zero, então
"Incremente o contador de pessoas"
"some a idade lida ao total da idade"
fim
fim
"Mostre a média, que é a soma das idades dividida pela quantidade de pessoas".
Veja o programa completo:

PROGRAM MediaIdades;
uses CRT;
var Idade, Quant, SomaIdade : word;
begin
ClrScr;
Writeln('Cálculo de média de idades');
Idade := 999;
while Idade <> 0 do
begin
Write('Digite a idade: '); Readln(Idade);
if Idade <> 0 then
begin
Quant := Quant + 1;
SomaIdade := SomaIdade + Idade;
end;
end;
Writeln('A média das idades é : ', SomaIdade/Quant:0:2);
ReadKey;
end.
Prática 7.21 – MediaIdades

Calcule manualmente a média das idades 18 – 17 – 21 – 35 – 18 - 20. Depois teste o programa com os
mesmos valores e confira.
Exemplo 7.22 – Série
Escrever programa para calcular, para N lido, o valor de S, dado por:
1 2 3 N −1 N
S= + + + ... + +
N N −1 N − 2 2 1
Após efetuar um cálculo, o programa pede novo número, parando quando N for zero.
Antes de trabalhar na repetição, vamos fazer um projeto. Uma tela de saída pode ser (após fazer
cálculos manuais da série):
8 - REPETIÇÃO 143
Entre valor de N (inteiro):

3
S(3) = 4.33

5
S(5) = 8.70

0
Observando a especificação ou a tela, podemos identificar que será necessário declarar as

variáveis N, o número inteiro a ser lido e S, o valor da série, que é real. A estrutura geral do programa é:
"Inicialize N com um valor diferente de zero"
enquanto N <> 0 faça
leia N
se N > 0 então
"Calcule o valor da série"
"Mostre valor da série na tela"
fim
fim.
O único passo da segmentação acima que não pode ser diretamente implementado em Pascal é
"Calcule o valor da série". Este pode ser segmentado informalmente em:
Repita N vezes
"Calcule o valor de um termo da série"
"Acumule o valor do termo calculado"
fim
Aqui podemos aplicar as perguntas sugeridas acima, já sabendo que há repetição.
Quais são as variáveis necessárias? O que varia é a soma S, o numerador Numer e o

denominador Denom.
Qual é o passo intermediário? Calcular um fator, Numer/Denom, e somá-lo em S.
Quais são as variáveis que se alteram a cada passagem, seus valores inicial e final e instruções
que as modificam? A cada iteração, mudam o numerador (de 1 em 1), o denominador (de –1 em –1) e o
próprio valor de S (Numer/Denom). Representando através de uma tabela:
Variável Val. Inicial Val. Final Instrução
Numer 1 N Numer := Numer + 1
Denom N 1 Denom := Denom –1
S 0 S S := S + Numer/Denom
Quantas vezes ocorrerá a repetição? Teremos N iterações, uma para cada fator da série.
Qual é a variável de controle? Podemos usar Numer, que varia de 1 a N.
Qual é o melhor comando de repetição? A quantidade de iterações ou repetições será N, portanto

podemos usar o comando for.
Com base nessas definições, podemos completar o algoritmo, representado em Pascal:

ALGORITMO CalculaSérie;
Denom := N;
S := 0;
For Numer := 1 to N do
begin
S := S + Numer/Denom;
Denom := Denom – 1;
end
Antes de completar o programa, vamos efetuar a verificação manual para N = 3. Montamos uma
tabela de variáveis e executamos o algoritmo instrução a instrução, atualizando a tabela a cada alteração
no valor de uma variável. Ao final, a tabela ficará assim:
Iteração N S Numer Denom
início 3 ? ? ?
Inicialização 0 1 3
1 0.333 2 2
2 1.333 3 1
3 4.333 4 0
A execução produziu o resultado previsto no projeto (faça o mesmo para N = 5). Veja o programa
completo:
PROGRAM CalculaS;
{calcula o valor de uma série matemática}
uses CRT;
var N, Numer, Denom : integer;

S : real;
begin
ClrScr;
N := 999;
while N <> 0 do
begin
Writeln('Entre valor de N:');
Readln(N);
if N > 0 then
begin
S := 0;
Denom := N;
for Numer := 1 to N do
begin
S := S + Numer/Denom;
Denom := Denom - 1;
end;
end;
Writeln('S(', N, ') = ', S:10:2)
end
end.
Note que você tem várias alternativas para chegar a um algoritmo: a especificação, o projeto,
segmentação, experiência anterior, tentativa-e-erro. Por onde você passa não importa, se chegar a um
resultado correto.
Nunca se esqueça: suas idéias são seu principal recurso. Não as mate
impiedosamente!
8 - REPETIÇÃO 145
Exercício 7.23 - Responda

Para as especificações abaixo, responder às perguntas de comandos de repetição:
a) Escrever um programa que lê dois números inteiros, inicial e final, e mostra na tela os números
inteiros do inicial até o final. Critica: o número final deve ser maior do que o inicial. O
programa repete isso enquanto os números lidos forem diferentes de zero.
b) Elabore um programa que lê um número de 1 a 9 e mostra a tabuada de multiplicação do
número. Por exemplo, para o 5:
5x1 =5
5 x 2 = 10
...
5 x 10 = 50
Especificação 7.24 - Chateação

Implementar um programa que fica repetindo a melodia do parabéns (pág. 76) até que uma tecla seja
pressionada. Execute-o sempre que quiser amolar alguém!
Exercício 7.25 – Fotossíntese revisitada

O programa da fotossíntese (especificado na pág. 83) foi reescrito, de forma que o estudante possa
avançar ou retroceder as páginas através de seta acima e seta abaixo. O programa termina quando avançar
além da última página ou quando teclado ESCAPE. Leia cada pergunta dos comandos de repetição e
procure as respostas no programa abaixo. Faça o que for necessário para chegar às respostas: executar o
programa, fazer um diagrama de blocos e o que você puder usar.
PROGRAM Fotossintese;
{Apresentacao de texto sobre fotossintese, com titulo e tres paginas.
Atencao: nao roda em Turbo Pascal for Windows}
uses CRT;
const {codigos ASCII (estendidos, exceto o 27) das teclas usadas no programa}
ESCAPE = #27;
SetaAcima = #72;
SetaAbaixo = #80;
var
PagAtual : byte;
Tecla : char;
begin
ClrScr;
GotoXY(34,12); Write('F O T O S S I N T E S E');
Readln;
PagAtual := 1;
repeat
ClrScr;
{mostra a pagina atual; algumas linhas foram separadas apenas para o
fonte caber nas 80 colunas da tela e do papel}
Case PagAtual of
1 : begin
GotoXY(12,12); Write('A agua e os sais minerais absorvidos'
+ ' pelas raizes');
GotoXY(12,13); Write('sobem atraves dos vasos lenhosos do'
+ ' caule e chegam as folhas');
end;
2 : begin
GotoXY(12,12); Write('Nas folhas, existe uma substancia verde,'
+ ' a clorofila,');
GotoXY(12,13); Write('que absorve a energia luminosa do Sol.'
+ ' Ao mesmo tempo,');
GotoXY(12,14); Write('por meio dos estomatos presentes nas'
+ ' folhas, a planta');
GotoXY(12,15); Write('absorve gas carbonico do ar.');
end;
3 : begin
GotoXY(12,12); Write('Usando a energia solar, o gas carbonico'
+ ' e o hidrogenio');
GotoXY(12,13); Write('contido na agua retirada do solo,'
+ ' apos complicadas reacoes');
GotoXY(12,14); Write('quimicas, a planta produz acucares'
+ '(glicose)');
end;
end;
Tecla := ReadKey;
{Algumas teclas (de controle) retornam dois caracteres, sendo o
primeiro #0; testamos so o segundo. As setas tem dois}
if Tecla = chr(0) then
Tecla := ReadKey;
Case Tecla of
SetaAcima :
if PagAtual > 1 then PagAtual := PagAtual - 1;
SetaAbaixo :
if PagAtual < 3 then PagAtual := PagAtual + 1;
end;
until Tecla = ESCAPE;
end.
Especificação 7.26 - Números inteiros 1

Escrever um programa que lê dois números inteiros, inicial e final, e mostra na tela os números inteiros
do inicial até o final. Critica: o número final deve ser maior do que o inicial. O programa repete isso
enquanto os números lidos forem diferentes de zero.
Especificação 7.27 - Soma de pares

Implemente um programa que calcula a soma dos números pares compreendidos entre dois números
lidos.

Elaborar programa que lê uma disciplina e respectiva nota (de 0 a 10, com uma casa decimal), e informa
se o aluno passou na disciplina, repetindo o ciclo até que a nota lida seja zero. O aluno passa quando tira
7 ou mais.
8 - REPETIÇÃO 147
Especificação 7.29 - Maior

Escrever um programa que lê números inteiros até que o número lido seja zero, quando então é mostrado
o maior número lido. [Dica: declare uma variável para registrar o maior lido até um momento,
inicializando-a com o menor número possível. Teste cada número lido com o maior e troque se for o
caso]
Especificação 7.30 - Maior e menor

Alterar o programa anterior para que mostre também o menor número lido.
Especificação 7.31 – Nome em cantos

Faça um programa que fica mostrando seu nome alternadamente nos quatro cantos da tela, até que uma
tecla seja pressionada.
Especificação 7.32 - Conversão de temperatura 1

Escrever um programa que mostra uma tabela de graus Celsius/Fahrenheit entre duas temperaturas lidas
do teclado, variando 1 grau de cada vez, uma temperatura por linha.
Especificação 7.33 - Estatística de notas

Faça um programa que lê uma quantidade qualquer de notas de 0 a 10 (não permitir fora desta faixa) e, ao
final, mostra quantas notas foram digitadas, a média e também a quantidade com valor abaixo de 5.
[Dica: mantenha variáveis para a soma parcial das notas e a quantidade de notas, atualizadas a cada
leitura. No final, divida a primeira pela segunda]
Especificação 7.34 - Raiz quadrada com menu

Faça um programa que repetidamente mostra na tela duas opções: "1 - Fim" e "2 - Calcular raiz" e lê do
teclado a opção desejada pelo usuário. Se a opção for 1, o programa termina. Se a opção for 2, o
programa lê um número real e, se o número for positivo ou zero, calcula e mostra sua raiz quadrada com
duas casas decimais, se negativo, mostra uma mensagem de erro. E se a opção for inválida (nem 1 nem
2), é mostrada uma mensagem apropriada. Quando a opção não é a de terminar, o programa volta para
mostrar novamente as opções e ler a opção do usuário.
Especificação 7.35 – Menu de conta telefônica

valor dos interurbanos
Implemente um programa com 4 opções principais: a primeira lê valores de uma conta (valor de
interurbanos, quantidade de impulsos normais e para celular), e calcula e mostra o valor da conta. A
segunda informa a quantidade de contas lidas, o valor total e a média do valor das contas. A terceira
mostra outras 2 opções (menu secundário): mostrar ajuda para o programa (o que faz, como usá-lo) e
mostrar informações do programador e do programa (nome do arquivo em disco, versão). A quarta
finaliza o programa.
Detalhes: os valores das assinaturas e preços de impulsos deverão ser declarados como constantes. Para o
menu, combinar os comandos repeat e case, e mostrar mensagem se for indicada uma opção inválida. Não
permitir valores negativos. Não mostrar estatística se nenhuma conta tiver sido informada.
Especificação 7.36 - Concatenação de caracteres

Elabore um programa que lê uma quantidade qualquer de números de 32 a 254 e mostra na tela uma
cadeia formada pela concatenação dos caracteres ASCII de cada número (lembre-se da função Chr). Se
um dos números estiver fora de faixa, é mostrada uma mensagem de erro e o programa espera a correção.
O final da entrada de números ocorre quando for lido zero.
Especificação 7.37 - Criptografia

Implementar um programa com duas opções: na primeira, ler e codificar uma cadeia com códigos ASCII
de 32 (espaço) a 122 ('z') , da seguinte maneira: ao código ASCII de cada caractere é somado 1; os
números resultantes são convertidos novamente em caracteres e concatenados, sendo a cadeia resultante
mostrada na tela. A segunda opção decodifica uma cadeia codificada pela primeira programa. Exemplo: a
cadeia "fogo", codificada, se torna "gphp" (esse processo de codificação é chamado de "criptografia").
Especificação 7.38 - Animação horizontal 1

Implementar um programa que simula um caractere se movendo pela tela ao longo de uma linha cujo
valor é lido do teclado, a partir e até colunas também lidas. O programa verifica se a coluna final
informada é maior do que o valor inicial.
Especificação 7.39 - Animação horizontal 2

Alterar o programa anterior para que o movimento seja na vertical, isto é, a coluna fica fixa e a linha
varia.
Especificação 7.40 - Tabuada

Elabore um programa que lê um número de 1 a 9 e mostra a tabuada de multiplicação do número. Por
exemplo, para o 5:
5x1 =5
5 x 2 = 10
...
5 x 10 = 50
Após mostrar uma tabuada, o programa pergunta se o usuário deseja ver outra. Se a resposta for positiva
(por exemplo, 'S'), ele faz tudo de novo, caso contrário termina.
Especificação 7.41 - Série convergente

1 1 1
A série S = + + +... converge para 1. Demonstre isso através de um programa que calcula o
2 4 8
valor de S para N termos. Inclua uma repetição que faça o programa calcular e mostrar o valor da série
para 1, 2, 3 ...10 termos.
Especificação 7.42 - Quantidade de caracteres

Elaborar um programa que lê uma cadeia e um caractere e informa a quantidade de ocorrências do
caractere na cadeia (não diferenciar minúsculas/maiúsculas: 'a' = 'A'). Por exemplo, se a cadeia for
"BANANA nanica" e o caractere for "a", o programa deve informar 5.
Especificação 7.43 - Estatística de frase 1

Elabore um programa que lê uma cadeia de até 255 caracteres e informa:
- quantidade de brancos
8 - REPETIÇÃO 149
- quantidade de palavras
- quantidade de ocorrências da letra 'A'
Especificação 7.44 - Numerador

Implemente um programa que mostre na tela os números inteiros entre dois números lidos do teclado,
organizados em linhas com 10 números:
21 22 23 24 25 26 27 28 29 30
31 32 33 34...
Especificação 7.45 - Caracteres progressivos

Escrever um programa que produza a saída abaixo na tela, para N linhas e usando um caractere lido do
teclado (no exemplo, *). Após mostrar uma vez, o programa repete o processo, só parando quando N for
zero.
*
**
***
****
*****
(...)
Especificação 7.46 - Caracteres progressivos v2

Idem acima, para o formato abaixo.
**
****
******
********
(...)
Especificação 7.47 - Caracteres progressivos v3

Ibidem:
(...)
*****
***
*
Especificação 7.48 - Tudo junto

Faça um programa que junte os 3 exercícios acima. Ele repetidamente oferece um menu com a opção 0
para terminar e outras 3 opções 1, 2, 3 cada uma correspondendo a um tipo de figura, além de uma opção
para ler o caractere e a quantidade de linhas. Caso a opção indicada pelo usuário seja inválida, é mostrada
uma mensagem apropriada. Em todos os casos exceto 0 o menu é oferecido novamente. Note que as
opções de 1 a 3 não efetuam a leitura, somente o desenho; por isto, inclua uma verificação para que o
desenho não seja feito se o caractere ou a quantidade de linhas não tiverem sido lidas.
Especificação 7.49 - Nave espacial 1

Bolar um desenho de uma "nave espacial" em modo texto. Fazer um programa que inicia com a "nave" no
centro da tela e move-a para a esquerda ou direita se tecladas as setas, terminando se teclado ESCAPE. A
nave pára se for atingido algum limite da tela.
Especificação 7.50 - Nave espacial 2

Alterar o programa acima para permitir o movimento também para cima e para baixo.
Especificação 7.51 – Menu variado

Escreva um programa que repetidamente faz o seguinte, através de um menu:
a) Ler do teclado uma cadeia de caracteres (digamos, S), cujo tamanho máximo é declarado como
uma constante.
b) Restaurar o último valor lido para S, se algum já foi lido (declare uma variável para armazenar o
valor e salve o valor lido nela).
c) Mostrar o valor atual de S e seu tamanho.
d) Trocar todos os espaços de S por hífens, informando a quantidade de substituições feitas.
Somente aceitar esta opção se já tiver sido lida alguma cadeia.
e) Terminar.
Especificação 7.52 - Eleição

Para computar o vencedor de uma eleição deve ser feito um programa. Há 3 candidatos, e os votos dos
eleitores foram codificados da seguinte forma:
1, 2 ou 3: votos para os respectivos candidatos
0: voto em branco
4: voto nulo
5: fim da digitação
Escrever o programa, que deve fornecer o número do vencedor da eleição (suponha que não pode haver
empates), as quantidades de votos brancos e nulos e o número de eleitores que compareceram às urnas.
Especificação 7.53 - Dia da semana

As questões abaixo se referem à seguinte especificação:
"Elaborar um programa que repetidamente lê um número de 1 a 7 e informa o nome do dia da semana
correspondente, sendo domingo o dia de número 1. A leitura do número também é repetida enquanto o
número estiver fora da faixa válida; neste caso é mostrada uma mensagem de erro. Após mostrar o nome
do dia, o programa pergunta se o usuário deseja ver outro dia da semana; se a resposta for 'S', os
procedimentos especificados são repetidos, caso contrário o programa termina.
a) Elabore uma tela-exemplo para o programa, mostrando como a tela ficará quando o usuário informar
um dia inválido, depois um dia válido e em seguida uma resposta 'S'.
b) Elabore uma árvore de decisão tendo como entrada um número de 1 a 7 e como resultado o
respectivo nome do dia da semana.
c) Escreva um programa Turbo Pascal para a especificação descrita.
8 - REPETIÇÃO 151
Exercício 7.54 - Revisão dos comandos de repetição

a) for é um comando de repetição apropriado para uma quantidade ___________________ de
repetições e com decisão no __________.
b) while é um comando de repetição apropriado para uma quantidade _________________ de
c) repeat é um comando de repetição apropriado para uma quantidade ________________ de
d) Em todos os comandos de repetição a decisão de parar o comando é tomada com base na
avaliação de uma __________________ ______________.
Exercício 7.55 - Revisão 2

Avalie as afirmações abaixo e depois assinale a opção correta:
I - O comando repeat termina quando a expressão após o until é avaliada como verdadeira.
II - O comando while termina quando a expressão lógica é avaliada como falsa.
III - Em um comando for...to, se a expressão de início for maior do que a expressão de fim, as
instruções após o do não serão executadas.
IV - É possível que um comando de repetição nunca atinja a condição de terminação.
a) As afirmativas I e II são verdadeiras.

b) As afirmativas I, II e III são verdadeiras.
c) Somente a afirmativa III é falsa.
d) Todas as afirmativas são verdadeiras.
Prática 7.56 – Obtendo o prenome com Pos

Altere o programa ObtemPrenome, do início do capítulo, de forma a usar Pos em lugar do while para
achar a posição do primeiro espaço.
Especificação 7.57 - Código ou caractere ASCII

Implemente um programa que mostra na tela os caracteres imprimíveis da tabela ASCII (comece do 32,
espaço).

Implemente um programa que sorteia um número de 1 a 10 e dá ao usuário 3 tentativas de acertá-lo. A
cada tentativa errada, o programa informa se o número a adivinhar está abaixo ou acima. Use um
comando de repetição para o controle.

Altere o programa acima para que ele permita ao usuário tentar até acertar.
Especificação 7.60 – Etiquetas

Faça um programa que lê três linhas de uma etiqueta, a quantidade horizontal e a quantidade vertical e
imprime a etiqueta repetindo-a na página impressa segundo as quantidades lidas.
Especificação 7.61 - Linha reta

Implemente um programa que dê uma inclinação e desenha na tela, ponto a ponto, uma linha reta com a
inclinação lida. Uma reta é definida pela equação y = ax + b, onde a é a inclinação.
Especificação 7.62 - Desenho

Faça um programa de desenho, cuja tela tem um cursor que se movimenta com as setas, deixando um
"rastro" (algum caractere; se quiser sofisticar, ponha um hífen se o movimento for na horizontal e uma
barra, se na vertical. Se quiser sofisticar mais ainda, use os caracteres de desenho de retângulos da tabela
ASCII).
Especificação 7.63 - Caixa automático

Um caixa automático precisa calcular quais e quantas notas devem ser entregues ao cliente para efetuar a
retirada desejada. Faça um programa com opções para:
− Receber notas de 10 e 50 (a quantidade inicial é zero para ambas)
− Ler o valor da retirada e mostrar a quantidade de notas de 10 e de 50 a serem entregues.
Se alguma das quantidades não for suficiente, o programa cancela a operação, com uma
mensagem apropriada. [Dica para calcular as quantidades de notas: use os operadores div e
mod]
Apresentar relatório com as quantidades de notas e valor total disponível, e valor total de retiradas
efetuadas.
153
.8 CRIAÇÃO DE INSTRUÇÕES E MODULARIZAÇÃO
As pessoas que vencem neste mundo são aquelas que procuram as

circunstâncias de que precisam e, quando não as encontram, as criam.
Anônimo
À medida em que nossos programas vão se tornando maiores e mais complexos, a quantidade de
detalhes pode se tornar intratável, e o risco de haver erros é maior. Além disso, muitas vezes executamos
um mesmo conjunto de instruções em dois ou mais pontos do programa. Seria ótimo se pudéssemos
programar em nível mais alto do que as instruções das linguagens de programação, e também podermos
reexecutar uma ação sem precisar reescrever as instruções que a implementam.
Neste capítulo veremos como podemos estruturar melhor nossos programas, criando novas
instruções na forma de procedimentos e funções reutilizáveis.
.8.1. Instruções criadas pelo programador
Suponha que você conhece três receitas de cozinha, sendo que todas usam um mesmo molho à
bolonhesa, e você quer escrever estas receitas. Como você faria: descreveria as instruções do molho em
meio às instruções de cada receita (ou seja, 3 vezes)? Ou descreveria a receita do molho em separado, e
ao descrever as outras receitas forneceria uma instrução do tipo “faça o molho à bolonhesa da pág. 2”?
A segunda alternativa certamente é mais econômica: você escreveria menos. Outra vantagem é
que, quando você tiver uma idéia brilhante para melhorar o molho, para registrá-la você fará alterações
em apenas um lugar, ao invés de 3. Além disso, uma pessoa que já conheça a receita do molho nem
precisa ir à página 2, e a descrição da receita fica mais simples.
Esses princípios se aplicam à programação. Suponha que você deve escrever um programa que
desenha 3 quadrados na tela, em locais variados do programa, e você dispõe de instruções que desenham
um quadrado. Seria suficiente escrever 3 vezes a seqüência de instruções que desenha um quadrado.
Porém essa redundância cria alguns inconvenientes:
• O teste é triplicado;
• Se alguma alteração for feita, ela terá que ser feita em 3 lugares;
• Se for necessário desenhar o quadrado em outro programa, as respectivas instruções deverão
ser redigitadas e retestadas.
Para evitar estes inconvenientes, o Pascal nos permite fazer o seguinte:

• Codificar as instruções que desenham o quadrado, como um bloco em separado;
• Atribuir um nome ao bloco de instruções;
• Executar as instruções e desenhando o quadrado escrevendo apenas o nome dado

ao bloco, no ponto do programa desejado.
.8.2. Tipos e características de instruções
Para entender melhor a criação de instruções, é bom revisar como elas podem ser. Por exemplo,
observe a instrução abaixo:
Writeln('Numero = ', 1);
A instrução Writeln possui, além de um nome único para identificá-la, uma finalidade bem
definida e específica, que é apresentar dados na tela.
Uma outra característica é que Writeln precisa receber dados para cumprir sua finalidade, os
chamados dados de entrada. Devemos indicar o que queremos que apareça na tela. Acima, os parâmetros
'Numero = ' e 1 são os dados de entrada. Mas não há informação alguma que se precise conhecer
(internamente ao programa) após a execução da instrução, ou dados de saída. Cuidado para não
confundir: a saída de Writeln é na tela, mas essa instrução não retorna qualquer informação que vá ser
usada dentro do próprio programa.
Associadas à instrução Writeln há outras características não visíveis para nós. Sendo uma
instrução de alto nível, também possui instruções em linguagem de máquina que a implementam. Essas
instruções constituem um bloco de código, que realizam sua finalidade. Além disso, Writeln deve possuir
variáveis internas, necessárias para algum cálculo intermediário, como por exemplo, linha e coluna da
tela.
Já a função Sin(X) tem a finalidade de calcular o seno de um número real. Tem como dado de
entrada o número, e como saída (resultado) o seno do número. Seu bloco de código e suas variáveis
internas também ficam escondidas. Observe como o resultado aparece no programa: no lugar da chamada
da função..
A instrução Writeln é um comando direto, imperativo, que representa uma ação a ser executada: é
chamado procedimento. A instrução Sin é uma função: retorna um valor como resultado de sua
execução, podendo portanto ser usada em expressões. Writeln e Sin são, respectivamente, procedimento-
padrão e função-padrão do Pascal, porque são predefinidas na linguagem.
As instruções que podemos criar podem ter a forma de procedimento ou de função. Suas
estruturas são bem semelhantes, exceto que para uma função devemos dizer o tipo de valor que ela
retornará e em pelo menos um ponto do seu bloco de código devemos atribuir um valor a ser retornado.
De forma semelhante, ao criarmos instruções, estas terão:

• uma finalidade específica
• um nome
• um tipo (procedimento ou função)
• dados de entrada
• dados de saída
• um bloco de código
• variáveis internas
9 - CRIAÇÃO DE INSTRUÇÕES E MODULARIZAÇÃO 155
Assim como a execução de um programa consiste em executar os comandos contidos no seu

bloco de código principal, a execução de uma instrução criada pelo programador consiste na execução
dos comandos do seu bloco de código.
Uma grande vantagem de criar uma nova instrução é esconder seu bloco de código e suas
variáveis internas do resto do programa. Uma vez testada, podemos usá-la como uma instrução qualquer
da linguagem, conhecendo apenas seu nome e seus dados de entrada e saída, ou seja, sua interface.
Assim, evitamos a repetição de instruções e, encapsulando os detalhes de implementação de cada uma,
permitimos que possam ser implementadas e testadas uma de cada vez.
Exercício 8.1 – Reconhecendo procedimento e funções

Com relação às instruções do Turbo Pascal abaixo, marque com um P os procedimentos e com um F as
funções (retornam um valor):
( ) ReadKey
( ) ClrScr
( ) Writeln
( ) WhereY
( ) Trunc
.8.3. Declarando procedimentos
Observe o programa a seguir.

PROGRAM QuadradoEmXY_v1;
uses CRT;
var Continua : char;

L, C, I : byte;
begin GotoXY, Write;

repeat GotoXY, Write;
ClrScr; GotoXY, Write;
Write('Digite a linha: '); Readln(L); ...
Write('Digite a coluna: '); Readln(C);
GotoXY(C, L); Write('XXXXX');
for I := 1 to 3 do
begin
GotoXY(C, L+I);
Write('X X');
end;
GotoXY(C, L+4); Write('XXXXX');
GotoXY(1, L+6);
Write('Deseja ver outro quadrado?');
Continua := Upcase(Readkey)
Until Continua = 'N';
end.
Note que no programa ocorre várias vezes a seqüência GotoXY/Write. Nestes casos, ao invés de
ficar repetindo instruções várias vezes, podemos declarar uma nova instrução que faça o que queremos.
Basta então chamar a instrução quando necessário.
Para o caso GotoXY/Write, podemos declarar um procedimento, já que apenas uma ação é
executada e nenhum valor é produzido. Veja a estrutura de um procedimento no quadro. PROCEDURE
é uma palavra reservada que indica que você está declarando um procedimento.
PROCEDURE NomeDoProcedimento(Var1 : tipo1; Var2 : tipo2...);

{descrição da finalidade do declara
Aqui você procedimento}
as
variáveis locais:
necessárias dentro do
procedimento e que não
var são para receber dados
...
Aqui você declara o nome do
procedimento e os
parâmetros: variáveis que
begin vão receber dados quando o
procedimento for chamado
Aqui você coloca os ...
comandos que executam
end; o que foi especificado
para o procedimento
Você pode notar que, assim como o programa tem um bloco de código, cada procedimento
também tem o seu. O primeiro é chamado principal para distinguí-lo dos outros. A declaração do
procedimento deve vir antes do bloco de código principal.
Uma vez declarado o procedimento, para que seja executado deve-se chamá-lo, isto é, escrever
seu nome no ponto adequado do programa, informando entre parênteses os valores a serem passados aos
parâmetros. Estes podem ser constantes, variáveis ou ainda expressões. Neste caso a expressão é avaliada
antes da chamada; sempre chegam valores constantes ao procedimento.
O padrão GotoXY/Write é um ótimo candidato a ser implementado por um procedimento. Veja a

definição passo a passo:
Finalidade do procedimento: mostrar um texto na tela em uma linha e uma coluna.
Nome do procedimento: WriteXY.
Dados necessários: a coluna, a linha e o texto, declarados como parâmetros.
Comandos: GotoXY seguido de Write.
Veja o procedimento completo e sua localização dentro do programa:

PROGRAM {...}
uses {...}
PROCEDURE WriteXY (Col, Lin : byte; Texto : string);

{mostra texto na tela na coluna e linha recebidas}
begin
GotoXY (Col, Lin);
Write(Texto);
end;
var {...}
begin {bloco de código principal}

{...}
end.
Uma vez declarada a nova instrução, podemos substituir todas as chamadas a GotoXY/Write por
uma chamada ao procedimento WriteXY, sendo que a cada chamada passamos valores diferentes
conforme a necessidade. Assim, ao invés de escrevermos
begin
...
GotoXY(C, L); Write(Texto);
...
end.
escrevemos
begin
...
WriteXY(C, L, Texto);
...
end.
Na chamada de um procedimento com parâmetros, estes devem ser

obrigatoriamente fornecidos na chamada, na mesma seqüência de sua
declaração, e os parâmetros efetivos devem ser do mesmo tipo ou de um
tipo compatível com o parâmetro formal correspondente.
Também variáveis e expressões podem ser usadas como parâmetros efetivos. Se o argumento for
uma variável, seu valor é buscado na memória para ser passado; se for uma expressão, esta primeiro é
avaliada e o valor resultante é que é passado ao procedimento. Sempre chegará ao parâmetro um valor;
por isso esse tipo de parâmetro é chamado parâmetro por valor.
Variáveis locais podem ter o mesmo nome que variáveis globais; neste caso estas não estarão
visíveis, isto é, não podem ser referenciadas no bloco de código do procedimento, enquanto este estiver
ativo.
Um procedimento pode ter também seções type e const.
Veja no exemplo a seguir uma segunda versão do programa do quadrado, modificada para usar a
nova instrução:
{Desenha um quadrado usando procedimento}
uses CRT;

begin
GotoXY (Col, Lin);
Write(Texto);
end;
var L, C, I : byte; {variáveis globais}

Continua : char;
begin {bloco de código principal}

repeat
ClrScr;
Write('Digite a linha: '); Readln(L);
{desenha o quadrado}
WriteXY(C, L, 'XXXXX'); {chamada do proced.}
for I := 1 to 3 do
WriteXY(C, L+I, 'X X');
WriteXY(C, L+4,'XXXXX');
WriteXY(1, L+6, 'Deseja ver outro quadrado?');

until Continua = 'N';
end.
Note no programa acima:

- A declaração do procedimento vem antes de sua chamada.
- O procedimento tem um nome, e esse nome é usado para ativá-lo onde desejado.
- Os parâmetros são declarados da mesma forma que variáveis.
- Os parâmetros efetivos (passados na chamada) podem ser constantes, variáveis ou
expressões, e devem estar na mesma ordem em que foram declarados.
- Todo procedimento tem seu próprio bloco de código, que será executado quando o
procedimento for chamado.
- WriteXY é independente de declarações externas a ele próprio. Se você quiser reutilizá-lo,
basta copiá-lo para o outro programa, e nem precisa testá-lo novamente.
Prática 8.2 – Como funcionam procedimentos

1. Digite o programa QuadradoEmXY_v2.
2. Execute-o com o debugger até executar a primeira linha com WriteXY. Continue com F7 e veja como
o fluxo de execução desvia para as instruções do procedimento a cada vez que este é chamado.
3. Novamente execute o programa com o debugger. Use alternadamente F7 e F8 quando for executada a
chamada do procedimento WriteXY. Qual a diferença? Use F8 quando você não quiser que o fluxo
de execução siga para dentro do bloco de código do procedimento. Com F8 todos os comandos do
procedimento são executados de uma vez.
Prática 8.3 - Passagem dos valores para o procedimento

Execute mais uma vez o programa acima com o debugger, desta vez para observar as variáveis. Insira na
janela Watch as variáveis L, C, Col, Lin e Texto. Vá executando o programa enquanto observa os seus
valores. Note que o debugger só vai reconhecer os parâmetros do procedimento enquanto este estiver
ativo. Preste atenção em particular ao fato de que os parâmetros assumem os valores passados a cada
chamada. Se nesta houver uma variável ou expressão, o valor é buscado ou calculado antes da ativação do
procedimento.
Prática 8.4 – Erros na sintaxe de procedimentos

No programa QuadradoemXY_v2, familiarize-se com alguns erros relacionados a procedimentos,
introduzindo os erros abaixo, um de cada vez, e tentando compilar (registre o erro em cada caso):
a) retire a palavra PROCEDURE
b) substitua PROCEDURE por PROC
c) retire o parêntese inicial do cabeçalho do procedimento
d) retire o parêntese final do cabeçalho
e) retire um ponto-e-vírgula do cabeçalho
f) retire o begin do bloco de código do procedimento
g) idem, para o end
h) retire o ponto-e-vírgula após o end do procedimento.
Prática 8.5 – Go to cursor

Às vezes você quer testar apenas um procedimento do programa; o debugger facilita isso. Posicione o
cursor dentro do procedimento do programa acima e tecle F4 (Go to cursor). O programa será executado
de uma vez, até parar no cursor. Você pode usar este recurso a qualquer momento em um teste com o
debugger.
Prática 8.6 – Da existência dos parâmetros

Execute o programa QuadradoEmXY_v2 no debugger, monitorando os valores das variáveis, e responda:
a) As variáveis dos parâmetros existem antes da sua ativação ("chamada")? Quando
começam a ser reconhecidos pelo depurador?
b) Idem, depois da ativação? Porque?
Prática 8.7 – Mais erros

Utilizando o mesmo programa acima, verifique e indique a mensagem de erro ocorrida ao tentar compilá-
lo nas seguintes situações (após cada uma, retorne à sintaxe correta):
a) retire de uma chamada do procedimento WriteXY algum parâmetro (popularmente
"esquecer de passar o parâmetro").
b) retire da declaração do procedimento WriteXY algum parâmetro.
Especificação 8.8 – Quadrado com crítica

Crie uma versão do programa do quadrado que impeça valores de linha e coluna fora da faixa válida e
que repita tudo, só parando quando os valores de linha e coluna forem ambos zero.
Exemplo 8.9 – Quadrado com procedimento

Podemos usar procedimentos para organizar melhor um programa. Que tal um procedimento para
desenhar o quadrado? Primeiro, a finalidade: desenhar um quadrado com X na tela em uma linha e coluna
especificadas. Depois, o nome: QuadradoXY. Dados necessários: a linha e a coluna. Com essas
informações já podemos escrever o cabeçalho:
PROCEDURE QuadradoXY(X, Y: byte);
O bloco de código deve conter as instruções necessárias para desenhar o quadrado, que são semelhantes
às usadas acima.
Execute o programa abaixo, já com o procedimento completo, usando o debugger e observando os
valores dos parâmetros e da variável local.
uses CRT;

begin
GotoXY (Col, Lin);
Write(Texto);
end;
PROCEDURE QuadradoXY(C, L : byte);

{Mostra quadrado 5x5 feito com X em linha e coluna da tela}
var I : byte; {variável local}
begin
WriteXY(C, L, 'XXXXX');
for I := 1 to 3 do
WriteXY(C, L+I, 'X X');
WriteXY(C, L+4,'XXXXX');
end;
var L, C : byte;
Continua : char;
begin
repeat
ClrScr;
Write('Digite a linha: '); Readln(L);
QuadradoXY(C, L);
WriteXY(1, L+6, 'Deseja ver outro quadrado?');
until Continua = 'N';
end.
Sobre procedimentos:
- Você pode declarar quantos procedimentos quiser;

- Procedimentos podem ter variáveis internas (locais), que, como os parâmetros, só existem
enquanto o procedimento está ativo. Também podem ter suas próprias constantes e types.
- Um procedimento pode chamar outro procedimento;
- Procedimentos podem ter nomes de parâmetros iguais aos de outros procedimentos ou a
variáveis globais;
- Veja como o programa principal acima ficou mais simples e como você poderá usar o
procedimento do quadrado em outro programa rapidamente, sem necessidade de testá-lo
novamente.
Prática 8.10 – Quadrado com qualquer caractere

Altere o procedimento QuadradoXY para que desenhe o quadrado com qualquer caractere. Inclua o
caractere como um parâmetro tipo char, e na chamada passe o 'X'. Teste com pelo menos dois caracteres
diferentes.
Prática 8.11 – Brincando com sons

a) Digite o programa SomVariavel, abaixo. Teste para várias faixas de duração: pequena (5), média
(20, 40) e longa (100, 300).
PROGRAM SomVariavel;
{Emite sons de 100 a 8000 Hz, com duração em milissegundos lida e variação de
10 em 10%}
uses CRT;
var Dur, Freq : word; {duração e freqüência}
begin
ClrScr;
repeat
Write ('Entre duração: ');
Readln(Dur);
Freq := 100;
repeat
Sound(Freq);
Delay(Dur);
NoSound;
{incrementa em 10% a freqüência}
Freq := Trunc(Freq * 1.1)
until Freq > 8000;
until Dur = 0;
end.
b) Faça um procedimento que emite um som em uma freqüência e duração informadas como
parâmetros. O seu bloco de código deverá portanto conter as instruções Sound/Delay/NoSound.
Faça uma nova versão do programa SomVariavel, trocando a chamada a essas instruções pela
chamada ao novo procedimento.
c) Agora crie um procedimento que recebe freqüências inicial e final e duração, e emita os sons da
mesma forma que o programa SomVariavel. Na chamada, passe os mesmos valores atuais: 100,
8000 e a variável da duração. O novo procedimento chama o anterior para emitir cada som.
d) Finalmente, faça o programa ler do teclado também os valores das freqüências e passar as
respectivas variáveis como parâmetros. Acrescente um IF para que o procedimento principal não
seja chamado se a duração lida for zero.
.8.4. Parâmetros por referência
Os parâmetros que vimos acima representam dados de entrada para os procedimentos. Qualquer
que seja o parâmetro efetivo passado na chamada (variável, constante ou expressão), o procedimento
receberá um valor na chamada.
É possível, entretanto, declararmos parâmetros que sirvam tanto para entrada quanto para saída de
dados (resultados). Para isso, inserimos na declaração, antes do identificador do parâmetro, a palavra var.
Se o parâmetro é precedido por var, dizemos que ele é um parâmetro por referência. O argumento, ou
parâmetro efetivo, de um parâmetro por referência não pode ser um valor; obrigatoriamente deverá ser
uma variável. No início da execução do procedimento, o valor desta variável é passado para o parâmetro;
ao final, o valor do parâmetro é atribuído à variável. Desta forma, temos um mecanismo em que o
procedimento poderá retornar dados e resultados que produza internamente.
Note a diferença na declaração e na chamada:

PROCEDURE NomeProc (Param : byte); {Param é de entrada}
Chamadas possíveis:
NomeProc(3);
NomeProc(N);
NomeProc(N+5);
PROCEDURE NomeProc (var Param : byte); {Param é de entrada e saída}
Chamada possível (sempre deve ser uma variável):

NomeProc(N);
No programa a seguir, o procedimento possui três parâmetros por valor e dois por referência.
Vejamos como é a execução.
Prática 8.12 – Parâmetros por referência

Execute o programa abaixo com o debugger, observando os valores dos parâmetros na janela Watches.
Acompanhe o que acontece no roteiro a seguir.
var C1, C2, C3 : integer; {coeficientes}

R1, R2 : real; {raízes}
PROCEDURE EqSegGrau(a, b, c : integer; var Raiz1, Raiz2: real );

{Calcula raízes da equação do segundo grau
com coeficientes a, b e c }
var Delta : real;
begin
Raiz1 := (-b + SqRt(Delta) )/2*a;
Raiz2 := (-b - SqRt(Delta) )/2*a;
end;
begin
Write('Entre coeficiente inteiro a: '); Readln(C1);
Write('Entre coeficiente inteiro b: '); Readln(C2);
Write('Entre coeficiente inteiro c: '); Readln(C3);
EqSegGrau(C1, C2, C3, R1, R2);
Writeln('Primeira raiz é ', R1:0:2);
Writeln('Segunda raiz é ', R2:0:2);
end.
• É reservada memória para as variáveis globais C1, C2, C3, R1 e R2

• Após os Writeln e Readln, é executada a chamada ao procedimento EqSegGrau. Suponha que

foram lidos do teclado os valores 1, 3 e 2 para as variáveis C1, C2 e C3, respectivamente.
• O fluxo de execução é desviado para o procedimento EqSegGrau
• São criadas na memória variáveis correspondentes aos parâmetros a, b, c, Raiz1 e Raiz2
• Os valores das variáveis passadas como argumentos são recuperados da memória e atribuídos
aos parâmetros, na mesma seqüência em que foram fornecidos. Após, portanto, os valores das
variáveis serão:
a=1
b=3
c=2
Raiz1 = ?
Raiz2 = ?
Note que, como as variáveis R1 e R2 não foram inicializadas, não podemos ter certeza de seu
valor, o mesmo ocorrendo com os parâmetros correspondentes Raiz1 e Raiz2, que receberam
os valores de R1 e R2.
• É executado o bloco de código do procedimento, após o que temos:
Raiz1 = -1
Raiz2 = -2
• O valor do parâmetro Raiz1 é atribuído à variável R1, e o valor de Raiz2 é atribuído a R2. Isto
é automático através de instruções colocadas pelo compilador.
• As variáveis dos parâmetros são eliminadas, liberando a memória que usavam
• O fluxo de execução retorna para a instrução que segue a chamada ao procedimento,
aparecendo na tela os valores de R1 e R2, respectivamente -1 e -2.
Compare: se invertêssemos na chamada os argumentos R1 e R2, como em

EqSegGrau(C1, C2, C3, R2, R1);
a primeira raiz a ser mostrada na tela seria -2.
Você deve ter percebido que, quando o procedimento é ativado, é estabelecida uma ligação da
variável que representa o parâmetro efetivo (o da chamada) com o respectivo parâmetro formal (o
declarado). Na prática, é um mesmo endereço de memória referenciado através de dois nomes distintos:
um nome para o programa principal, outro para o procedimento. Cada alteração efetuada no parâmetro
formal provocará uma alteração na variável passada que, ao final do procedimento, terá o mesmo valor
final que o parâmetro formal correspondente.
Exemplo 8.13 - Troca var
Siga o programa abaixo, que é executado assim:
Após as 2 primeiras instruções, temos X = 1 e Y = 99. A chamada ao procedimento TrocaVar

com os parâmetros X e Y criará uma relação de V1 para X e de V2 para Y. O procedimento TrocaVar
inicia então com V1 = 1 e V2 = 99. A execução das instruções do procedimento faz Aux = 1, V1 = 99 e
finalmente V2 = 1. Ao término da execução do procedimento, as variáveis X e Y contém os valores de
V1 e V2, respectivamente. Assim, a instrução Writeln mostrará que X = 99 e Y = 1.
Se não houvesse a declaração var dos parâmetros, os valores finais de V1 e V2 seriam os

mesmos, porém X e Y manteriam os valores originais.
PROGRAM Troca;
{Exemplo de parâmetros por referência}
var X, Y : integer;
PROCEDURE TrocaVar (var V1, V2 : integer);

{Troca os valores de duas variáveis}
var Aux : integer;
begin
Aux := V1;
V1 := V2;
V2 := Aux;
end;
begin
X := 1; Y := 99;
TrocaVar (X, Y);
Writeln('X = ', X, 'e Y = ', Y);
end.
Resumindo parâmetros
Parâmetros por valor são declarados sem a palavra var, e representam dados de entrada de um
procedimento. Para estes podem ser usados como parâmetros efetivos: variáveis, constantes e
expressões. O procedimento chamado recebe valores. Se o argumento é uma variável, recebe o valor
desta no momento da execução; se expressão, o valor resultante da avaliação da expressão.
Parâmetros por referência são precedidos da palavra var e constituem dados de entrada e saída, ou
somente de saída. Na chamada somente variáveis podem constituir-se nos parâmetros efetivos
correspondentes. Ao final da execução do procedimento, o parâmetro efetivo conterá o mesmo valor
que o parâmetro formal correspondente.
Exercício 8.14 – Revisão de parâmetros por referência

a) Parâmetros por referência servem tanto para _________________ quanto para
______________ de dados em um procedimento.
b) Para declarar que um parâmetro é por referência devemos preceder seu nome com
______.
c) O argumento correspondente a um parâmetro por referência deve necessariamente ser
uma __________________ .
d) Ao final da execução de um procedimento, o valor de um parâmetro por referência é
passado para a _______________ passada como argumento.
Prática 8.15 - Troca

Execute o programa Troca para responder: as variáveis que recebem os valores do procedimento
(parâmetros efetivos) são atualizadas ao final de sua execução ou durante esta? Explique.
Prática 8.16 – Erros em parâmetros por referência

No programa EqSegundoGrau, responda:
a) O que ocorrerá se a palavra var for retirada da declaração dos parâmetros?

b) O que ocorrerá se a ordem dos parâmetros Raiz1 e Raiz2 for invertida (Raiz2, Raiz1)?
.8.5. Funções declaradas pelo programador
Assim como procedimentos, podemos criar funções, segundo uma estrutura similar. Funções
definidas pelo programador são semelhantes aos procedimentos nos seguintes aspectos:
• constituem-se em um bloco de instruções com um nome que as identifica;
• podem possuir seção local de dados;
• podem receber parâmetros por valor ou por referência;
• são executadas somente quando chamadas.
As diferenças:
• retornam um valor ou resultado, cujo tipo deve ser especificado na declaração da função;
• no bloco de código da função, devemos atribuir um valor a ser retornado;
• somente podem ser chamadas em expressões.
Prática 8.17 – Função

Execute o programa a seguir e confira como é executado: a chamada da função, a atribuição do valor de
retorno, o retorno do valor da função.
PROGRAM CalculaFatorial;
{calcula o fatorial de um número lido, usando função}
var N : byte;
FUNCTION Fatorial( Num : byte ) : longint;

{retorna o fatorial para Num > 0} Declaração do
tipo de valor a
var I : byte; ser retornado
F : longint;
begin
F := 1;
for I := 2 to Num do
F := F*I Atribuição do
valor de retorno Chamada (o
Fatorial := F;
end; valor retornado
aparecerá aqui)
begin
Writeln('Entre um número inteiro:');
Readln(N);
Writeln('O fatorial de ', N, ' é ', Fatorial(N) );
end.
O programa acima é executado na seguinte seqüência:

• É reservada memória para a variável global N;
• São executados o Writeln e o Readln. Suponha que foi lido do teclado o valor 5 para N;
• É executada a segunda instrução Writeln, mostrando na tela “O fatorial de 5 é ', e antes que
seja concluída, o fluxo de execução é desviado para a função Fatorial;
• É criada na memória uma variável correspondente ao parâmetro N;

• O valor da variável global N passada como argumento é recuperado da memória e atribuído ao
parâmetro de mesmo nome;
• É executado o bloco de código da função, que calcula F = 120;
• É determinado o valor de retorno da função (120);
• As variáveis locais e o parâmetro são eliminados, e é liberada a memória que usavam;
• É retornado o valor 120 para a instrução Writeln, que o mostra na tela.
A atribuição do valor de retorno de uma função pode ser feita mais de

uma vez, e sua ausência não representa um erro de sintaxe, mas nesse
caso o valor retornado é imprevisível.
Prática 8.18 - CalculaFatorial

Explore um pouco mais o programa CalculaFatorial:
a) Execute-o de uma vez, calculando o fatorial de 11.
b) Execute-o agora usando o debugger, fazendo-o mostrar a execução do bloco de código da função
e monitorando o valor do parâmetro e das variáveis locais.
c) Agora retire ou comentarize a atribuição do valor de retorno da função (Fatorial := F) e reexecute
o programa O que aconteceu?
Exemplo 8.19 – Funções

Veja outros exemplos de funções simples (apenas as declarações):
FUNCTION AlunoPassou ( Nota : real) : boolean;

{retorna True se a nota habilita a aprovação}
begin
AlunoPassou := (Nota >=5)
end;
FUNCTION Dia ( Data : string) : byte;

{retorna dia de uma data no formato DD/MM/AAAA}
begin
Dia := Copy(Data, 1, 2);
end;
Funções criadas pelo programador, da mesma forma que as funções

padrão, podem ser chamadas em qualquer lugar em que possa ocorrer
uma expressão, desde que o tipo de valor retornado seja compatível com
a expressão. Você pode chamar uma função inteira em uma expressão
real, mas não pode chamar em tal expressão uma função que retorne um
valor booleano ou string.
Tipicamente você usará funções quando houver um só valor retornado

pela instrução. Se houver mais de um, terá que criar um procedimento.
Prática 8.20 – Conversão para maiúsculas

A função abaixo recebe uma cadeia e retorna-a convertida para maiúsculas: um apontador varre a cadeia
do primeiro ao último caractere; a cada posição na cadeia, obtemos o caractere, convertemos o caractere
para maiúscula e armazenamos o resultado na própria posição do caractere.
FUNCTION Maiusc(S : string) : string;

{converte uma cadeia de caracteres para maiúsculas}
var I : byte;
begin
for I := 1 to Length(S) do
S[I] := Upcase(S[I]);
Maiusc := S;
end;
Elabore um pequeno programa para testar a função.
Prática 8.21 – InverteCadeia

a) Elaborar um programa completo e testar a função InverteCadeia, abaixo.
b) Altere a função para usar o comando for.
FUNCTION InverteCadeia (Cad : string) : string;
var Ap : byte;
CadInv : string;
begin
CadInv := '';
Ap := Length(Cad);
while Ap > 1 do
begin
CadInv := CadInv + Cad[Ap];
Ap := Ap + 1
end;
InverteCadeia := CadInv;
end;
Exercício 8.22 – Conversão procedimento/função

Converta os cabeçalhos abaixo em cabeçalho de função (se procedimento) ou em cabeçalho de
procedimento (se função), mantendo os mesmos dados de entrada e saída.
a) PROCEDURE CalculaDigitoCPF (CPF : string; var Digito : integer);
b) FUNCTION Pesquisa( Nome : string) : boolean;
c) PROCEDURE CalculaMedia (N1, N2 : real; var Media : real)
d) FUNCTION InverteCad ( Cadeia : string ) : string;
Exercício 8.23 – Fatorial estourado

O que você acha que poderia fazer para o caso em que o fatorial, se calculado, vai estourar a capacidade
do tipo de dado adotado?
.8.6. Independência e reusabilidade
A forma que você dá às instruções que cria afeta profundamente o seu rendimento como
programador. Por exemplo, você poderia programar uma função que calcula o fatorial da forma abaixo,
declarando todas as variáveis como globais:
PROGRAM CalculaFatorial_Dependente;
var N, I : byte;
F : longint;
FUNCTION Fatorial: longint;
begin
F := 1;
for I := 2 to N do
F := F*I
Fatorial := F;
end;
begin
{...}
end.
Se você quiser usar essa função em outro programa, terá que declarar as variáveis I e F que a
função necessita. Imagine que um programa maior utilize 10, 20 ou mais funções e procedimentos, todos
estruturados dessa forma. Além de ter que se lembrar de todas as variáveis de que todos necessitam,
algumas das variáveis terão o mesmo nome, e pode ocorrer que uma instrução modifique uma variável
que está sendo usada por outra. Você ia ficar louco para administrar essa complexidade.
Usando parâmetros adequados e variáveis locais, você torna as novas instruções independentes, e
assim sendo, elas se tornam imediatamente reutilizáveis. Além disso, variáveis locais só ocupam memória
quando sua instrução está ativa. E uma outra imensa vantagem é que você pode escrever e testar as
instruções em separado uma da outra.
Quando uma instrução produz dados, se bem estruturada ela não apresenta seus resultados na tela;
simplesmente retorna o valor, o que a torna mais genérica. A parte do programa que a chamou é que
decidirá o que fazer com o valor. Se uma instrução mostra um resultado na tela, e você precisar imprimir
o valor, terá que alterá-la, ou escrever outra instrução. Esse tipo de independência das instruções
proporciona reusabilidade imediata, que por sua vez incrementa a produtividade do programador.
Uma característica de instruções independentes é que podemos implementá-la de forma

independente do programa que vai chamá-la: uma coisa de cada vez. Além dessa vantagem, é possível
distribuir o trabalho entre várias pessoas, definindo-se apenas o cabeçalho das instruções e cada pessoa
implementando um subconjunto das instruções (pense nisso ao planejar trabalhos escolares mais
complexos!).
Nunca use variáveis globais em procedimentos ou funções, a menos que

os benefícios superem os custos.
Na prática, você armazena os procedimentos e funções relacionados em um arquivo separado, e

para compilar um programa que usa essas instruções basta indicar ao compilador em que arquivo elas
estão. No Turbo Pascal esses arquivos se chamam units (veja neste capítulo). Assim você pode ter sua
biblioteca de funções matemáticas, de instruções que tratam janelas emolduradas, instruções para cadeias,
etc. Esta reusabilidade é a grande chave da sua produtividade como programador.

Sobre instruções independentes:
a) Que características deve possuir uma instrução para que seja independente?
b) Quais as vantagens de se escrever instruções independentes?
Exercício 8.25 – Isto é útil?

Uma pessoa, ao aprender procedimentos e funções, manifestou a seguinte opinião ao observar
procedimentos com 2 ou 3 comandos:
“Jamais vou usar isso. Assim digito muito mais, e é muito mais prático colocar as instruções na
seqüência correta”
Analise a afirmação à luz das possibilidades da criação de novas instruções. Responda: sua
afirmação é apropriada em algum aspecto, ou para alguns casos particulares? O que essa pessoa
pode não estar percebendo que poderia lhe ser útil? Justifique suas respostas.
Prática 8.26 - ScreenChar

Um ótimo exemplo de reusabilidade. O Turbo Pascal não dispõe de instrução para recuperar o código do
caractere que está em uma linha e coluna da tela, isto deve ser feito utilizando-se conhecimentos bem
mais profundos que os normais para uma linguagem de alto nível. A função abaixo faz isto, mas você não
precisa conhecer os detalhes de funcionamento dela para usá-la; basta conhecer o cabeçalho. Faça um
pequeno programa para testá-la (para uso em programas, provavelmente será necessário um
melhoramento: salvar a posição do cursor e restaurá-la no final da função). Não se esqueça de inserir um
comando uses para as units DOS e CRT.
FUNCTION ScreenChar (X, Y : byte) : byte;

{retorna o caractere em posição na tela.
USAR units DOS e CRT.
(adaptada de O'Brien 1992, pág. 294)
}
var Regs : registers;
begin
GotoXY(X,Y);
FillChar(Regs, SizeOf(Regs),0);
Regs.AH := 8;
Regs.BH := 0; (* página de vídeo *)
Intr($10,Regs);
ScreenChar := Regs.AL;
end;
.8.7. Roteiro para criar novas instruções
Para criar uma nova instrução, você pode seguir alguns passos bem definidos:
Identificação da possibilidade - Quando é que você decide que vai declarar uma instrução?
Tipicamente é quando faz a segmentação, na forma de diagrama de blocos ou refinamentos, e estrutura o
programa. Um ponto importante é estar procurando uma operação ou ação que possa ser implementada
através de uma nova instrução. Um pouco de experiência já faz com que você perceba logo essas
possibilidades.
Descrição da finalidade - É o que a instrução deve fazer.

Entrada - Identificação dos dados necessários para a instrução atender à sua finalidade.
Saída/resposta - Definição dos dados de saída ou da resposta que a instrução deve produzir.
Tipo da instrução - A instrução pode um procedimento ou uma função. Tipicamente será uma
função quando houver apenas um valor de retorno, e procedimento nos demais casos.
Cabeçalho - Escolha de um nome para identificar a instrução e definição do cabeçalho, sendo

declarados como parâmetros os dados de entrada e saída, se houver.
Implementação - Escreva o código Pascal da instrução. Se a instrução corresponde a um

algoritmo, você pode ter que desenvolvê-lo.
Teste - Se outras partes do programa estão avançadas e habilitam o teste da nova instrução, teste-
a lá mesmo. Outra possibilidade é fazer um pequeno programa para efetuar o teste. Se o procedimento foi
bem estruturado, isso será muito fácil; veja à frente as considerações sobre independência e reusabilidade
de instruções.
Exemplo 8.27 - Contando palavras
Implementar um programa que lê uma cadeia e informa a quantidade de palavras da cadeia.

Considere como separador de palavras o caractere espaço (que pode ser mais de um) e como palavra
uma seqüência de caracteres diferentes de espaço..
O programa terá a seguinte estrutura:

"Ler cadeia"
"Calcular quantidade de palavras da cadeia"
"Mostrar quantidade de palavras"
Podemos criar uma instrução para a segunda ação: ela receberá a cadeia e retornará a quantidade
de palavras. Seguindo a seqüência de passos sugerida acima para a declaração de uma instrução, temos:
Finalidade: calcular a quantidade de palavras de uma cadeia de caracteres.
Entrada: uma cadeia de caracteres
Saída: a quantidade de palavras
Tipo da instrução: havendo um só valor retornado, podemos declarar uma função, cujo uso é
mais prático que o procedimento.
Cabeçalho: FUNCTION CalcQtPal (Cadeia : string) : byte;
Implementação: Veja a seguir a implementação completa da função e do programa. Para achar a

quantidade de palavras usamos um apontador para cada caractere da cadeia e repetidamente fazemos:
"pular espaços até achar uma palavra"
"incrementar o contador de palavras encontradas"
"pular os caracteres da palavra encontrada"
Em cada caso é tomado o cuidado de não ir além do final da cadeia, verificando se o apontador
Ap não ultrapassou seu tamanho. Veja o programa a seguir..
PROGRAM ContaPalavras;
uses CRT;
const Espaco = ' ';
var CadLida : string;
FUNCTION CalcQtPal (Cadeia : string) : byte;

{calcula quantidade de palavras em uma cadeia}
var Ap, CtPalavras : byte;
begin
CtPalavras := 0;
Ap := 1;
while Ap < Length(Cadeia) do
begin
{pula os espaços}
while (Cadeia[Ap] = Espaco) and (Ap <= Length(Cadeia)) do
Ap := Ap + 1;
if Ap <= Length(Cadeia) then
begin
{achou palavra}
CtPalavras := CtPalavras + 1;
{pula os caracteres da palavra encontrada}
while (Cadeia[Ap] <> Espaco) and (Ap < Length(Cadeia)) do
Ap := Ap + 1
end
end;
CalcQtPal := CtPalavras
end;
begin
ClrScr;
Writeln('Contador de palavras');
repeat
Write('Digite cadeia de até 255 caracteres: ');
Readln(CadLida);
if CadLida <> '' then
Writeln( CalcQtPal(CadLida), ' palavras.'); Writeln;
until CadLida = ''
end.
Prática 8.28 - ContaPalavras

Digitar e testar o programa ContaPalavras, usando o debugger. Depois, e considerando que os espaços são
um elemento importante no algoritmo usado, verificar os resultados para as seguintes frases:
a) ' Espaços no início'
b) 'Espaços no final '
c) 'Espaços no meio'
d) ' s i t u a ç õ e s mistas '
Exercício 8.29 – Procedimento ou função?

Para cada descrição abaixo, definir se deve ser implementada como função ou procedimento. Identificar
parâmetros necessários e tipo de valor retornado, se função, e declarar o cabeçalho para cada uma.
Fornecer um exemplo de chamada de cada procedimento ou função declarado.
Modelo:
Verifica se aluno passou em disciplina.
FUNCTION AlunoPassou( Nota : real ) : boolean;
Chamada: if AlunoPassou (7.5) then ...
a) Calcula média aritmética de 3 números.
b) Calcula um inteiro elevado a outro inteiro.
c) Mostra na tela uma linha de texto.
d) Calcula dígito verificador de CPF.
e) Imprime um cabeçalho com número de página.
Especificação 8.30 - Números pares

Escrever um procedimento que recebe dois números e mostra na tela os números pares situados entre os
dois, inclusive. Testar com um programa que lê os números inicial e final e, se este maior que o inicial,
chama o procedimento.
Especificação 8.31 - Número par

a) Fazer um procedimento que recebe um número e retorna Verdadeiro ou Falso, por referência,
conforme o número seja par ou não (use mod).
b) Elaborar uma função para a mesma finalidade.
Especificação 8.32 - Linha vertical 1

a) Desenvolva um procedimento que recebe um número de coluna de tela e preenche a coluna com
caracteres ‘O’.
b) Alterar o procedimento acima para que receba também o caractere.
Especificação 8.33 - Cabeçalho

Elaborar um procedimento que recebe e imprime uma linha de cabeçalho com número de página, no
formato. A data é obtida do sistema (pesquise função apropriada na ajuda) e o número de página é um
parâmetro:
RELATÓRIO DE CLIENTES EMISSÃO: DD/MM/AAAA PÁG. 999
_____________________________________________________________________

Escrever uma função que recebe uma nota de 0 a 10 e retorna verdadeiro ou falso (ou outros valores
convencionados como tal) se o aluno foi aprovado, isto é, se tirou 7 ou mais.

Escrever uma função que recebe dois números quaisquer e retorna o maior.

Escrever uma função que recebe 3 números e retorna o maior
Especificação 8.37 - Média de 3

Declarar uma função que calcula a média aritmética de 3 números
Especificação 8.38 - Maior e menor com menu

Faça duas funções: uma que recebe dois números e retorna o maior e outra que recebe o mesmo mas
retorna o menor. Implementar um programa com um menu de 4 opções: ler dois números, testar uma e
outra função e terminar.
Especificação 8.39 - Mensagem

Escrever um procedimento que recebe valores de linha e coluna da tela e um texto, mostra o texto nas
coordenadas recebidas e espera 5 segundos. Após, apaga a mensagem e termina.
Especificação 8.40 - Minúsculas

Elaborar uma função que converte uma cadeia de caracteres para minúsculas. [Dica: some 32 aos
caracteres cujos códigos ASCII estão entre 65 e 90, inclusive].
Especificação 8.41 - Bissexto

Um ano é bissexto se for divisível por 4 exceto os séculos, que são bissextos se forem múltiplos de 400.
Implementar uma instrução que recebe o número de um ano e retorna Verdadeiro se o ano for bissexto ou
Falso caso contrário.
Especificação 8.42 – Crítica de data

Escrever uma função que recebe uma data no formato 'DD/MM/AAAA' (dia/mês/ano), verifica se as
barras estão na posição correta, se o dia está entre 1 e 31 (inclusive), se o mês está entre 1 e 12 e retorna
um valor da seguinte forma:
0: data correta
1: dia inválido
2: mês inválido
3: dia e mês inválidos
4: formato inválido
Depois escreva uma função que recebe um dos números acima e retorna a mensagem correspondente.
Teste as funções em um programa apropriado.
Especificação 8.43 - Sorteio de dados

Escreva uma instrução que recebe um número de 1 a 6, correspondente ao sorteio de um dado, e desenha
o dado na tela (em qualquer posição), mostrando o lado sorteado. Depois, faça um programa que sorteia 5
dados e os mostra na tela, alinhados.
Especificação 8.44 - Palavra grande

Elabore uma instrução que recebe linha, coluna e letra de A a Z e desenha "grande" essa letra, em linha e
coluna da tela. Faça outra instrução que recebe um texto de até 10 caracteres e chama a primeira para
mostrar o texto na tela em letras grandes.
.8.8. Reusabilidade total: units
Se você quiser reutilizar os procedimentos WriteXY, Som ou qualquer outro, terá que copiar as
instruções da declaração de um programa para outro e recompilar. Um jeito melhor é colocar as novas
instruções em uma unit. Uma unit é um arquivo texto, como um programa-fonte, mas começa com a
palavra reservada unit, é compilada em separado dos programas e quando é compilada é gerado um
arquivo com código objeto e extensão .TPU. Um unit não é executável diretamente mas pode ser usada
por qualquer programa.
O princípio básico de uma unit é que para que um programa referencie uma instrução, não é
necessário expor as declarações internas ou o bloco de código da instrução; é preciso somente conhecer o
cabeçalho: o nome da instrução e o tipo dos parâmetros. Por isso uma unit possui duas seções: a parte
pública (interface) e a parte privada (implementation). Na parte pública ficam somente os cabeçalhos
das instruções e na parte privada ficam os nomes e blocos de código, ou seja, a implementação das
instruções. Quando usa uma unit, um programa só pode referenciar as instruções cujo cabeçalho foi
declarado na parte pública. De fato, pode haver também declarações de tipos de dado, constantes e
variáveis, em ambas as seções. Novamente só as declarações públicas podem ser referenciadas no
programa que usa a unit.
São palavras reservadas, além das já conhecidas: unit, interface, implementation. No bloco de
código no final da unit podem ser incluídos comandos (opcionais) para a inicialização de variáveis ou
algo que precise ser feito para que as instruções da unit funcionem corretamente.
A estrutura simplificada de uma unit é assim:
UNIT Nome;
Interface
Na seção Interface ficam
PROCEDURE Proc1 (parâmetros);
apenas os cabeçalhos das
{descrição do procedimento 2} instruções públicas, isto é, que
podem ser chamadas por
FUNCTION Func1 (parâmetros): tipo; programas.
{descrição da função 1}
Implementation
Uses lista de units usadas na implementação;
PROCEDURE Proc1;
Var variáveis locais;
Na seção Implementation
begin ficam os nomes das instruções
(não é preciso repetir os
Comandos do procedimento 1 parâmetros) e o restante da
end; implementação de cada uma.
FUNCTION Func1;
var variáveis locais;
begin
Comandos da função 1
Este procedimento não aparece
end. na Interface; é de uso interno da
unit e não pode ser chamado por
PROCEDURE Proc2(parâmetros);
programas.
var variáveis locais;
begin
Comandos do procedimento 2
Comandos colocados
end.
nesta seção serão
begin executados no início
de cada programa que
{comandos de inicialização da unit} usa a unit.
end.
Tanto na interface quanto na implementação, você pode declarar também variáveis, tipos e
constantes. Se estes forem declarados na interface, serão visíveis para os programas. Veja a seguir uma
unit que contém uma única instrução, WriteXY.
unit CRT2;
Parte pública:
interface para usar só é
preciso conhecer
PROCEDURE WriteXY (Col, Lin : byte; Texto : string); os cabeçalhos.
{mostra texto na tela, na coluna e linha recebidas}
implementation
uses CRT; Aqui fica a

implementação,
PROCEDURE WriteXY;
que não precisa
begin estar acessível aos
GotoXY (Col, Lin); programas.
Write(Texto);
end;
begin
end.
Prática 8.45 – CRT2

1. Digite a unit CRT2 e salve-a com o nome de CRT2.PAS. Compile a unit com destino disco. Não se
esqueça de configurar o diretório de executáveis e units para o seu diretório de trabalho
(Options/Directories). Pronto: agora você pode usar a instrução WriteXY de qualquer programa, para
isso basta incluir a unit CRT2 na declaração uses. Note que a seção de inicialização está vazia; nada é
precisa fazer neste caso.
2. Agora abra o programa QuadradoXY, exclua as linhas do procedimento WriteXY (lembra do Ctrl-Y?)
e inclua na declaração uses a unit CRT2, após uma vírgula. Compile e teste o programa. Execute
também com o debugger e veja como ele lhe mostra o fonte quando alguma instrução da unit é
chamada (somente quando estiver disponível).
Prática 8.46 – WriteXY v2

Altere o procedimento WriteXY para que ele não afete a posição atual do cursor: antes de mostrar o texto
ele salva a linha e a coluna, e após o cursor é retornado para a posição salva. Note que alterá-lo não afeta
em nada os programas que o chamam. E para que se beneficiem da modificação, esses programas terão
apenas que ser recompilados.
Prática 8.47 – Som

Inclua o procedimento Som na unit CRT2. Compile para disco. Altere o programa SomVariavel para usar
a unit e chamar o procedimento Som.
Prática 8.48 – Inicialização da unit

Teste a seção begin..end: inclua instruções na unit CRT2 para mostrar seu nome, esperar 2 segundos e
apagar o nome. Compile a unit e recompile algum programa que a use. Execute e veja o resultado.
Prática 8.49 – Unit Mat

Digitar e compilar a unit Mat, a seguir. Testá-la através do programa CalculaFatorial, usando o debugger.
UNIT Mat; {Instruções matemáticas}
interface
PROCEDURE EqSegGrau ( a, b, c : integer ; var Raiz1, Raiz2 :real);

{Calcula raízes da equação do segundo grau com coeficientes a, b e c;
versão simplificada; não critica o delta}
FUNCTION Fatorial( N : byte ) : longint;

{Retorna o fatorial de um número maior do que zero}
implementation
PROCEDURE EqSegGrau;
var Delta : real;
begin
Raiz1 := (-b + SqRt(Delta) )/2*a;
Raiz1 := (-b - SqRt(Delta) )/2*a;
end;
FUNCTION Fatorial;
var I : byte;
F : longint;
begin
F := 1;
for I := 2 to N do
F := F*I;
Fatorial := F;
end;
begin
end.
PROGRAM CalculaFatorial;
uses CRT, Mat;
var N : byte;
begin
ClrScr;
Writeln('Entre um número inteiro:');
Readln(N);
Writeln('O fatorial de ', N, ' é ', Fatorial(N) );
end.
Prática 8.50 – Substituindo Readln

A instrução ReadXY (adiante) foi implementada para substituir Readln na leitura de strings. Ela recebe
linha e coluna da tela onde deve ser feita a edição, o "prompt" (texto a ser mostrado antes do campo) e o
tamanho máximo da string, e retorna o valor lido. Se for recebido um valor inicial, este é mostrado na tela
no início da edição. Seus recursos de edição incluem deslocamento do cursor através das setas à esquerda
e à direita, Home (início da cadeia), End (fim da cadeia) e Insert (alterna sobreposição ou inserção de
caracteres). Somente é permitida a digitação de caracteres alfa-numéricos, e a edição termina quando for
teclado Escape ou Enter.
unit RXY;
interface
const kEscape = #27; {códigos ASCII correspondentes a teclas}

kEnter = #13;
kSeta_Esq = #75; {códigos estendidos de teclas de controle}
kSeta_Dir = #77;
kHome = #71;
kEnd = #79;
kInsert = #82;
PROCEDURE ReadXY(X, Y : byte; Prompt : string; var S : string; Tam : byte);

{Leitura de strings com comandos de edição, em posição da tela}
implementation
uses CRT;
PROCEDURE ReadXY;
var Pos : byte;

Tecla : char;
Insere : boolean; {True : inserção; False : sobreposição}
begin
GotoXY (X, Y); Write(Prompt);
X := X + Length(Prompt) + 1;
Pos := 1; Insere := True;
repeat
{mostra valor atual}
GotoXY(X,Y); Write(S);
{posiciona cursor no ponto de edicao}
GotoXY(X + Pos - 1, Y);
{le a tecla e processa (caractere válido ou de controle)}
Tecla := ReadKey;
case Tecla of
' ','0'..'9','A'..'Z','a'..'z' :
begin
if not Insere then
begin
S[Pos] := Tecla;
if Pos < Tam then Pos := Pos + 1;
end
else if Length(S) < Tam then
begin
Insert(Tecla, S, Pos);
if Pos < Tam then Pos := Pos + 1;
end;
end;
#0 : begin
{trata teclas especiais, que tem dois códigos, sendo zero o primeiro}
Tecla := ReadKey;
case Tecla of
kSeta_Esq : if Pos > 1 then Pos := Pos - 1;
kSeta_Dir : if Pos < Tam then Pos := Pos + 1;
kHome : Pos := 1;
kEnd : Pos := Length(S);
KInsert : If Insere then Insere := False
else Insere := True;
end
end;
end
until (Tecla = kEscape) or (Tecla = kEnter);
end;
begin
end.
Para a unit e o procedimento ReadXY, faça o seguinte:
a) Digite e compile a unit.

b) Faça um programa para testar o procedimento (por exemplo, repetidamente chama o
procedimento e mostra o valor retornado).
Prática 8.51 – Melhorando ReadXY

Faça e teste as seguintes alterações no procedimento ReadXY:
a) Implemente o uso das teclas Backspace (deleta à esquerda do cursor) e Delete (deleta o caractere
na posição do cursor).
b) Implemente a saída de edição com a tecla Escape; neste caso, a instrução retorna o valor inicial
recebido (salve o valor recebido no início e restaure-o no final).
Especificação 8.52 - Exponenciação real

Escrever uma função que calcula um número real elevado a outro real, usando a fórmula Y X =
exp(x*ln(y)). Após testá-la (verifique se a fórmula falha para alguma situação), inclua-a na unit Mat,
acima.
Especificação 8.53 – Menu matemático

Faça um programa com opções de: terminar, mostrar informações do programador e do programa,
calcular fatorial, resolver equações do segundo grau e potenciação. Chame um procedimento para mostrar
as informações. Use a unit Mat para os cálculos. Para o fatorial, limite o valor do número de forma a não
estourar a capacidade da variável que recebe o fatorial. Para as equações, não calcule as raízes se o delta
for negativo e mostre somente uma se o delta for zero. Para criticar o delta, use uma função Delta
declarada na própria unit.
Prática 8.54 - Mat v2

Altere a unit Mat para que qualquer programa que a use mostre a identificação da unit e o nome do
programador por três segundos e depois limpa a tela (inclua as instruções para isso no bloco de código no
final da unit).
Pesquisa 8.55 – Compilação simplificada

Descubra no menu Compile do Turbo Pascal uma opção que lhe permite compilar o programa e todas as
units usadas por ele.
Pesquisa 8.56 – Diretivas de compilação

Descubra na ajuda do Turbo Pascal o que são diretivas de compilação, e ache uma diretiva que afeta o
comportamento de instruções declaradas pelo programador.
Especificação 8.57 – Sorteio de dados

a) Escreva uma unit com duas instruções na interface. A primeira é uma função que sorteia e retorna um
número de 1 a 6, representando a pontuação de um dado. Para sortear o valor use a instrução
Random, cuja inicialização (instrução Randomize) deve ser feita na seção de inicialização da unit.
A segunda é um procedimento que recebe uma quantidade de pontos, uma linha, uma coluna e um
caractere e desenha um dado com a quantidade de pontos recebida, na posição da tela recebida e
usando o caractere recebido, usando 3 linhas e 3 colunas. Você pode assumir que existe a instrução
WriteXY, na unit CRT2. Não é necessário emoldurar o dado. Por exemplo, se os pontos forem 5 e o
caractere for '*', a saída seria (o '*' no alto à esquerda corresponde à linha e à coluna recebidas):
* *
*
* *
b) Escrever um procedimento que lê e retorna, por referência, dois números de 1 a 6 lidos do teclado.
Caso um dos números esteja fora da faixa válida, o procedimento retorna zero para ambos.
c) Elaborar um procedimento que recebe como parâmetros (não leia do teclado) dois números
correspondentes à pontuação de dois dados e faz o seguinte:
• Sorteia e armazena a pontuação de dois dados (para isso chame a função da unit declarada
acima).
• Mostra na tela a pontuação sorteada de ambos os dados (use o procedimento declarado
acima).
• Compara os pontos sorteados com os pontos recebidos e mostra mensagem na tela
informando se os dados são iguais (em qualquer ordem), se a soma é igual ou se nada disso
ocorreu.
d) Implementar um programa de sorteio de dados, que repetidamente oferece um menu com as seguintes
opções:
• Terminar.
• Leitura do palpite do usuário para dois dados. Use o procedimento declarado acima, e espere
uma tecla após a chamada do procedimento.
• Sortear e verificar o resultado. Use o procedimento declarado acima, mas somente se a
leitura já foi efetuada. Se não, é mostrada uma mensagem apropriada. Espere também uma
tecla antes de retornar.
Exercício 8.58 – Desvantagens de repetir código

Citar as desvantagens de escrever trechos redundantes de instruções. Qual é a solução?
Exercício 8.59 –Declaração de instruções

a) As instruções que criamos podem ser ___________________ ou _______________.
b) Para chamar uma instrução, precisamos conhecer apenas o seu _____________ e seus
dados de _________________ e _______________.
c) Para usar uma instrução, não precisamos conhecer seu __________ de ____________ ou
suas variáveis ______________.
d) Uma função produz um _________________, e por isto pode ser usada em expressões.
e) Uma vantagem de se criar instruções é evitar ___________________ de trechos de
código.
Exercício 8.60 – Mais revisão

Assinale V ou F:
( ) Uma instrução declarada pelo programador deve ter pelo menos um nome e um
bloco de código.
( ) As variáveis declaradas dentro de um procedimento ou função e só podem ser

usadas (referenciadas) no respectivo bloco de código, já que só existem quando a instrução
for executada.
( ) O bloco de código de uma instrução declarada é executado quando da
compilação.
( ) Um procedimento declarado pode chamar outro.
Exercício 8.61 - Funções

Assinale V ou F, conforme a afirmativa seja verdadeira ou falsa:
( ) Funções retornam um valor, de um determinado tipo de dado.
( ) O valor de retorno de uma função é determinado automaticamente pelo compilador.
( ) A passagem de parâmetros na chamada de uma função é opcional.
( ) Funções podem ter parâmetros por valor ou por referência.
( ) As variáveis locais de uma função só existem enquanto a função está sendo executada.
Exercício 8.62 – Revisão de parâmetros

a) Parâmetros são declarados no ___________________ de um procedimento.
b) Parâmetros por valor servem para o procedimento _____________ dados.
c) Para declarar um parâmetro precisamos definir seu _________ e seu _________.
d) Parâmetros, assim como variáveis locais, só existem na memória enquanto o
procedimento em que foram declarados estiver ____________________.
e) Um parâmetro declarado chama-se ___________________; o passado na chamada da
instrução é denominado ____________________ ou __________________.
f) O valor inicial de um parâmetro formal é fornecido na _______________ do
procedimento.
g) Se um parâmetro efetivo (ou argumento) é uma _______________, seu valor é
recuperado da memória antes da chamada do procedimento; se for uma expressão, seu valor é
antes __________________.
Pesquisa 8.63 - Dia da semana

Descubra como, a partir de uma data válida, você pode identificar o dia da semana correspondente
(domingo, segunda, etc.). Escreva uma instrução que retorna esse dia.
Especificação 8.64 – Função para substituir FillChar

O fato de FillChar ser um procedimento não o torna muito prático. Elabore uma função que recebe um
caractere e uma quantidade e retorna uma string com a quantidade indicada do caractere. Coloque a
função em uma unit.
Especificação 8.65 – Operações com cadeia

Elabore um programa que mostra um menu com as opções abaixo. Todos os procedimentos e funções
devem estar em uma ou mais units. Todas as units devem mostrar na tela, ao inicializar, o seu nome (da
unit) e a identificação do programador, por 2 segundos. Todo texto deve ser mostrado na tela através da
função WriteXY em unit. Mostrar mensagens de erro também através de procedimento, que emite um
som qualquer usando o procedimento Som.
a) Terminar.
b) Mostrar submenu com duas opções: informações do programador, da disciplina, etc. ou ajuda
para o programa. Usar procedimento para este submenu.
c) Ler uma cadeia qualquer.
d) Inverter a cadeia, que ficará como lida de trás para a frente. Usar função para a inversão.
e) Converter a cadeia para maiúsculas, usando função
f) Converter a cadeia para minúsculas, usando função.
g) Restaurar o último valor lido para a cadeia.
Especificação 8.66 - Formatação de data

Elaborar um procedimento que recebe como parâmetros dia, mês, ano, uma linha e uma coluna da tela e
uma letra que corresponde ao formato de data a ser apresentado. Se o formato = ‘A’, mostra
DD/MM/AA; se ‘B’, mostra DD.MM.AAAA. Para testá-lo, faça um programa que busca a data do
sistema, extrai dia, mês e ano e chama o procedimento.
Especificação 8.67 - Números primos

Um número é dito ser primo quando é divisível somente por si e pela unidade. Faça um programa que
verifica, através de uma função, se um número é ou não primo. [Dica: divida o número N por todos os
números de 2 a N - 1. Se o resto da divisão de N por algum dos números der zero, ele não é primo]
Especificação 8.68 - Palíndromos

Implementar um programa que verifica se uma frase é palíndroma (a mesma se lida normalmente ou de
trás para a frente: "Roma me tem amor", "socorram me subi no ônibus em Marrocos").
Especificação 8.69 - Custo de execução de procedimento

Escrever um programa que serve para se medir o custo, em tempo, de execução de um procedimento. Ele
troca, alguns milhares de vezes, os valores de duas variáveis, de duas formas: na primeira é usado para
trocar as variáveis um procedimento, na segunda sem este. Computar o tempo gasto para cada forma e
mostrá-los na tela.
Especificação 8.70 - Trim

Implementar uma função que retira os brancos finais de uma cadeia de caracteres (em certas linguagens
disponível com o nome de "Trim").
Especificação 8.71 - Ajuste de tamanho

Implementar uma função que recebe uma cadeia e um tamanho e retorna a cadeia com brancos inseridos
no fim até o tamanho especificado.
Especificação 8.72 - Formatação de linha

Um programador está escrevendo um editor de textos, e precisa de uma função que recebe uma linha de
texto e uma largura de linha, e insere espaços de forma a alinhar o texto à largura recebida, retornando a
linha formatada. Implemente essa função. [Dica: primeiro calcule a quantidade de espaços necessária;
descubra a quantidade de intervalos entre palavras e calcule quantos espaços terá que inserir em cada
intervalo; insira essa quantidade em cada intervalo, sendo que o último intervalo receberá os espaços
extras restantes. Investigue outras possibilidades de distribuição]
Especificação 8.73 - Janela de confirmação

Implementar uma instrução que mostra uma janela de confirmação na tela com as opções "SIM", "NÃO"
e "CANCELAR", aguarda a opção do usuário e retorna a opção selecionada. O usuário seleciona a opção
com as setas ou a primeira letra e depois teclando Enter.
Especificação 8.74 - PIS/PASEP

O dígito verificador do PIS/PASEP é calculado através da seguinte regra: o número é composto por dez
dígitos mais um dígito verificador. Multiplique os números, da esquerda para a direita, respectivamente
por 3 2 9 8 7 6 5 4 3 2. Some os resultados das multiplicações; calcule o resto da divisão da soma
por 11 e subtraia o resultado de 11. Se o resultado for 10 o dígito é zero, caso contrário o dígito é o
próprio resultado.
Por exemplo, para o número 1701209041-1, o cálculo seria:
1x3 + 7x2 + 0x9 + 1x8 + 2x7 + 0x6 + 9x5 + 0x4 + 4x3 + 1x2 = 98. O resto da divisão de 98 por 11 é 10.
Como 11 - 10 = 1, o dígito é 1.
Escrever uma função que recebe um número de PIS/PASEP e retorna o dígito verificador. Para testá-lo,
você pode usar também o número 1010861269-1.
Especificação 8.75 - CPF

Os dois dígitos de verificação do CPF (constituído de 9 dígitos) são calculados através de um complicado
algoritmo:
Etapa 1: cálculo de DV1
Soma 1: soma dos produtos de cada dígito por um peso de 2 a 10, na ordem inversa (do nono para
o primeiro).
Multiplique a soma 1 por 10 e calcule o resto da divisão do resultado por 11. Se der 10, DV1 é
zero, caso contrário o DV1 é o próprio resto.
Etapa 2: cálculo de DV2
Soma 2: soma dos produtos de cada dígito por um peso de 3 a 11, também na ordem inversa.
Adicione a Soma 2 ao dobro do DV1, multiplique por 10 e calcule o resto da divisão do resultado
por 11. Se der 10, DV2 é zero, caso contrário o DV2 é o próprio resto.
Etapa 3: Multiplique DV1 por 10, some com DV2 e você tem o número de controle do CPF.
Exemplo: para o CPF 398 136 146, temos:
Etapa 1: 2x6 + 3x4 + 4x1 + 5x6 + 6x3 + 7x1 + 8x8 + 9x9 + 10x3 = 258
2580 mod 11 = 6, portanto, DV1 = 6
Etapa 2: 3x6 + 4x4 + 5x1 + 6x6 + 7x3 + 8x1 + 9x8 + 10x9 + 11x3 = 299
(299 + 6x2)x10 mod 11 = 3150 mod 11 = 8, portanto DV2 = 8
Etapa 3: DV1x10 + DV2 = 6x10 + 8 = 68, que é o número procurado.
Escrever uma função para calcular os dígitos de controle do CPF. Para simplificar, já que são duas
somatórias, você pode escrever também uma função auxiliar que recebe o CPF e o peso inicial e retorna a
soma.
Especificação 8.76 - Freqüência de notas musicais

Se você conhece a freqüência de uma nota musical, pode conhecer a nota seguinte (um semitom acima)
multiplicando aquela por 12 2 . Sabendo que a freqüência de uma das notas Lá é 440 Hz, faça o seguinte:
a) Escreva uma função que recebe uma nota e retorna a próxima;
b) Escreva um programa que calcula as freqüências de notas acima do Lá (La#, Si, Dó, Dó#,
Ré, Ré#, Mi, Fá, Sol, Sol#, Lá, Lá #, Si, Dó. Anote as freqüências.
c) Em outro programa, declare constantes para as freqüências das notas (por ex., DO) e
escreva instruções que toquem o Parabéns pra você. [Dica: declare uma constante para a
duração e use múltiplos desta; as primeiras notas, com a respectiva duração, do Parabéns
ficariam assim: (DO, Dur), (DO, Dur), (RE, 4*Dur), (DO, 2*Dur). Tente Dur = 100 e 200.]
185
.9 LISTAS NUMERADAS: VETORES E MATRIZES
Em várias situações o programador deve trabalhar com listas de nomes, números e várias outras.
Para facilitar a sua vida, as linguagens de programação permitem a declaração de muitas variáveis em
uma só instrução, na forma de uma lista com vários elementos, e para atribuir ou recuperar valores você
faz referência a um elemento de cada vez, através de sua posição na lista.
Essas listas são chamadas de vetores, quando de uma dimensão, ou matrizes, quando com duas ou
mais dimensões. Você verá neste capítulo como declarar e usar esse tipo de variáveis em Pascal.
.9.1. Vetores
Considere a seguinte especificação:
"Implementar um programa que lê uma série de pares freqüência/duração até que seja lida uma
freqüência zero. Após, o programa "toca" a seqüência lida, emitindo sons em cada freqüência, com a
respectiva duração."
Para efetuar a leitura, você vai precisar de variáveis para a freqüência e a duração. Mas onde
guardar os valores lidos anteriormente? Mesmo que fossem declaradas variáveis para cada par (o que
daria muito trabalho), não se sabe a quantidade de pares.
Vamos ver como atender à necessidade da especificação acima e depois como efetuar a
declaração no Pascal. Para essa especificação, precisamos de duas listas, uma para as freqüências e outro
para as durações. Como exemplo, vamos usar as seis primeiras notas do "Parabéns pra você"; as listas
devem ficar assim (assumindo um máximo de 10 notas em uma “música”):
Freqüências (Hertz)
440 440 500 440 600 560
1 2 3 4 5 6 7 8 9 10
Durações (milissegundos)
200 200 800 400 400 800
1 2 3 4 5 6 7 8 9 10
Para representar as estruturas acima e outras semelhantes, o Pascal (e as outras linguagens)

permitem que declaremos muitas variáveis de uma vez, na forma de um vetor. Um vetor consiste em uma
lista numerada de variáveis, às quais fazemos referência pela nome do vetor e a posição desejada da lista.
Cada variável componente do vetor é chamada elemento.
Outros exemplos de problemas que podem ser solucionados através de listas:

• Achar a nota média de uma turma de 50 alunos
• Organizar 5000 números em ordem decrescente

• Armazenar uma lista de 200 palavras
• Armazenar na memória e ordenar em ordem crescente uma lista de códigos de 3000 produtos
.9.2. Declaração de vetores
No Pascal, e como qualquer outra variável, para se usar um vetor é preciso declará-lo; sua
declaração deve fornecer os seguintes elementos:
nome: o identificador do vetor
limite inferior: inteiro que aponta para o menor posição do vetor2
limite superior: inteiro que aponta para a maior posição do vetor
tipo de dado de cada elemento.
Sintaxe da declaração:
var nome : array [Limite inferior..limite superior] of tipo;
array e of são palavras reservadas. O primeiro número dentro dos colchetes indica o número ou
posição do primeiro elemento (limite inferior), e o segundo (10) indica o número do último (limite
superior). As declarações acima, portanto, criam dois vetores com 10 elementos cada um, numerados de 1
a 10, sendo que em cada elemento ou posição podemos armazenar um dado do tipo word. Veja que desta
forma criamos 10 variáveis de uma só vez, a cada declaração.
Podemos declarar os vetores de freqüências e durações assim (lembrando que freqüência e

duração no Turbo Pascal são do tipo word):
var vFreq : array [1..10] of word;
vDur : array [1..10] of word;
Como as duas estruturas são iguais, podemos simplificar a declaração usando type:
type tNotas = array [1..10] of word;
var vFreq, vDur : tNotas;
Um vetor é dito ser um tipo estruturado e homogêneo de dados, porque é composto de várias
variáveis, todas de um mesmo tipo.
O limite inferior de um vetor não precisa ser necessariamente 1. Você pode utilizar um valor
relacionado ao contexto dos seus dados. Por exemplo, se você quer armazenar uma tabela de
correspondência de graus Fahrenheit/Celsius na faixa de 32 a 212, você poderia declarar um vetor assim:
type vTabFahrCels : array[32..212] of real;
Para se saber quantos elementos possui um vetor, basta calcular:
Quantidade de elementos = limite superior - limite inferior + 1
2
Na verdade, os limites inferior e superior podem ser de outros tipos de dado (como char e boolean); para
nós é suficiente assumirmos que são números.
10 - LISTAS NUMERADAS: VETORES E MATRIZES 187
O vetor acima possui 212 - 32 + 1 = 181 elementos. Veja outros exemplos de declaração de
vetores:
type Palavras : array[1..100] of string[20];

Texto : array[1..5000] of char;
Tela : array[1..25] of string[80];
Notas : array[1..50] of real;
Passou : array[1..50] of boolean;
PrecoProduto : array[1000..9999] of real;
Exercício 9.1 - Vetores

Assinale V ou F:
( ) Todos os elementos de um vetor Pascal são do mesmo tipo de dado.
( ) O nome que identifica um vetor deve seguir as regras para identificadores Pascal.
( ) Um vetor é dito ser homogêneo porque todos os seus elementos são do mesmo tipo de
dado.
( ) Um vetor não pode ter limite superior negativo.
Exercício 9.2 - Declaração de vetores

Escreva uma seção var declarando vetores apropriados para representar:
a) 500 números aleatórios na faixa de 0 a 100.
b) Tabela de graus Celsius/Fahrenheit desde o ponto de fusão até o ponto de ebulição da
água, em incrementos unitários.
c) Altura em centímetros atingida por uma pessoa, em cada e todo aniversário.
d) Linhas de texto correspondentes a uma página.
e) Tabela de preços de um comerciante, que codificou seus produtos na faixa de 100 a 999.
f) Cadeias lidas e já processadas, em um programa que mostra strings invertidas.
g) Pares de coordenadas (X,Y) indicando a seqüência de pontos de um gráfico.
.9.3. Operações com vetores
Quando quisermos referenciar (atribuir ou recuperar o valor) de um elemento, devemos informar

o nome do vetor e a posição do elemento desejado entre colchetes. Se for o primeiro, escrevemos
vFreq[1] (pronuncia-se “vFreq de 1”); o décimo é vFreq[10]. O número entre colchetes, que indica a
posição desejada, é chamado subscrito ou índice.
Exemplos:
vFreq[4] := 100; {atribui o valor 100 ao elemento na posição 4 do vetor vFreq}
Write(vFreq[4]); {recupera o valor do elemento na posição 4 no vetor vFreq e

mostra-o na tela}
Write(vFreq[Pos]); {recupera o valor de Pos, recupera o valor do elemento de

vFreq correspondente ao valor de Pos e mostra-o na tela}
Tenha em mente que um elemento de um vetor é uma variável semelhante

às outras, podendo sofrer atribuição, ser passado como parâmetro ou
participar como operando em expressões, desde que você indique qual é o
elemento.
Outros exemplos de referências válidas a elementos de vetores:

vFreq[Pos] := N;
vFreq[Pos] := vFreq[Pos+1];
vFreq[Pos+1] := vFreq[Pos+2];
v[1] := v[ v[2] ];
A forma de referenciar elementos de vetores é idêntica à maneira de

referenciar caracteres específicos de uma string; na verdade, strings são
vetores do tipo char!
Vejamos um pequeno exemplo inicial.
Prática 9.3 – Vetores

a) Digite o programa abaixo.
PROGRAM MaiordeTres;
{lê três números inteiros (diferentes), calcula e mostra o maior e a respectiva
ordem em que foi lido}
uses CRT;
type tNumeros = array[1..3] of integer;
var vNum : tNumeros;

PosMaior : byte;
begin
ClrScr;
Writeln('Programa para identificar o maior dentre três'
+ ' números inteiros diferentes');
Write('Entre o primeiro número: '); Readln(vNum[1]);
Write('Entre o segundo número: '); Readln(vNum[2]);
Write('Entre o terceiro número: '); Readln(vNum[3]);
if (vNum[1] > vNum[2]) and (vNum[1] > vNum[3]) then
PosMaior := 1
else if vNum[2] > vNum[3] then
PosMaior := 2
else
PosMaior := 3;
Writeln('O maior número foi ', vNum[PosMaior], ' na posição ',
PosMaior);
ReadKey;
end.
b) Execute-o com o debugger até o primeiro Readln. Entre na janela Watches a expressão vNum[1],
para ver o primeiro elemento do vetor. Execute o Readln e observe a janela Watches. Faça o
mesmo para os demais elementos.
c) Para ver todo o vetor, entre na janela Watches apenas o nome dele, vNum.
d) Teste o programa para as seguintes situações:
- maior é o primeiro número lido.
- maior é o segundo.
- maior é o terceiro.
Prática 9.4 – Treinando referências a vetores

Determinar manualmente os valores de X impressos pelo programa abaixo. Depois testá-lo e comparar os
resultados.
PROGRAM PraticaVetores;
type tVet = array[1..5] of byte;
var V : tVet;
X : real;
I : byte;
begin
V[1] := 2; V[2] := 4; V[3] := 1; V[4] := 3; V[5] := 5;
X := V[1] + V[5]; Writeln(X);
X := V[2] - V[5]; Writeln(X);
X := V[4] * V[1] - X; Writeln(X);
I := 4;
X := V[ V[I] ]; Writeln(X);
X := V[ V[I] - 1] / V[ V[3] ]; Writeln(X);
end.

Assinale V ou F:
( ) Um elemento de um vetor pode participar como operando em expressões.
( ) Para referenciar um elemento de um vetor é necessário indicar o nome do vetor e o
subscrito.
( ) Se o subscrito de um elemento de um vetor for uma expressão aritmética, esta será
avaliada antes que o vetor seja acessado.
( ) Um elemento de um vetor pode ser usado em instruções Readln, mas somente se o tipo de
dado do vetor for numérico.
Prática 9.6 – Erros de compilação com vetores

Tente compilar o programa acima com as seguintes modificações (uma de cada vez):
a) retire a palavra array
b) retire o of
c) retire o limite inferior na declaração do vetor
d) idem, limite superior
e) idem, retire o ponto-ponto (..)
f) idem, retire a palavra integer
g) inclua uma referência a V[0]
h) idem, V[6]
i) use para o limite superior um número real (por exemplo, array [1..5.2])
Prática 9.7 – ExemploVetor

a) Digite o programa ExemploVetor. Execute-o com o debugger e abra a janela Watch, incluindo
nela “vFreq” e “vFreq[1]”.
PROGRAM ExemploVetor;
const cMaxNotas = 10;
type tNotas = array [1..cMaxNotas] of word;
begin
vFreq[1] := 400;
vDur[1] := 200;
Sound(vFreq[1]); {recupera}
Delay(vDur[1]);
NoSound;
end.
b) Altere o programa, incluindo atribuições de valores variados aos elementos 2 e 3 de cada vetor.
Inclua também as instruções para tocar os sons. Teste.
c) Agora altere o programa de forma que ele continue atribuindo os mesmos valores aos elementos
1, 2 e 3 mas execute a nota de uma posição informada pelo teclado. Se for informado 2, por
exemplo, o programa faz soar a freqüência de vFreq[2] com a duração vDur[2].
d) No programa acima, a referência vFreq[11] seria inválida, porque o tamanho máximo do vetor é
10 e a numeração é de 1 a 10. Pelo mesmo motivo, vFreq[0] também seria inválida. Para conferir
isso, inclua no programa ExemploVetor atribuições para posições abaixo do limite inferior e
acima do limite superior e tente compilar.
.9.4. Processando todo um vetor
Quando você precisa processar todos os elementos de um vetor, e não sabe quantos elementos de
um vetor serão usados, deve então usar repeat ou while. No trecho abaixo, a leitura deve parar quando
for digitado zero, mas também devemos evitar que o limite do vetor seja ultrapassado:
Pos := 1;
repeat
Readln(vFreq[I]);
Pos := Pos + 1
until (I > MaxNota) or (vFreq[I] := 0)
Se você sabe qual é a última posição, o comando for é o ideal. Veja alguns exemplos para o
vetor de freqüências, supondo que a posição do último elemento é indicada pela variável Pos:
for I := 1 to Pos do {escolha um}
vfreq[I] := 0; {para inicializar}
{ou} Write(vFreq[I]); {para mostrar}
{ou} vfreq[I] := 100 + Random[900];{para preencher com um número

aleatório de 100 a 1000}
Declarando o tamanho do vetor como uma constante

No Pascal o tamanho de um vetor (e conseqüentemente a memória utilizada para armazená-lo) é
definido em tempo de compilação do programa, e não pode ser alterado. Por isso, deve-se ter
cuidado para defini-lo de forma a atender os objetivos do programa sem consumo desnecessário de
memória. Uma forma conveniente de declarar os limites de um vetor é definindo constantes, como
em:
const MaxDisc = 100; {quantidade máxima de disciplinas}
var NomesDisc : array[1..MaxDisc] of string[20];

Notas : array[1..MaxDisc] of real;
Dessa forma você mantém a quantidade de elementos do vetor em um só lugar do programa, e pode
modificá-la, para correção ou otimização, sem ter que procurar cada comando que faça referência ao
tamanho.
Os trechos de programa abaixo utilizam a declaração:

const MaxNotas = 10;
var Notas : array [1..MaxNotas] of real;
Por exemplo, para ler várias notas para o vetor:
for I := 1 to MaxNotas do
begin
Write ('Entre nota ', I, ' ');
Readln(Nota[I]);
end;
Para mostrar na tela todos os elementos de um vetor, um em cada linha:
Writeln(Notas[I]);
Para achar a maior nota:

MaiorNota := 0;
if Notas[I] > MaiorNota then
MaiorNota := Notas[I];
Para preencher um vetor de 100 elementos com inteiros aleatórios, na faixa de 0 a 999:
Randomize; {inicializa gerador de números aleatórios}
for I := 1 to 100 do
Vet[I] := Random(1000);
Para pesquisar uma determinada nota (neste caso, sem o uso do for):
Readln(NotaDesejada);
I := 0;
repeat
I := I + 1
until (Notas[I] = NotaDesejada) or (I > MaxNotas);
if I <=MaxNotas then
Writeln('Encontrada na posição ', I)
else
Writeln('Nota não encontrada');
No Turbo Pascal funções não podem retornar vetores.
Exemplo 9.8 – Cadeias espelhadas
Faça um programa que leia cadeias (qualquer quantidade, limitada a 20) de até 39 caracteres e
mostre-as espelhadas no centro da tela, como no exemplo:
Primeira ariemirP
Segunda adnugeS
Terceira ariecreT
...
Definimos a estrutura básica do programa assim:

"Ler lista de cadeias, lembrando a quantidade digitada"
Para "cada cadeia na lista", faça
"Posicione cursor para mostrar a cadeia normal"
"Mostre cadeia normal"
"Posicione cursor para mostrar a cadeia invertida"
"Inverta e mostre cadeia"
fim
A lista é um vetor com 20 elementos, sendo string o tipo de dado de cada elemento. Uma variável
armazenará a quantidade de cadeias digitadas, já que o vetor pode não ser completamente preenchido.
Precisaremos também de uma variável para a linha, já que cada cadeia será mostrada em uma linha
diferente. Para inverter uma cadeia usamos uma função já vista. Estude os demais detalhes no programa:
PROGRAM EspelhaCadeias;
uses CRT;
const MaxQtCad = 20;
type Str39 = string[39];

tVetCad = array[1..MaxQtCad] of str39;
FUNCTION InverteCad (Cad : string) : string;
var Ap : byte;
CadInv : string;
begin
CadInv := '';
for Ap := Length(Cad) downto 1 do
CadInv := CadInv + Cad[Ap];
InverteCad := CadInv;
end;
var I, QtCad, Linha : byte;

vCad : tVetCad;
begin
{lê e armazena as cadeias}
ClrScr;
Writeln('Mostra cadeias espelhadas na tela'); Writeln;
I := 0;
repeat
I := I + 1;
Write('Cadeia ', I, ' : ');
Readln(vCad[I]);
until (vCad[I] = '') or (I = MaxQtCad);
{Lembra a quantidade de cadeias digitadas}
if vCad[I] = '' then QtCad := I - 1 else QtCad := I;
{limpa a tela e mostra as cadeias normais e espelhadas}
ClrScr;
Linha := 1;
for I := 1 to QtCad do
begin
{Posiciona cursor para mostrar a cadeia normal, de forma
que o último caractere esteja na coluna 39}
GotoXY(39 - Length(vCad[I]), Linha);
Write(vCad[I]);
{Inverte e mostra a cadeia invertida a partir da coluna 41}
GotoXY(41, Linha);
Write(InverteCad(vCad[I]));
Linha := Linha + 1
end;
end.
O programa tem duas telas de saída distintas: a primeira, de digitação das cadeias, e a segunda,
em que são mostradas as cadeias espelhadas. Veja a seguir uma amostra da execução.
Mostra cadeias espelhadas na tela
Cadeia 1 : Em terra de cego,

Cadeia 2 : Quem tem um olho
Cadeia 3 : Anda vendo coisas...
Cadeia 4 :
Em terra de cego, ,ogec ed arret mE

Quem tem um olho ohlo mu met meuQ
Anda vendo coisas... ...sasioc odnev adnA
Prática 9.9 – EspelhaCadeias

Inclua no programa EspelhaCadeias uma repetição para que, após mostrar as cadeias espelhadas, ele
pergunte ao usuário se deseja repetir e, se a resposta por positiva, volte para ler novamente outras cadeias.
Prática 9.10 - Vetores com comandos de repetição

O programa TocaVetor abaixo implementa a especificação do início do texto. Teste o programa usando as
seis notas do Parabéns (pág. 76)
PROGRAM TocaVetor;
{lê várias freqüências e durações para um vetor
e depois "toca" as notas na seqüência}
uses CRT;
type tNotas = array [1..cMaxNotas] of word;

Pos, I : byte;
begin
ClrScr;
{leitura das notas}
Pos := 0;
repeat
Pos := Pos + 1;
Write('Freqüência ', Pos, ': ');
Readln(vFreq[Pos]);
Write('Duraçao ', Pos, ': ');
Readln(vDur[Pos]);
until (vFreq[Pos] = 0) or (vDur[Pos] = 0)
or(Pos > cMaxNotas);
{toca notas no vetor}
for I := 1 to Pos - 1 do
begin
Sound(vFreq[I]);
Delay(vDur[I]);
NoSound;
end;
end.
Note em particular no programa acima:

− Há uma variável (Pos) para controlar a posição de inserção nos vetores. Ela sempre
aponta para a próxima posição livre.
− Na primeira parte, a leitura dos valores, foi usado um repeat, já que não se sabe quantas
notas o usuário irá entrar. Já na segunda parte, sendo conhecida a quantidade de pares completos
lidos (Pos –1), usou-se for.
− A repetição da leitura termina se um dos valores lidos foi zero ou se foi atingido o
tamanho máximo do vetor.
− Cada vez que é feita a inserção de um par completo freqüência/duração, a variável Pos é
incrementada, para apontar para a próxima posição do vetor.
Especificação 9.11 - Música aleatória

Faça um programa com os mesmos vetores do programa TocaVetor que, ao invés de ler os valores do
teclado, e usando um comando FOR, sorteia as 10 freqüências na faixa de 300 a 3000 [300 +
Random(2700)] e as 10 durações na faixa de 20 a 200 [20 + Random(180)]. A cada execução uma
“música” diferente! Lembre-se de chamar a instrução Randomize antes de começar o sorteio.
Prática 9.12 – Outros vetores

Faça um programa de teste e tente compilar as seguintes declarações de vetores. Assinale as válidas:
a) type tStringGrande = array [1..1000] of char;

b) type tTabFahreneitCelsius = array [32..212] of real;
c) type tGraus = array [-360..360] of real;
d) type tProdutos = array [1000..9999] of string[4];
e) type tSimNao = array [1..20] of boolean;
f) type tTextoLongo = array [-10000000..10000000] of char;
g) type tSubFaixa = array [1..10] of (1..6);
h) type tNota = (0..10)
i) type tNotas = array [1..50] of tNota;
Especificação 9.13 – Média

Escrever um programa que leia 20 números inteiros para um vetor e calcule a média dos valores.
Especificação 9.14 – Média v2

Altere o programa anterior para que leia até 20 números inteiros para um vetor e calcule a média dos
valores (declare uma variável para controlar quantos números foram lidos).
Especificação 9.15 – Maior e menor

Escrever um programa que preencha um vetor de 100 elementos com valores inteiros aleatórios, e
identifique o maior e o menor número gerados, e respectivas posições.
Especificação 9.16 – Tabela de temperatura

Implementar um programa que monta uma tabela de graus Celsius/Fahrenheit desde o ponto de fusão até
o ponto de ebulição da água, em incrementos unitários. Após são oferecidas opções para o usuário ver na
tela ou imprimir.
Especificação 9.17 – Pesquisa notas

Elaborar programa com opções para: ler 10 notas de 0 a 10, pesquisar se uma nota existe no vetor e
mostrar o conteúdo do vetor. Na leitura, rejeitar notas fora da faixa válida.
Especificação 9.18 – Nome do dia

Construa um programa que lê um número de 1 a 7 e informa, usando vetor, o dia da semana
correspondente, sendo domingo o dia de número 1. Se o número estiver fora da faixa válida, é mostrada
uma mensagem de erro. Declare uma função que recebe o dia e retorna o nome do dia.
O Turbo Pascal permite declarar constantes tipadas, isto é, com tipo

também declarado. Isto é útil para inicializar vetores que contém valores
constantes. Por exemplo, para a especificação acima:
const Dias : array [1..7] of string[10] = ('Domingo', 'Segunda', 'Terça',

'Quarta', 'Quinta', 'Sexta', 'Sábado');
Especificação 9.19 – Nome do mês

Escrever uma função que recebe número do mês e retorna seu nome por extenso. Inseri-la em um unit
juntamente com a função da especificação anterior.
Especificação 9.20 – Alunos e notas

Implemente um programa que lê uma lista de pares nomes de aluno/notas. Depois são mostrados na tela
os nomes e as notas, juntamente com a quantidade de alunos e a média das notas.
Especificação 9.21 – Troco

Implemente um programa que resolve o problema do troco: dado um valor de uma venda, um valor pago
e um estoque de notas e moedas (todos os possíveis), calcular o troco e as notas ou moedas e respectivas
quantidades que devem ser entregues ao cliente. Procure estruturas de dados que permitam soluções mais
simples, como por exemplo um vetor com o valor de cada nota ou moeda, em ordem decrescente de
valor.
Especificação 9.22 – Palavras grandes

Faça um programa que lê uma cadeia de até 10 caracteres e a mostra na tela com letras grandes. Cada
letra é formada por uma matriz 8x8, com algum caractere nas posições adequadas de forma a compor o
desenho de cada letra (cada caractere é como se fosse um pixel - veja sugestão abaixo). Para separar uma
letra da outra, quando mostradas na tela, você pode deixar em branco uma linha e uma coluna de cada
letra, na própria matriz.
*
* *
* *
* *
* * * * *
* *
* *
Especificação 9.23 – Sena

Faça um programa que lê apostas da sena, os números sorteados e apresente os resultados obtidos pelo
apostador: senas, quinas e quadras.
Especificação 9.24 – Codificação de preço

Certas lojas usam (ou pelo menos usavam) um sistema de codificação de preços associando os dez dígitos
à palavra PERNAMBUCO. Implemente um programa que lê um preço e mostra-o codificado, ou lê um
código e mostra o preço.
Especificação 9.25 – Maior e menor

Escrever um programa com quatro opções (implementadas através de instruções declaradas): preencher
um vetor de 10 elementos com valores inteiros aleatórios, mostrar o conteúdo do vetor, identificar o
maior e o menor número gerados, e respectivas posições.
.9.5. Registros
Como vimos, um elemento de um vetor pode ser apenas de um tipo de dado. Em algumas
situações, isto pode ser inconveniente. Suponha que uma especificação pede para armazenar nomes de
disciplinas e respectivas notas. Sem algum outro recurso, precisaríamos declarar um vetor de cadeias para
as disciplinas e outro, de reais, para as notas.
O Pascal permite uma solução elegante para este inconveniente, por meio da declaração de vários
dados em um único tipo de dado: o registro. Um registro é um agregado de variáveis, de tipos de dados
distintos, em um único tipo de dado, que por isto é chamado de estruturado. Podemos usar registros
isoladamente, combinados com vetores e também para usar em arquivos.
Um registro é declarado através da palavra reservada record, seguida das declarações das
variáveis que o compõem, e terminando com end. Tipicamente efetua-se a declaração em uma seção
type, embora ela possa ocorrer diretamente na seção de variáveis. Veja os exemplos de declaração de
registros e de variáveis:
type tData = record

Dia, Mes : byte;
Ano : integer;
end;
tNota = record
NomeDisciplina : string[15];
ValorNota : real;
end;
tCoordenadas = record
X, Y : byte
end;
tPessoa = record
Nome : string[30];
Endereco : string[50];
DataNasc : tData;
Fone : string[10];
E-mail : string[30];
end;
var PosicaoTela : tCoordenadas;

Cliente : tPessoa;
Observe na última declaração da seção type como um registro pode ser composto de outros
registros: o tipo tPessoa contém o campo DataNasc, que por sua vez é também um registro, composto dos
campos Dia, Mes e Ano.
Referências a campos - Para atribuir a ou recuperar valores de campos, é preciso indicar tudo o
que for preciso para o compilador identificar o campo sem ambigüidade: o nome da variável e o nome do
campo, separados por um ponto. Para simplificar as referências a campos, podemos usar a declaração
With...do, na qual indicamos o nome do registro que será referenciado. Dentro do escopo do With,
podemos escrever somente o nome dos campos.
Para exemplificar, primeiro declaramos um registro com nome de disciplina e valor da respectiva
nota. Depois definimos um vetor com capacidade de armazenar até 20 registros de notas. Finalmente,
declaramos um registro para armazenar informações sobre alunos, contendo um nome e uma lista de
notas. Observe no bloco de código abaixo as várias possibilidades de referência a campos, incluindo
declarações With.
PROGRAM ExemplosReferenciasACampos;
type tNota = record

NomeDisciplina : string[15];
ValorNota : real;
end;
tVetNotas = array[1..20] of tNota;
tAluno = record
Nome : string[30];
Notas : tVetNotas;
end;
var vAlunos : array[1..50] of tAluno;

begin
{referências normais a campos de registros}
vAlunos[1].Nome := 'Adalberto';
vAlunos[1].Notas[1].NomeDisciplina := 'Português';
vAlunos[1].Notas[1].ValorNota := 7.5;
vAlunos[1].Notas[2].NomeDisciplina := 'Inglês';
vAlunos[1].Notas[2].ValorNota := 8;
{forma simplificada de referência a campos usando With}

With vAlunos[1] do
begin
Nome := 'Adalberto';
Notas[1].NomeDisciplina := 'Português';
Notas[1].ValorNota := 7.5;
With Notas[2] do
begin
NomeDisciplina := 'Inglês';
ValorNota := 8;
end;
end;
end.
Podemos aplicar o recurso de declarar registros no programa que toca músicas. Ao invés de
declarar dois vetores, precisamos de apenas um:
type tNota = record
Freq, Dur : word;
end;
tMusica = array [1..10] of tNota;
Veja no quadro como fica o programa TocaVetor usando essas declarações.

PROGRAM TocaVetor_v2;
uses CRT;
type tNota = record

Freq, Dur : word;
end;
tMusica = array [1..cMaxNotas] of tNota;
var vMusica : tMusica;

Pos, I : byte;
begin
ClrScr;
Pos := 0;
repeat {leitura das notas}
Pos := Pos + 1;
Write('Freqüência ', Pos, ': '); Readln(vMusica[Pos].Freq);
Write('Duração ', Pos, ': '); Readln(vMusica[Pos].Dur);
until (vMusica[Pos].Freq = 0) or (vMusica[Pos].Dur = 0)
or (Pos > cMaxNotas);
{toca notas no vetor}
for I := 1 to Pos - 1 do
begin
with vMusica[I] do
begin
Sound(Freq);
Delay(Dur);
NoSound;
end;
end;
end.
Prática 9.26 – TocaVetor_v2

a) Digite e teste-o.
b) Altere o programa TocaVetor_v2 para usar with também no bloco de leitura
Exercício 9.27 - Declaração de registros

Declare registros e vetores para representar:
a) Altura em centímetros e peso em kg com uma casa decimal, atingidos por uma pessoa,
em cada e todo aniversário.
b) Pares de coordenadas (X,Y) indicando a seqüência de pontos de um gráfico
c) Lista de arquivos, contendo nome, extensão, tamanho em bytes, data e hora.
d) Salários recebido em um ano por um funcionário, incluindo valores bruto e líquido, INSS
e IRPF.
Especificação 9.28 – Soma em vetor 1

Escrever um programa que, após preencher dois vetores com números inteiros aleatórios, soma os valores
dos elementos correspondentes de dois vetores, armazenando o resultado num terceiro vetor.
Especificação 9.29 – Soma em vetor 2

Elabore um programa semelhante ao anterior, exceto que, em apenas um vetor, soma os valores de dois
campos e armazena o resultado em um terceiro campo de um registro.
Especificação 9.30 – Validação de senha

Implementar um programa que lê um nome e uma senha (entre 4 e 8 caracteres) e verifica e o usuário está
autorizado ou não. Para essa verificação, o programa mantém uma lista de nomes e respectivas senhas. O
programa mostra mensagens de erro se o nome ou a senha estiverem incorretos. São permitidas até 3
tentativas.
Especificação 9.31 – Validação de senha v2

Faça um programa semelhante ao anterior, mas que apresenta um menu com opções para: incluir nomes e
senhas, ler e validar nome e senha, zerar vetor de senhas, terminar.
Especificação 9.32 – Média ponderada

Escrever um programa que calcula médias ponderadas para uma quantidade de fatores de até 15. O
programa lê vários pares [número, peso] até que seja lido um número negativo. É calculada então a
média, somando-se os produtos de cada número por seu peso e dividindo-se o resultado pela soma dos
pesos.
.9.6. Matrizes
Um professor quer fazer um programa que armazene notas de alunos para cada disciplina que
leciona e mostre algumas informações. O que ele deseja é uma tabela com a forma:
Aluno/Disciplina IPD LP1 Bancos de dados
Gilberto 7.5 8 8.5
Patrícia 4 4.5 6
Simone 8 10 9.5
Qual será a melhor estrutura de dados para armazenar esta tabela? O que o professor precisa é de
uma extensão do conceito de vetores, chamada matriz. Ao invés de apenas uma dimensão, como os
vetores, matrizes são listas multidimensionais; no exemplo acima, a estrutura adequada é uma matriz de
duas dimensões.
As diferenças básicas entre vetores e matrizes são:
• Na declaração, devemos informar a faixa de subscritos para cada dimensão:

var Mat := array [1..10, 1..20, 1..5] of byte;
• Ao acessar um elemento de uma matriz, devemos informar o subscrito para cada dimensão:
Mat[1, 11, 2] := 77;
Readln( Mat[9, 7, 1] );
Writeln( Mat[2, 5, 5] );
Exemplo 9.33 - Ache a careta

Elaborar um programa que preenche uma área da tela (15x15) com caracteres aleatórios e
esconde algum caractere ASCII (como o 1, uma careta) em uma posição aleatória, para o
usuário descobrir onde está. Antes de preencher a tela, monte-a em uma matriz com os códigos
ASCII. Use constantes para definir a área da tela que será usada e o código do caractere a
esconder.
Note que para a solução não precisamos estritamente usar uma matriz, mas fazer isso proporciona
flexibilidade de incorporação de novas características. Veja a seguir o programa AcheNaTela, com
exemplo de uma tela gerada (os caracteres podem não ser exatamente os mesmos, devidos a diferenças
nas páginas de código do sistema operacional).
++²Éâ+¼åñ+¿ª_+É
¬+£+ä__ö_☺ò+Ö_+
úè-_ö+«ÖäÇéó-++
+û+¦+¦++ÜÆ_â-+·
¦++_¿-Ñ_+ú+¦á+_
_+-äáº»Öæ¦-àß_+
¦n+_++«_•¦+éú½_
à•ÅÇü¬É·-¦£+_-»
û¼°ªÖ-__+_•+__¦
•_+__ùÉ¥±_¦á+ó¦
¡²¦+û_½_¦_+ê_²+
»___Å+°____ú¦Ö_
â«¥æâúÄÿ__Ç__++
+_¦+¿__-_++·---
ºn_+±¦_½+ü___¦ß
Ache o ☺!
PROGRAM AcheNaTela;
{Esconde uma careta na tela preenchida com caracteres aleatórios, para
a pessoa descobrir onde está}
uses CRT;
const cMaxLin = 15;

cMaxCol = 15;
cCarEscondido = 1;
var vTela : array[1..cMaxLin,1..cMaxCol] of byte;

L, C : byte;
begin
{Preenche a matriz com caracteres aleatórios na faixa ASCII superior a 127}
Randomize;
for L := 1 to cMaxLin do
for C := 1 to cMaxCol do
vTela[L,C] := 128 + Random(126);
{Sorteia posição e põe a careta}

vTela[1+Random(cMaxLin-1),1+Random(cMaxCol-1)] := cCarEscondido;
{transpõe para a tela}

ClrScr;
for L := 1 to cMaxLin do
for C := 1 to cMaxCol do
begin
GotoXY(C,L);
Write(Chr(vTela[L,C]));
end;
GotoXY(1, cMaxLin+2);
Write('Ache o ', chr(cCarEscondido),'!');
ReadKey;
end.
Exemplo 9.34 - Rifa

Veja agora um exemplo de como o comportamento de um vetor de strings é o mesmo de uma matriz.
Uma rifa é sorteada com base nos números da Loteria Federal da seguinte maneira: o primeiro
prêmio é formado obtendo-se o primeiro dígito de cada prêmio. O segundo é obtido através dos
segundos dígitos, e assim por diante. Por exemplo, suponha que os números da Loteria Federal
são:
1 - 45.698
2 - 65.788
3 - 01.214
4 - 37.840
5 - 77.430
Os prêmios da rifa serão 46.037, 55.177, etc.
A estrutura do programa é simples: ler os números sorteados na loteria, identificar os números premiados
na rifa, mostrar os números premiados na tela. Portanto, vamos nos concentrar no passo "identificar os
números premiados" e elaborar um algoritmo. A escolha da estrutura de dados aqui é a chave: apesar de
os dados serem números, representá-los como strings torna mais fácil a solução; teremos um vetor de
strings para os prêmios da loteria e outro para a rifa. E como strings são um tipo de vetor, estamos
tratando com uma matriz 5x5. O algoritmo equivale a inverter uma matriz: o que é linha vira coluna e
vice-versa.
PROGRAM CalculaNumerosRifa;
type tPremios = array [1..5] of string[5];
var vLot, vRifa : tPremios;

Premio, Posicao : byte;
PROCEDURE CalcNumRifa(var vLoteria, vRif : tPremios);

{acha os números premiados na rifa a partir dos números premiados
na rifa}
begin
for Premio := 1 to 5 do
begin
vLoteria[Premio] := '';
for Posicao := 1 to 5 do
vRif[Premio] := vRif[Premio] + vLoteria[Posicao,Premio]
end;
end;
begin
{leitura dos números sorteados na loteria}
For Premio := 1 to 5 do begin
Write('Numero ', Premio, ': ');
Readln(vLot[Premio]);
end;
CalcNumRifa(vLot, vRifa);
Writeln('Números da rifa:'); {mostra resultados}
For Premio := 1 to 5 do
Writeln(Premio, ': ',vRifa[Premio]);
end.
Exercício 9.35 - Declaração de matrizes

Defina e declare em Pascal estruturas de dados apropriadas para representar
a) Um texto com até 1000 caracteres
b) Um texto com até 1000 linhas de 80 caracteres cada uma

c) jogo-da-velha
d) um tabuleiro de damas (casas, posição e cor da pedra)
e) um tabuleiro de batalha naval
f) um tabuleiro de xadrez
g) todas as posições de uma tela de computador em modo texto padrão (25x80)
h) as 25 linhas da tela
i) O jogo Campo Minado, do Windows.
j) um labirinto (paredes, localização do tesouro e do monstro, ou outra coisa que você
inventar).
Especificação 9.36 – AcheNaTela com cor

Altere o programa AcheNaTela para que seja sorteado e armazenado, além do código ASCII de cada
caractere, a sua cor. Ao transpor a matriz para a tela, ajuste também a cor de cada caractere.
Prática 9.37 – CalculaNumerosRifa

Teste o programa CalculaNumerosRifa com os mesmos números do exemplo.
Especificação 9.38 – Soma de matrizes

Elabore um programa que lê duas matrizes 2x2, efetua sua soma (elemento a elemento) em uma terceira e
mostra todas as elas na tela.
Especificação 9.39 – Matriz inversa

Elabore um programa que preenche uma matriz 5x5 com caracteres ASCII aleatórios e depois a mostra na
tela com está e invertida, isto é, as linhas se tornam colunas e vice-versa.
Exercício 9.40 - Diferenças

Descreva as diferenças entre vetores e matrizes.
Exercício 8.41 – AcheNaTela v2

Descreva como o programa AcheNaTela poderia ser implementado sem a declaração de uma matriz.
Especificação 9.42 – Quadrado mágico

Um quadrado mágico é aquele dividido em linhas e colunas, com um número em cada posição e no qual
a soma das linhas, colunas e diagonais é a mesma. Por exemplo, veja um quadrado mágico de lado 3, com
números de 1 a 9:
8 3 4
1 5 9
6 7 2
Elabore um programa que identifica e mostra na tela todos os quadrados mágicos com as características
acima. Analise os quadrados mostrados e verifique se há alguma diferença básica entre eles ou se podem
ser considerados os mesmo sob algum aspecto. [Dica: produza todas as combinações possíveis e
verifique a soma quando completar cada quadrado. Usar um vetor de 1 a 9 (a estrutura que usei) parece
ser mais simples que usar uma matriz 3x3]
Especificação 9.43 – Preenchimento de matriz

Considerando que cada elemento de uma matriz bidimensional é designado por A ij ou A(i,j), declare uma
instrução que preenche cada elemento de uma matriz MxN com i+j. Faça um programa de teste que
chama a função para pelo menos 3 combinações de M e N.
206
.10 TRABALHO FINAL
Uma das melhores formas de aprender a programar é lidando com situações novas, para as quais
você acha uma solução onde antes pouco sabia. Fazer um programa maior é uma forma de fazer isto, ao
mesmo tempo em que os novos conhecimento são integrados. Por isto, você deve fazer pelo menos um
dos trabalhos indicados neste capítulo. Use como inspiração a implementação descrita. E envie-me o
programa para que seja incluído como demonstração nesta apostila!
Não imagine que um programa é implementado linearmente, etapa por etapa. É mais provável
que você vá e volte várias vezes nas várias fases, à medida em que amadurece sua compreensão da
especificação e do resultado final.
.10.1.Especificação
Escrever um programa para fazer estatísticas de notas de um aluno. O programa oferece opções
de: entrar com nomes de disciplinas e respectivas notas, achar a maior nota, achar a menor nota e
calcular a média das notas. Quando mostra algum resultado, o programa espera ser teclado algo para
oferecer novamente o menu.
O primeiro passo é ler a especificação algumas vezes, e deixar que sejam formadas as primeiras
impressões. Neste ponto descobrimos muitas coisas que não sabemos.
.10.2.Projeto
O programa tem um menu inicial, mencionado na especificação. Assim, a tela inicial conterá as
quatro opções previstas na especificação e uma outra para terminar o programa. Ela fica definida como
abaixo. Note que nosso objetivo é ilustrar as etapas de programação e por isto evitamos "enfeites", do tipo
formatação de tela. Fique à vontade para embelezar seus programas, se tiver tempo para isso.
ESTATÍSTICA DE NOTAS
0 - Fim
1 - Entra valores
2 - Maior nota
3 - Menor nota
4 - Media
Opção: _
Quando o usuário escolher, o programa fará o que for pedido abaixo do menu. Por exemplo, a
entrada de valores pode ocorrer assim:
11 - TRABALHO FINAL 207
ESTATÍSTICA DE NOTAS
0 - Fim
1 - Entra valores
2 - Maior nota
3 - Menor nota
4 - Media
Opção: 1
Tecle Enter na disciplina para terminar
Nome da disciplina: Calculo
Nota de Calculo : 8
Nome da disciplina: Pascal
Nota de Pascal : 9.5
Nome da disciplina: TGA
Nota de TGA : 7.5
Nome da disciplina: _
0 - Fim
1 - Entra valores
2 - Maior nota
3 - Menor nota
4 - Media
Opção: 4
Media das notas: 8.33
Assim que o usuário teclar Enter no nome da disciplina, limpamos a tela e reapresentamos o
menu. Para as demais opções simplesmente é mostrado o que foi pedido e espera-se uma tecla antes de
limpar a tela e mostrar novamente o menu. Ao elaborar seus projetos, recomendo detalhar todo o
programa.
.10.3.Programa-fonte
Podemos começar o programa-fonte pela sua estrutura, representada por um diagrama de blocos.
Poderíamos fazer refinamentos sucessivos, se quiséssemos. Veja a seguir; por questões de espaço, não
está representada a opção de cálculo da menor nota.
Precisamos de uma estrutura de dados que guarde as notas: um vetor de notas e disciplinas,
numerado de 1 até a quantidade máxima de notas que se espera. Para facilitar as declarações e eventuais
alterações, declaramos a quantidade de elementos como uma constante e o tipo do vetor em uma
declaração type. Cada elemento do vetor de notas irá armazenar uma nota e uma disciplina, portanto o
tipo de dado será um registro com um campo real e outro string. As declarações serão:
const MaxNotas = 50;
type str15 = string[15];

Notas = record
Disc : str15;
Nota : real;
end;
tvetNotas = array [1..cTamVet] of Notas;
Uma questão surge: quando o usuário for usar o programa, ele sempre digitará 50 disciplinas?
Dificilmente. Precisamos então controlar quantas disciplinas (e portanto notas) o usuário digitou: uma
variável, que chamaremos MaxAtual. Esta variável servirá de referência para acessos ao vetor, ao invés
da constante que indica o tamanho do vetor.
E s t a t í s t ic a d e
n o t a s d e a lu n o
B lo c o d e
I n ic ia liz a ç ã o c o n t r o le F in a liz a ç ã o
M e n u S e le ç ã o
L e it u r a d a s C á lc u lo d a C á lc u lo d a
n o t a s m a io r n o t a m é d ia
C a l c u l a M r o s t r a r C m a a l ci o u r l a r m é d ia
E n t r a d a V a lid a ç ã o M o s t r a r m é d
m a i o r n o t na o t a d e n o t a s
A partir do diagrama de blocos, identificamos as instruções que podemos declarar. Para as ações
de achar a maior nota, a menor e a média, como cada uma retorna apenas um valor inteiro ou real, serão
três funções. Para que sejam independentes das variáveis globais, os dados de entrada são declarados
como parâmetros, e a saída é o valor de retorno da função. Podemos inicialmente definir somente os
cabeçalhos:
FUNCTION PosMenor (vNotas : tVetNotas; Max : byte ) : byte;

{retorna subscrito da menor nota}
FUNCTION PosMaior (vNotas : tVetNotas; Max : byte ) : byte;

{retorna subscrito da maior nota}
FUNCTION Media (vNotas : tVetNotas; Max : byte ) : real;

{retorna media das notas}
Podemos escrever cada uma conhecendo apenas o que devem fazer e as estruturas de dados
escolhidas; veja a seguir. Não há trabalho significativo relacionado aos algoritmos, todos foram baseados
no conteúdo do capítulo sobre vetores. Mas se fosse necessário, desenvolveríamos cada um em separado
dos demais, facilitando bastante o processo.

var P, S : byte;
begin
P := 1;
for S := 2 to Max do
if vNotas[S].Nota < vNotas[P].Nota then P := S;
PosMenor := P
end;

var P, S : byte;
begin
P := 1;
if vNotas[S].Nota > vNotas[P].Nota then P := S;
PosMaior := P
end;

var Soma : real;

S : byte;
begin
Soma := 0;
for S := 1 to Max do Soma := Soma + vNotas[S].Nota;
Media := Soma/Max
end;
.As variáveis globais que precisam ser declaradas são as mesmas que devem ser passadas para as
funções, mais o vetor das disciplinas e a opção. Para estrutura melhor o programa, decidimos declarar
instruções também para a leitura da opção e entrada de notas:
- Mostrar o menu, ler e retornar a opção (função)
- Ler e retornar valores das notas, disciplinas e a quantidade de notas lidas (procedimento)
Podemos agora montar o programa juntando as várias partes elaboradas em separado e

codificando as partes mais simples que faltavam:
PROGRAM EstatisticaDeNotas;
uses CRT;
const cTamVet = 20;
type str15 = string[15];

Notas = record
Disc : str15;
Nota : real;
end;
tvetNotas = array[1..cTamVet] of Notas;
var N : tvetNotas;
Opcao, MaxAtual, Pos : byte;
FUNCTION Menu : byte;

{mostra menu, lê e retorna opção}
var Op : byte;
begin
Writeln('0 - Fim');
Writeln('1 - Entra valores');
Writeln('2 - Maior nota');
Writeln('3 - Menor nota');
Writeln('4 - Media');
Write('Op: '); Readln(Op);
Menu := Op;
end;
PROCEDURE EntraValores( var VNotas : tVetNotas;

var Max : byte );
{Lê e retorna disciplinas, notas e quantidade}
var S : byte;
begin
S := 0;
Writeln('Tecle Enter na disciplina para terminar');
Repeat
S := S + 1;
With vNotas[S] do
begin
Write('Nome da disciplina: ');
Readln(Disc);
if Disc <> '' then
begin
Write('Nota de ',Disc , ' : ');
Readln(Nota);
end
end;
Until (vNotas[S].Disc = '') or (S = cTamVet);
if S < cTamVet then Max := S - 1 else Max := S;
end;

var P, S : byte;
begin
P := 1;
if vNotas[S].Nota < vNotas[P].Nota then P := S;
PosMenor := P
end;

var P, S : byte;
begin
P := 1;
if vNotas[S].Nota > vNotas[P].Nota then P := S;
PosMaior := P
end;

var Soma : real;

S : byte;
begin
Soma := 0;
for S := 1 to Max do Soma := Soma + vNotas[S].Nota;
Media := Soma/Max
end;
{bloco de código principal}

begin
repeat
ClrScr;
Opcao := Menu;
case Opcao of
0 :;
1 : EntraValores(N, MaxAtual);
2 : begin
Pos := PosMaior(N, MaxAtual);
Write('Maior nota: ', N[Pos].Nota:5:1,
' na disciplina ', N[Pos].Disc);
end;
3 : begin
Pos := PosMenor(N, MaxAtual);
Write('Menor nota: ', N[Pos].Nota:5:1,
' na disciplina ', N[Pos].Disc);
end;
4 : Writeln('A média das notas é: ', Media(N, MaxAtual):10:2);
else Writeln('Opção inválida.');
end;
ReadKey
until Opcao = 0;
end.
Uma opção adicional para este programa seria declarar as instruções relativas a notas em uma
unit.
Como exercício, inclua opções no programa para:
a) Mostrar o conteúdo atual dos vetores de notas e disciplinas

b) Dada uma disciplina, pesquisar a nota correspondente
c) Dada uma nota, pesquisar se ela existe no vetor de notas e mostrar a respectiva disciplina
.10.4.Teste
Uma vez compilado o programa, deve-se testá-lo, comparando os resultados obtidos com a
especificação. Vamos vê-la outra vez:
Escrever um programa para fazer estatísticas de notas de um aluno. O programa oferece opções
de: entrar com nomes de disciplinas e respectivas notas, achar a maior nota, achar a menor nota e
calcular a média das notas. Quando mostra algum resultado, o programa espera ser teclado algo para
oferecer novamente o menu.
O programa pode ter erros de lógica, de controle e outros. No mínimo, o teste deve responder
favoravelmente às seguintes perguntas, elaboradas com base na especificação, no projeto e no programa-
fonte:
1) O menu contém as opções corretas?
2) O programa termina normalmente quando selecionada a respectiva opção do menu?
3) Todas as opções do menu estão sendo selecionadas?
4) A leitura das notas é efetuada corretamente? As notas e disciplinas estão sendo
armazenadas corretamente no vetor?
5) A maior nota é encontrada e mostrada corretamente?
6) A menor nota é encontrada e mostrada corretamente?
7) A média das notas é calculada e mostrada corretamente?
8) O programa espera uma tecla após mostrar um resultado?
9) O menu é mostrado novamente após um ciclo de seleção?
Com o tempo e a experiência, os programadores desenvolvem um "feeling", uma sensação de

segurança ou insegurança com relação à correção de um programa. Se algo ainda o incomoda, continue
testando!
.10.5.Idéias para trabalhos
Ao escolher alguma das idéias desta seção, certifique-se de definir uma especificação completa,
adequada ao prazo disponível, e fazer o projeto, antes da decisão final.
10.1 – AcheNaTela
Inclua os seguintes recursos no programa AcheNaTela (pág. 202):
a) Crie um menu com as opções Configurar, Jogar, Terminar. Na opção de configuração, permita ao
usuário indicar o grau de dificuldade, determinado pela área da tela usada, e o caractere que deve ser
escondido.
b) Ao jogar, ofereça opções para imprimir o jogo, para mostrar onde está o caractere escondido e para
jogar novamente.
10.2 – Forca
Implementar um programa que jogue o jogo da forca. Na tela é mostrado o alfabeto, destacando as letras
já tentadas. Um banco de palavras pode ser implementado em vetor ou em arquivos, permitindo ao
programa sortear uma palavra. Extensões: armazenar histórico do jogador: nome, jogadas ganhas e
perdidas, etc.
10.3 – Controle de senhas

Implemente um programa que faz um controle de senhas. Veja o projeto na figura. Os traços à esquerda
são os locais onde o usuário entra com os comandos de linha, o que implica em um cursor que indique a
ele onde está digitando.
Se quiser sofisticar e fazer um programa realmente útil, veja como se lida com arquivos no Turbo Pascal
e grave os dados.
CONTROLE DE SENHAS
Usuário: Fulano (digite outro para mudar)
LOCAL NOME SENHA

_ New York Times Fulano 1234
_ Sterling Fulano 1234
_ Altavista Fulano11 5678
_ Bco do Brasil C/C 123456
_ HotMail Fulano17 1234
_ (digite nova) ________ _______
Comandos de linha - E: exclui A: altera

Outros comandos – I: imprime PgUp: acima PgDn: abaixo
ESC: sai
10.4 – Jogo da velha

Desenvolva um programa que jogue o jogo-da-velha. Ele pode ser um monitor, que controla dois
jogadores, ou pode ser inteligente, que joga contra um jogador.
10.5 – Quadrado mágico

Faça uma variação do programa do quadrado mágico, na página 204. O programa pode por exemplo
editar um quadrado e verificar se está correto. Se quiser, pesquise mais sobre o assunto; vários números
da revista Superinteressante exploraram bastante inúmeros tipos de quadrados mágicos.
10.6 – Robô
Faça um programa que entende alguns comandos simples do robô, como Ande e Vire. Algo que
representa o robô se move na tela em resposta aos comandos.
10.7 – Palavra embaralhada

Implementar um programa que, a partir de um banco de palavras, seleciona aleatoriamente uma palavra,
embaralha as letras e dá um tempo para o usuário adivinhar a palavra.
10.8 – Combinações de letras

Implementar um programa que lê uma palavra de 4 letras e gera todas as combinações possíveis das
quatro letras, sem repetição. O programa deve fornecer um menu para o usuário, permitindo:
- entrar nova palavra
- gerar combinações
- mostrar na tela (formatadas em colunas)
- imprimir (também em colunas)
- eliminação de palavras indesejadas (por exemplo, que não existam).
10.9 – Bingo
Elabore um programa que faz sorteios de bingo. O programa deverá oferecer opções de iniciar um sorteio,
sortear um número e apresentar os números sorteados até um determinado momento. Note que o
programa não poderá repetir um número já sorteado.
10.10 – Desenho datilográfico

Implementar um programa que permite o uso de toda a tela para desenhos utilizando caracteres
disponíveis no teclado.
10.11 – Ping-Pong
Talvez você não conheça, mas um dos primeiros videogames era um Philco monocromático, e um dos
jogos, chamado de Ping-Pong, tinha duas "raquetes" que se moviam na vertical das laterais da tela e uma
"bolinha", cuja velocidade aumentava depois de algumas "raquetadas" dos jogadores. Um jogador fazia
um ponto quando o adversário deixava a bolinha passar; quem fizesse 15 pontos primeiro ganhava.
Implemente esse jogo. Uma alternativa mais simples é uma só raquete com um paredão.
10.12 – Meteoros: o jogo

Uma nave espacial, embaixo na tela, deve ultrapassar um campo de meteoros (por exemplo, se em modo
texto, asteriscos), desviando-se à esquerda ou direita. Se tocar em algum, ela explode. Cada "linha" de
meteoros ultrapassada conta um ponto, e a velocidade dos meteoros vai aumentando, digamos, a cada 500
pontos. Implementar o jogo. Entre outras coisas, o programa deverá preencher a próxima linha de
meteoros, no alto da tela, e mover esta uma linha para baixo (supondo ainda que a tela estará em modo
texto), além de verificar se houve colisão. Certifique-se de ter tempo suficiente para esta implementação...
10.13 – Lista de compras

Elabore um programa que mantém uma lista de produtos e imprime uma relação para controle da pessoa
no supermercado, por exemplo. Inclua uma opção para eliminar itens da lista a ser impressa. Para montar
a lista inicial, você pode pesquisar na Internet por um serviço de delivery.
10.14 – Etiquetas para cheques

Faça um programa que preenche mini-etiquetas para afixar em folhas de cheque, contendo nome,
endereço, telefone e RG. Provavelmente você terá que pesquisar os comandos de movimentação do carro
da impressora, para obter ajuste fino e assim manter o posicionamento correto.
10.15 – Tabuada
Implementar um programa para crianças que apóia o aprendizado de tabuada. Entre outras coisas, o
programa pode propor à criança seqüências de um mesmo número ou aleatórias. Pode também mostrar
números em tamanho maior. Se quiser sofisticar mesmo, armazene estatísticas de erros e acertos, e faça o
programa reforçar os pontos fracos.
10.16 – Código Morse

Implemente um tradutor de código Morse. Pode ter opções para som, imagens ou listagens. Dizem que só
a Marinha ainda usa esse código, mas pode ser um bom exercício...
10.17 – Provas V ou F
Elabore um programa que corrija provas contendo somente questões com respostas Verdadeiro ou Falso.
O programa deve armazenar as respostas corretas para cada questão e até 50 provas com até 20 questões.
Quando solicitado, o programa calcula e mostra as notas para cada aluno. Opcionalmente, o usuário pode
definir um fator de correção, de forma que para cada 2 ou 3 questões erradas, uma certa seja anulada.
Melhor implementar usando arquivos.
.
216
APÊNDICE A: PERGUNTAS FREQÜENTES
1) Compilei e executei o meu programa no Turbo Pascal e nada aconteceu. Ele não funciona?
Tecle Alt-F5 para ver a tela de saída.
2) Ao compilar, dá a mensagem “; expected”.
Está faltando um ponto-e-vírgula no final do comando anterior à posição do cursor.
3) Meu programa está em loop!
Tente teclar Ctrl-Break ou Ctrl-Break-Break para interromper sua execução.
4) Estou com um problema de compilação que não consigo solucionar.
Faça as práticas. Muitas delas foram feitas para lhe preparar para esses momentos.
5) O GotoXY não funcionou.
a) Você inverteu o X e o Y.
b) O X ou o Y estão fora da faixa válida de linhas e colunas (1 a 25 e 1 a
80, em modo texto normal).
6) Ao compilar recebo uma mensagem de que não é possível gravar o arquivo.
Se você está em uma rede, é possível que não tenha autorização para a gravação.
Configure em Options/Directories o diretório dos executáveis (.exe e .tpu) para o nome DOS da
sua pasta na rede ou uma pasta na qual você possa gravar.
7) Não estou conseguindo elaborar algoritmos.
A apostila apresenta várias ferramentas de pensamento para esses momentos, use-as.
Procure também digitar e seguir programas mais complexos, para alimentar seus neurônios. E
acima de tudo, não fique ansioso, se dê mais tempo.
(envie sua contribuição para este apêndice para virgilio@tba.com.br)
217
APÊNDICE B: PROCEDIMENTOS E FUNÇÕES DO TURBO

PASCAL*
Abaixo são listados os principais procedimentos e funções padrão da Linguagem Turbo Pascal, e suas
finalidades. Detalhes sobre a sintaxe, os parâmetros e uso destes procedimentos/funções podem ser encontrados no
help do sistema: digite o nome da instrução e tecle Ctrl-F1. As instruções assinaladas com um asterisco existem
somente no Turbo Pascal para DOS.
Aritméticas
Abs Func Retorna o valor absoluto do argumento.
ArcTan Func Retorna o arco tangente do argumento.
Cos Func Retorna o do argumento (argumento é um ângulo em radianos).
Exp Func Retorna o exponencial do argumento.
Frac Func Retorna a parte fracionária do argumento (argumento é real).
Int Func Retorna a parte inteira do argumento (argumento é real).
Ln Func Retorna o logaritmo natural do argumento.
Pi Func Retorna o valor da constante Pi.
Sin Func Retorna o seno do argumento (argumento é um ângulo em radianos).
Sqr Func Retorna o quadrado do argumento.
SqRt Func Retorna a raiz quadrada do argumento.
Conversão de Dados
Chr Func Retorna o caractere da tabela ASCII correspondente a um número especificado.
Ord Func Retorna o número de ordem na tabela ASCII de um caractere especificado.
Round Func Arredonda um número real para o inteiro mais próximo.
Trunc Func Retorna a parte inteiro de um número real.
Str Proc Converte um valor numérico em uma cadeia de caracteres.
Upcase Func Converte um caractere para a Maiúscula correspondente.
Val Proc Converte uma cadeira de caracteres em um valor numérico.
Manipulação da tela e teclado

ClrEol Proc Limpa os caracteres da posição do cursor até o fim da linha.
ClrScr Proc Limpa a tela e posiciona o cursor no canto superior esquerdo.
GotoXY Proc Posiciona o cursor na tela.
KeyPressed Func Retorna True se uma tecla for acionada ou False caso contrário.
ReadKey Func Lê um caractere de uma tecla acionada sem ecoá-lo na tela.
TextBackground Proc Define uma cor de fundo do texto.
TextColor Proc Define uma cor do texto.
WhereX Func Retorna a coluna em que o cursor se encontra.
WhereY Func Retorna a linha em que o cursor se encontra.
Window Proc Define uma janela de texto na tela.
Instruções aplicáveis a tipos de dados ordinais

Dec Proc Decrementa uma variável.
Inc Proc Incrementa uma variável.
Odd Func Testa se o argumento é impar.
Pred Func Retorna o predecessor do argumento.
Succ Func Retorna o sucessor do argumento.
Manipulação de cadeias de caracteres

Concat Func Concatena uma seqüência de cadeias.
Copy Func Retorna uma subcadeia de uma cadeia.
Delete Proc Exclui uma subcadeia de uma cadeia.
*
Cortesia do Prof. Vicente P. Teixeira.
FillChar Proc Preenche uma variável com uma quantidade indicada de um caractere ou byte.
Insert Proc Insere uma subcadeia em uma cadeia.
Length Func Retorna o tamanho dinâmico (quantidade de caracteres) de uma cadeia.
Pos Func Retorna a posição de uma subcadeia em uma cadeia.
Manipulação de Arquivos
Assign Proc Atribui um nome externo para uma variável do tipo file.
BlockRead Proc Lê um ou mais registro de um arquivo para uma variável.
BlockWrite Proc Escreve em um arquivo um ou mais registros a partir de uma variável.
ChDir Proc Muda o diretório corrente.
Close Proc Fecha um arquivo aberto.
Eof Func Retorna o status de fim de arquivo.
Erase Proc Elimina um arquivo.
FilePos Func Retorna a posição corrente do apontador de arquivo.
FileSize Func Retorna o tamanho (quantidade de registros) de um arquivo.
GetDir Proc Retorna o diretório corrente de um drive especificado.
IOResult Func Retorna o status da última operação de I/O efetuada.
MkDir Proc Cria um subdiretório.
Read Proc Lê o registro corrente de um arquivo para uma variável.
Rename Proc Renomeia um arquivo.
Reset Proc Abre um arquivo.
Rewrite Proc Cria e abre um arquivo.
RmDir Proc Remove um subdiretório vazio.
Seek Proc Move o apontador de um arquivo para uma posição especificada.
Truncate Proc Trunca o arquivo na posição corrente.
Write Proc Escreve o conteúdo de uma variável em um arquivo.
Controle de Fluxo de Execução

Exit Proc Sai do bloco de código em execução.
Halt Proc Encerra a execução do programa.
RunError Proc Encerra a execução do programa e gera um erro de tempo de execução.
Alocação dinâmica de memória

Dispose Proc Libera o espaço reservado para uma variável dinâmica.
FreeMem Proc Libera o espaço reservado para uma variável dinâmica de um dado tamanho.
GetMem Proc Cria uma variável dinâmica de um dado tamanho e põe seu endereço num
ponteiro.
MaxAvail Func Retorna o tamanho do maior bloco de memória contígua disponível.
MemAvail Func Retorna a quantidade total de memória disponível.
New Proc Cria uma variável dinâmica e põe seu endereço num ponteiro.
Diversas
Delay Func Faz o processador gastar uma quantidade de milissegundos especificada.
GetDate Proc Retorna a data corrente do Sistema Operacional.
GetTime Proc Retorna a hora corrente do Sistema Operacional
NoSound* Proc Desliga o alto-falante interno do processador.
Random Func Retorna um número aleatório entre 0 e o argumento..
Randomize Proc Inicializa o gerador interno com um número aleatório (obtido do relógio do
sistema).
Sound* Proc Liga o alto-falante interno com a freqüência (em Hz) passada como argumento.
219
APÊNDICE C: FERRAMENTAS DE PENSAMENTO
"Se você compreende verdadeiramente que existe um número infinito de

possibilidades em qualquer situação dada, você pode encontrar soluções onde
até agora era totalmente impossível encontrá-las."
Eva Pierrakos, em O Caminho da Autotransformação.
Quem está aprendendo normalmente não está propriamente na “zona de conforto”, e sim muito
perto de seus limites. E até que as novas habilidades se tornem naturais, espontâneas e fluentes, há uma
fase de transição, na qual pode haver momentos em que não se sabe precisamente o que é o melhor a
fazer. Dispor de boas alternativas para esses momentos pode acelerar o aprendizado, reduzir tempos e
mesmo tornar mais prazeroso o aprendizado. Este apêndice descreve algumas dessas alternativas, para
você usar quando for preciso ou simplesmente para fazer algo melhor.
Perguntar
"O olho dorme até que a mente o acorde com uma pergunta"
(Provérbio árabe)
Uma ferramenta muito poderosa para direcionar a mente é simplesmente elaborar perguntas a
respeito do assunto ou objetivo em questão. Por exemplo, por meio de perguntas podemos obrigar uma
pessoa a pensar no passado ou no futuro, mais genericamente ou mais especificamente. Note como posso
afetar o que você está pensando:
"O que você comeu hoje no café da manhã?"
"Qual foi a experiência mais agradável que você vivenciou?"
"Você se ama?" ou "Quanto você se ama, de 0 a 100"?
"Você gostou do último filme que assistiu?" ou "Qual parte do último filme que viu você mais
gostou?"
"Como você poderia melhorar seu rendimento escolar?"
"O que você realmente quer da vida neste momento?"
Perguntar é uma forma de manter a iniciativa. Se você enviar um e-mail e quiser uma resposta,
faça uma pergunta. Observe também como certos vendedores mantém o controle de uma conversa usando
esse recurso!
Como um reforço, compare a eficiência das perguntas a seguir:
“Será que vai dar certo?” ou “O que eu posso fazer para dar certo?”
“Será que eu consigo?” ou “Qual é o próximo pequeno passo que posso dar para conseguir?”
“Sou capaz?” ou “O que posso aprender para facilitar atingir meu objetivo?”
“Será que eu nunca aprendo?” ou “O que já aprendi que posso aplicar neste caso?”
Na falta de perguntas, use meta-perguntas (perguntas sobre perguntas):
“Qual é a melhor pergunta a ser feita agora?”
“O que eu poderia perguntar que me tornaria mais objetivo?”
“Que pergunta me conduziria a uma visão mais prática e realista?”
Aplicações – Antes de ler um livro, assistir uma aula ou iniciar uma sessão de estudos, pergunte:
o que quero com isto? Qual é o meu objetivo? Qual é a melhor atitude para aprender mais rapidamente?
O que eu já sei deste assunto? Qual é a melhor postura (física) para obter melhor rendimento?
Outros contextos de aplicação de perguntas: ao namorar, ao descansar, ao trabalhar em equipe.

Que tal perguntar “Como posso obter ainda mais prazer ao...?” Divirta-se!
Faça algo diferente
"Temos notado este traço peculiar aos seres humanos. Se estes descobrem alguma coisa que
fazem e que não funciona, eles a repetem. Skinner tinha um grupo de alunos que havia realizado diversas
pesquisas com ratos e labirintos. E alguém, um dia, perguntou-lhes: "qual é realmente a diferença entre
um rato e um ser humano?" Bom, os comportamentistas, uma vez que não eram pessoas terrivelmente
observadoras, decidiram que precisavam experimentar para descobrir. Construíram um labirinto
enorme em escala adequada para um humano. Pegaram um grupo controle de ratos e ensinaram-no a
percorrer um labirinto pequeno atrás de queijo. Depois pegaram pessoas e ensinaram-nas a percorrer o
labirinto grande atrás de notas de cinco dólares. Houve pequenas variações nos dados e – ao nível de
probabilidade de 95% - descobriram algumas diferenças significativas no número de tentativas ao
critério ou algo parecido. Os humanos conseguiram aprender a percorrer o labirinto um pouco melhor,
um pouquinho mais depressa do que os ratos.
As estatísticas realmente interessantes aconteceram quando foram efetuar a parte da extinção.

Removeram as notas de cinco dólares e o queijo e depois de um certo número de tentativas os ratos
pararam de correr pelo labirinto... Os humanos contudo não pararam!.. .Ainda estão lá!... De noite, eles
invadem o laboratório."
(Richard Bandler & John Grinder, "Sapos em príncipes", pág. 27)
Em situações de impasse ou um problema aparentemente insolúvel, com um "branco" imenso na

mente, o que fazer? As pessoas que são bons resolvedores de problemas em computadores nem sempre
são as mais inteligentes ou criativas; o que eles fazem normalmente é agir algo diferente, qualquer coisa,
para ver se descobrem uma pista ou informação que os faça avançar qualquer milímetro. E se o que
tentaram não deu em nada (o que é comum), novamente buscam algo diferente.
Quando aplicada à programação, essa alternativa pode significar:

• Buscar uma informação diferente
• Imaginar, acreditar que pode ser diferente.
• Fazer uma pergunta diferente
• Buscar um algoritmo diferente
• Usar uma instrução diferente
• Consultar uma ajuda diferente
APÊNDICE C: FERRAMENTAS DE PENSAMENTO 221
• Achar as diferenças entre o esperado e o obtido

• Recorrer a uma pessoa diferente
• Aplicar um método diferente
De fato, já fazemos isto com freqüência: ao torcer um parafuso, por exemplo, se algo que
fazemos não funciona, fazemos algo diferente: uma chave de fenda maior ou menor, mais força, outra
posição da mão, as duas mãos, algo para colocar no parafuso e diminuir o atrito. Ao dirigir automóveis,
fazemos ajustes todo o tempo no volante (e nem notamos).
Que tal fazer algo que você nunca vez antes?
A abordagem blitz
“O ser humano é muito melhor aperfeiçoando algo existente do que criando algo do nada”
Paul T. Ward
Da descrição teórica para a execução prática várias coisas podem mudar. O processo de
desenvolver um programa ou algoritmo não é, na grande maioria das vezes, uma linha reta, em que se
passa de uma etapa à outra em seqüência. Isso não ocorre devido somente a limitações do programador,
mas basicamente a causa principal é a falta de informações; nas fases iniciais normalmente não se dispõe
de todas as informações necessárias para elaborar um produto completo. E quanto menos informações,
maior a possibilidade de serem tomadas decisões que depois se revelam inadequadas. Por exemplo,
descobrir que o programa está estruturado incorretamente na etapa de teste normalmente impacta
significativamente o prazo previsto de implementação. O mesmo ocorre quando, já no final da
codificação, se percebe que falta uma solução importante para um aspecto importante ou algoritmo.
Imagine se isso ocorrer na véspera da entrega de um trabalho! Por isso, tão importante quanto uma boa
descrição das etapas a serem seguidas, é dispor de um bom roteiro para executá-las.
Em procedimentos ou atividades executadas em etapas, você pode aplicar a abordagem blitz. Ela
consiste em se fazer uma rápida passagem inicial pelas várias etapas, na qual o objetivo maior é obter
uma visão geral e preliminar, incompleta e não totalmente verificada da questão ou problema. Após, você
faz uma segunda passagem, desta vez em direção ao produto final. Benefícios desta abordagem:
• Com uma visão do todo, você identifica mais facilmente as partes cujos detalhes vão requerer
maior atenção
• Você tem melhor noção das conseqüências que suas decisões numa etapa vão provocar em
etapas posteriores
• Você não perde tempo tentando fazer um produto final desde o início, sendo que talvez não
tenha todas as informações necessárias para isso.
Você não precisa se limitar a duas passagens; de fato você pode fazer quantas forem necessárias.
Uma situação curiosa pode surgir, se em algum momento você perceber que o desenvolvimento não está
avançando: você pode tanto voltar a uma etapa anterior quanto avançar a uma etapa posterior, para obter
informações e amadurecer o seu produto. Por exemplo: ao produzir a primeira ou segunda versão do
algoritmo ou programa, passe logo para a verificação manual.
Para atingir objetivos nem todos os passos precisam ser "corretos".

Você mesmo – inspiração para algoritmos
Uma das melhores fontes de inspiração para elaborar certos algoritmos é seu próprio cérebro:
como você faria? Talvez isso não tenha lhe ocorrido, mas seu cérebro tem algoritmos. Normalmente não
estamos conscientes deles, e nem precisamos, mas muitas vezes podemos ter algum acesso. Por exemplo,
soletre uma palavra qualquer, digamos, "IMAGEM", enquanto procura observar como faz. Em geral o
algoritmo usado para isso é:
"Produza uma imagem interna da palavra"
"Focalize a primeira letra da palavra"
enquanto "não for o fim da palavra"
"pronuncie a letra focalizada"
"Focalize próxima letra"
fim
Se não conseguir perceber, peça a alguém para soletrar uma palavra e observe seus olhos.
Por exemplo, suponha que você deve elaborar um algoritmo para ordenar um conjunto de
números em ordem crescente. Você pode pegar alguns palitos de tamanho variado, ordená-los enquanto
observa o que faz e daí extrair pistas para o algoritmo. Pode ser que você percorra todos os palitos à
procura do maior e tire-o do conjunto para um outro. Para os que sobraram, repete o procedimento, até
que não haja mais palitos. Essas ações são pistas excelentes para a elaboração do algoritmo.
Considere agora o problema de inverter uma cadeia de caracteres. Por exemplo, dada a cadeia “A
mente é terra”, torná-la “arret é etnem A”. Pegue uma cadeia qualquer e inverta manualmente. Como
você fez? Provavelmente, seguiu os seguintes passos:
"Escolha um local para escrever a cadeia invertida"
"Focalize o último caractere da cadeia"
"Escreva o caractere"
enquanto "houver caracteres não copiados"
"Focalize na cadeia o próximo caractere à esquerda"
"Escreva o caractere focalizado à direita do último escrito"
fim
O algoritmo acima já permite obter algumas pistas: uma variável inteira para apontar cada
caractere da cadeia, uma instrução para obter um caractere apontado, outra para concatenar caracteres (no
Pascal, o +), as instruções que serão repetidas.
Note que pesquisar no próprio cérebro nem sempre irá fornecer o algoritmo com precisão; o que
buscamos são pontos de partida para idéias que serão adaptadas às nossas necessidades.
223
APÊNDICE D: TABELA ASCII
Na tabela estão representados os códigos dos caracteres mais usados (de 32 a 126). Para calcular
cada código, some o número da coluna do caractere com o número da respectiva linha. Por exemplo, o
código da letra T é 80 + 4.
TABELA ASCII (de 32 a 126)
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
32 ! " # $ % & ' ( ) * + , - . /
48 0 1 2 3 4 5 6 7 8 9 : ; < = > ?
64 @ A B C D E F G H I J K L M N O
80 P Q R S T U V W X Y Z [ \ ] ^ _
96 ` a b c d e f g h i j k l m n o
112 p q r s t u v w x y z { | } ~
224
BIBLIOGRAFIA
FARRER, Harry et al. Algoritmos Estruturados. Guanabara-Koogan, 1989.
_________________ Pascal Estruturado. Guanabara-Koogan, 1995.
FORBELLONE, André Luiz V. & EBERSPÄCHER, Henri F. Lógica de Programação. Makron, 1993.
GUIMARÃES, Ângelo M. & LAGES, Newton A. C. Algoritmos e Estruturas de Dados. LTC, 1985.
McMENAMIN, Stephen M. & PALMER, John F. Análise Essencial de Sistemas. Makron, 1991.
MECLER, Ian & Maia, Luiz Paulo. Programação e Lógica com Turbo Pascal. Campus, 1989.
MYERS, Glenford J. The Art of Software Testing. John Wiley & Sons, 1979.
O’BRIEN, Stephen. Turbo Pascal 6.0 Completo e Total. Makron, 1992.
SCHEID, Francis. Computadores e Programação. McGraw-Hill, 1984.
SCHMITZ, Eber Assis & TELES, Antonio A. S. Pascal e Técnicas de Programação. LTC, 1986.
WEISKAMP, Keith. Turbo Pascal 6.0. LTC, 1992.
WIRTH, Niklaus. Programação Sistemática em Pascal. Campus, 1987.

225
ÍNDICE REMISSIVO
A características...................154 com menu...........................36

.1.3.Algoritmo........................25 declaradas.........................165 como recuperar...................57
exemplo de elaboração.....142 matemáticas........................78 estrutura..............................37
representação......................26 G execução no Turbo Pascal. .59
Array.....................................186 GotoXY..................................74 o que é...................................6
Atribuição...............................86 I projeto.................................34
B If 111 tipos....................................35
Blitz, abordagem...................221 Implementation.....................174 Programa-fonte.......................58
Byte.........................................89 Impressão.................................... compilação..........................58
C com Write...........................77 visão geral...........................44
Case......................................118 da tela de saída....................84 Programação...............................
Char............................................ programa-fonte...................54 estratégia geral....................30
na memória.........................96 In, operador...........................114 etapas..................................31
operações............................95 Inc.........................................109 fatores de sucesso...............13
Chr........................................105 Indentação.............................115 R
Comentários............................62 Instruções.................................... Random...................................80
Compilação.............................10 tipos..................................154 Randomize..............................80
ajuda para erros...................61 Interface................................174 ReadKey.....................................
para disco............................61 L como função.......................96
Compilador.............................10 Linguagem.................................. Readln...............................86, 87
Const.......................................82 alto nível...............................8 ReadXY................................177
constantes................................... de máquina............................7 Registros...............................197
tipadas...............................196 orientação...........................11 .7.2.Repeat............................132
Constantes................................... Pascal..................................11 explicação.........................133
declaração...........................81 tipos de instruções................9 Repetição....................................
Copy.......................................97 M perguntas...........................140
CPF.......................................183 Matemática.............................70 problemas.........................138
D Matrizes................................200 Robô...........................................
.4.3.Debugger.........................68 MS-DOS..................................... elaborando algoritmos........21
janela Watches....................86 comandos básicos...............57 história................................16
Decisões...................................... N S
reconhecendo....................121 NoSound.................................76 Sintaxe................................8, 60
Delay.......................................76 Números aleatórios.................80 cores do editor....................61
Dicas........................................... O Software......................................
decisão..............................121 Operações...............................34 que você precisa.................12
E Operadores.................................. Sound......................................76
Erros........................................... aritméticos........................111 Str.........................................128
tipos....................................45 MOD...................................71 String..........................................
Especificação..........................31 P concatenação.......................97
Expressão lógica...................111 Parâmetro.................................... obtendo um caractere..........97
Expressões.................................. por referência....................161 operações............................97
aritméticas...........................69 Parâmetros............................154 tamanho atual......................97
Expressões lógicas...................... resumo..............................164 T
compostas.........................114 Perguntas..............................219 Tabela ASCII..................96, 223
F PIS/PASEP...........................183 .2.6.Teste................................45
Ferramentas de pensamento....... Pos, função...........................126 definição.............................46
faça diferente....................220 Precedência de operadores.....71 diretrizes.............................47
perguntas...........................219 Procedimento.............................. TextColor................................76
você e seu cérebro............222 características...................154 .5.2.Tipos de dado..................88
FillChar...................................95 declaração.........................155 declarando novos..............104
.7.3.For..................................134 detalhes.............................160 do Turbo Pascal..................88
explicação.........................135 roteiro para declaração.....169 .3.1.Turbo Pascal....................51
quando usar.......................136 Programa.....................................
.4.6.Funções............................77
ajuda...................................55 estrutura............................174 algoritmos.........................191

DOS shell............................56 inicialização......................176 operações..........................187
editor...................................52 Upcase....................................95 W
executando..........................52 Uses........................................73 .7.1.While.............................129
instalação............................51 V explicação.........................130
Type......................................104 Val........................................127 With......................................198
para registros....................198 Variáveis...........................26, 86 Write.......................................62
para vetores.......................186 descobrindo.........................99 parâmetros..........................66
U Vetor........................................... Posição do cursor................62
.8.8.Units..............................174 declaração.........................186 Writeln....................................58
elemento...........................185
.9.1.Vetores...........................185

Apostila Prof Virgilio Vilela

Загружено:

Сведения о документе

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Apostila Prof Virgilio Vilela

Загружено:

Авторское право:

Доступные форматы

APRENDENDO

"E na próxima pedra, o cortador pode pegar uma ferramenta mais

Princípio da Retribuição Espontânea

Creditado: Virgilio Vasconcelos Vilela

Princípio da Retribuição Espontânea..............................................................................................................................1

Um bom profissional de informática tipicamente é alguém com disposição para buscar

Bons profissionais de informática também sabem que somente dedicação e prática

Pressupõe-se que o estudante está familiarizado com os conceitos iniciais de

Engenheiro Eletricista e Mestre em Ciência da Computação pela UFMG. Analista de

Virgílio Vasconcelos Vilela

Home page: virgiliovv.cjb.net.

Para um melhor aproveitamento da sua dedicação, siga as seguintes orientações:

• Os capítulos consistem de atividades dos seguintes tipos: práticas (a maioria)

• Ao final de cada capítulo há uma seção de atividades suplementares. Após fazer

• Antes de começar, dê uma boa olhada na apresentação, no sumário, no índice

Fique atento aos textos neste formato: dicas, alertas e informações

.0.1. Programas e programação

O hardware do computador, constituído de placas e dispositivos mecânicos e eletrônicos, precisa

Programas são constituídos de instruções e comandos que o processador do computador entende:

Para que algo aconteça no computador, não basta um programa; os comandos

Programar um computador é, portanto, produzir comandos agrupados em programas, em uma

.0.2. Conhecendo os programas

Prática 0.1 – Brincando

.0.3. A linguagem do computador

A atividade básica de um computador consiste em executar instruções, através de um

A memória RAM, ou simplesmente memória, de um computador é constituída de uma seqüência

Os números armazenados na memória podem representar dados ou instruções. Quando

.0.4. Linguagens de alto nível

Escrever programas de computador em linguagem de máquina, apesar de os programas

.0.4.1 Tipos de instruções de alto nível

Um televisor possui vários recursos: a tela, o alto-falante, o controle remoto, opções de

Exercício 0.2 - Revisão

Exercício 0.3 – Vantagens e desvantagens

Exercício 0.4 – Categorias de instruções

.0.5. Conversão do programa-fonte

Quando o programa-fonte é todo convertido em linguagem de máquina antes da execução, esse

Quando a conversão é feita durante a execução, o processo é chamado de interpretação, e o

.0.6. Orientação das linguagens de alto nível

.0.7. Linguagem Pascal

Exercício 0.5 - Revisão

.0.8. Software que você precisa ter ou conhecer

Alguns programas são necessários às atividades de um programador:

.0.9. Fatores de sucesso

Atitude - O direcionamento interior que você assumir (suas

"A inteligência não substitui a falta de informação"

Exercício 0.6 – Planejando o dia

.0.10. Para você que está começando

Vou resumir em algumas frases minha opinião:

.0.11. Atividades suplementares

Exercício 0.7 - Revisão

Entrevista 0.8 – Experiência de outros

.1.1. Meu Primeiro Robô

O robô continua em silêncio. Aí você se lembra de como deve começar:

REPITA REPITA N VEZES

“Mas parece fácil”, você pensa, e então testa o robô:

ALGORITMO Guarde todos os lego.

ALGORITMO Guarde todos os lego.

Exercício 1.1 – Outras utilidades do robô

Exercício 1.2 - Chateando

Exercício 1.3 – Decisões cotidianas

Exercício 1.4 – Fale comigo

.1.2. Brincando de robô

Aproveitando as idéias da história, vamos explorar um pouco as possibilidades de um robô. Nos

Vire(X graus), onde graus positivos referem-se ao sentido horário.