UFS - Apostila - Programação 1 - Pascal

Prévia do material em texto

Universidade Federal de Sergipe – Campus Alberto Carvalho
Núcleo de Sistemas de Informação
Professora: Mai-Ly Vanessa A. S. Faro
Índice
1. Introdução.........................................................................................................................................3
2 – Algoritmo........................................................................................................................................3
2.1 – Conceito de Algoritmo............................................................................................................3
2.2 – Algoritmo X Programa............................................................................................................5
2.3 – Trinômio Entrada-Processamento-Saída.................................................................................6
2.4 – Estrutura Básica de um Algoritmo..........................................................................................6
3 – Pseudo-Linguagem Usada..............................................................................................................7
3.1 – Instrução de Saída...................................................................................................................7
3.2 – Variáveis..................................................................................................................................7
3.3 – Operador de Atribuição...........................................................................................................9
3.4 – Operadores Aritméticos..........................................................................................................9
3.5 - Instrução de Leitura...............................................................................................................10
3.6 – Algumas Funções Matemáticas Pré-Definidas.....................................................................10
3.2 - Conceito de troca de conteúdo de variáveis..........................................................................12
3.3 – Como Rastrear um Algoritmo...............................................................................................12
3.4 – Estruturas de Decisão............................................................................................................13
3.4.1 – Operadores Relacionais.................................................................................................13
3.4.2 – Condicional Simples.....................................................................................................13
3.4.3 – Condicional Composto..................................................................................................15
3.4.4 – Estruturas Condicionais Aninhadas..............................................................................16
...................................................................................................................................................17
3.4.5 – Operadores Lógicos......................................................................................................17
1. Introdução
Em primeiro lugar é necessário que o aluno compreenda o que vem a ser um programa. Em 
uma linguagem mais técnica nós chamaríamos o objeto de nosso estudo de software. Como vocês 
descobrirão mais adiante no curso existem softwares de vários níveis. 
Um computador, para ser uma ferramenta de alguma utilidade, é basicamente composto de 
hardware e software. Certa vez eu ouvi de alguém uma definição no mínimo curiosa da diferença 
entre hardware e software: “Quando estamos em frente ao computador e nada funciona hardware é 
a parte que você chuta e software é a parte que você xinga!!”.  Em uma linguagem mais 
adequada à um escrito acadêmico poderíamos dizer que o hardware é palpável: são os circuitos, os 
fios, as placas, os periféricos, é o equipamento físico. O software é a parte lógica, é aquilo que 
instrui o hardware como funcionar, ou seja, são programas como editor de texto, planilhas, jogos, 
browser ou mesmo o próprio sistema operacional. Sem o software o hardware não seria útil para 
nada além de algumas funções tipo peso de papel, prendedor de porta ou algo assim. É o software 
que faz com que o hardware funcione de forma a executar todas as tarefas que vemos diariamente 
sendo feitas por computadores em suas mais variadas formas.
2 – Algoritmo
2.1 – Conceito de Algoritmo
O primeiro assunto que estudaremos em Programação 1 será construção de algoritmos. Mas, 
o que será um algoritmo? Vejamos a definição de alguns conceituados autores sobre o que vem a ser 
um algoritmo:
• Marcos Vianna Villas: “Algoritmo é a descrição de um procedimento finito, passo a passo de 
forma perfeitamente definida”.
• Tremblay: “Um algoritmo pode ser definido como uma seqüência ordenada e sem 
ambigüidades de passos que levam a solução de um dado problema”.
• Farrer: “Algoritmo é a descrição de um conjunto de comandos que obedecidos resultam 
numa sucessão finita de ações”.
Apesar de a primeira vista serem diferentes, todas as definições acima são perfeitamente 
verdadeiras. Na verdade eu diria até que elas se completam. Podemos salientar alguns pontos sobre 
algoritmos:
- É a descrição de um conjunto de passos (Vemos isto em todas as definições); 
- Os passos seguem uma seqüência ordenada (Então eles não podem ser feitos em qualquer 
sequência);
- É finito (Não vai continuar executando eternamente, deve haver um ponto de parada e 
este deve ser bem, definido);
- Sem ambigüidade (Este ponto é crucial, os passos devem ser perfeitamente definidos para 
que não se chegue a um ponto onde não se saiba qual passo executar);
- Esses passos resultam na solução de algum problema (O objetivo de seguir os passos é 
chegar a um determinado fim).
Desta forma, uma receita de bolo poderia ser considerada um algoritmo?
Pense antes de responder 
.
.
.
Sim! Seguiremos os passos da receita, esses passos devem ser seguidos na ordem (vá tentar 
desenformar antes de levar ao forno para ver no que vai dar!) a receita é finita (ufa! Ainda bem,... 
senão morreríamos de inanição) e o objetivo final é o bolo prontinho (e gostoso de preferência). 
Quanto a ausência de ambigüidade, vai depender da fluência de quem escreveu a receita.
Vejamos os seguintes exemplos da vida cotidiana. Numere as colunas de acordo com a 
ordem em que aconteceriam:
• ( )assinar boleto do cartão de crédito
• ( )sair do restaurante
• ( )comer
• ( )entregar cartão de crédito
• ( )pedir a conta
• ( )pedir a refeição
• ( )entrar no restaurante
Na seqüência acima, de acordo com o bom senso há somente uma seqüência que seria 
considerada a correta. Entretanto vejamos o seguinte exemplo:
• ( )comprar carpete
• ( )fazer medição
• ( )calcular o custo
• ( )calcular metragem necessária
• ( )verificar o preço do metro quadrado
Acima também temos uma seqüência de passos, entretanto o que deveria ser feito primeiro? 
A medição da área ou a verificação do valor do metro quadrado do carpete? 
...
Depende. 
...
De quê? 
...
De fatores externos que não foram colocados no problema, a situação financeira de quem vai 
comprar o carpete, a disponibilidade da fita métrica, se a pessoa se encontra mais perto da loja ou da 
área a ser coberta, vários fatores podem influenciar esta decisão.
Neste ponto temos uma ambigüidade, com as informações que temos ambas as respostas 
seriam consideradas corretas. Isso não pode haver em um algoritmo. É uma falha, ele deve ser 
perfeitamente definido de forma que não seja deixado espaço para ambigüidades.
Vejamos mais um exemplo.
Escreva uma receita de como preparar um hambúrguer:
Resposta:
Quantos passos você colocou em sua receita? Quantos passos seu colega colocou na 
preparação do hambúrguer dele? Em uma turma de 50 pessoas a variação do nível de detalhamentocom que cada um escreverá sua receita será enorme. Já vi receitas de hambúrguer com 23 passos e 
receitas com 4 passos.
2.2 – Algoritmo X Programa
Qual a diferença entre um algoritmo e um programa? Um algoritmo é escrito ou 
representado em uma pseudo-linguagem ou mesmo de forma gráfica. Na verdade o algoritmo como 
o iremos ver nesta disciplina será usado como uma ferramenta para o ensino de programação. Um 
programa é nada mais que um algoritmo codificado em alguma linguagem de programação.
2.3 – Trinômio Entrada-Processamento-Saída
Sempre que formos pensar na solução de um problema computacional há 3 características do 
problema que devem estar claros em nossa mente: as entradas necessárias, o processamento a ser 
executado e as saídas que devem ser providas. Entrada é como são chamados todos os dados que 
são lidos pelo computador por qualquer dispositivo de entrada. Saída é como são chamadas todas as 
informações exibidas pelo computador ou mesmo ações executadas por este.
Mas o que são dispositivos de Entrada/Saída? São dispositivos de entrada todos aqueles que 
servem para entrar dados no computador. Seriam exemplos destes: teclado, mouse, scanner, web-
cam, uma tela sensível ao toque, até mesmo um disquete ou uma placa de vídeo poderiam ser 
considerados dispositivos de entrada. São dispositivos de saída todos aqueles dispositivos que 
servem para informar resultados obtidos no processamento, ou mesmo dispositivos que tem seu 
comportamento controlado pelo computador. São exemplos destes: monitor de vídeo, impressora, 
ploter, um robô controlado pela máquina, uma disquete ou placa de rede poderiam ser considerados 
dispositivos de saída na medida em que eles realizam a saída de dados do computador.
Nesta disciplina iremos utilizar como dispositivos de entrada padrão o teclado e como 
dispositivo de saída padrão o monitor de vídeo.
2.4 – Estrutura Básica de um Algoritmo
programa nome_do_programa
var
 lista_de_variáveis : tipo
inicio
 <seqüência de comandos>
fim_prog.
Entrada
Processamento
Saída
3 – Pseudo-Linguagem Usada
Nesta etapa inicial do nosso curso, iremos usar uma forma de Português Estruturado que 
será definida em sala de aula. Posteriormente faremos a migração para a linguagem Pascal. É 
interessante observar que português estruturado é uma denominação genérica para um conjunto de 
linguagens de descrição de algoritmos baseadas em português. Cada livro ou mesmo professor irá 
possuir particularidades na estrutura do português estruturado que usa, sem contanto significar que 
um seja melhor ou pior que o outro.
3.1 – Instrução de Saída
A instrução que fará com que uma mensagem seja exibida no dispositivo de saída padrão, 
que no nosso caso é o teclado, é a instrução escreva
Sintaxe: 
escreva(‘mensagem’)
escreva(variável)
escreva(mensagem, variável, mensagem)
Ex: 
escreva(‘Olá mundo!’)
escreva(‘Média =’,32)
Exercícios...
3.2 – Variáveis
Dados em processamento são guardados provisoriamente em determinada posição da 
memória principal do computador que por questões históricas é chamada memória RAM (do inglês 
Randon Access Memory). A memória RAM é dividida em bytes que são endereçados 
sequencialmente. Quando um programa lê um dado, este dado tem que ser provisoriamente 
guardado em algum local de forma que ele possa ser chamado facilmente quando necessário. 
Trazendo esta discussão para o mundo que conhecemos, vejamos um exemplo prático de 
como usaríamos um grande gaveteiro de 200 gavetas dispostas em 10 filas de 20 gavetas cada uma. 
Faz de conta que por algum motivo você tem um “elefante” deste no seu quarto. Um belo dia você 
guardou em uma das gavetas seu comprovante de matrícula da faculdade. No dia seguinte, fora de 
casa, você precisa de alguma informação deste comprovante e telefona para sua mãe ler a 
informação pelo telefone. Como ela vai achar o comprovante? Você vai dizer a ela que é uma 
gaveta que fica mais ou menos na altura do seu ombro, mais ou menos perto da linha que a janela 
faz sombra no cabideiro às 3h da tarde, ou algo assim? Não ficaria bem mais fácil se você tivesse 
colocado uma etiqueta na frente da gaveta e dissesse que bastava ela procurar na gaveta com uma 
etiqueta “Documentos da faculdade” colada na frente? Este mesmo raciocínio pode ser usado com 
relação á variáveis. 
Iremos considerar a memória do computador como sendo o gaveteiro, a variável será como a 
gaveta em que colocamos uma etiqueta. Ao armazenar um dado na memória, você vai atribuir um 
nome a esta posição de memória de forma que fique fácil encontrar pelo nome o que foi 
armazenado neste lugar. 
Tipos de variáveis
Ao reservarmos espaço para guardar um dado na memória temos que nos preocupar com 
qual será o tipo de informação que será guardada, pois dependendo do tipo de informação iremos 
precisar de mais ou menos espaço. Este é um dos motivos para definirmos de que tipo será a 
variável no momento em que a criarmos, pois de acordo com o tipo declarado para a variável o 
computador saberá quanto de memória tem que reservar para guardar esta informação. Outro 
motivo para a definição de um tipo de variável é a questão de verificação de erros do programa, 
como veremos adiante.
Em nossa linguagem algorítmica iremos trabalhar com os seguintes tipos de variáveis:
inteiro – para guardar números inteiros, ou seja que não serão fracionários, como por exemplo 
número de filhos, quantidade de carros entre outros.
real – para guardar números fracionários como números relativos a dinheiro ou o resultado de 
divisões (mesmo de divisões de números inteiros).
string – para guardar informações alfa-numéricas como letras, palavras ou frases.
lógico – para armazenar uma informação que só contém um de dois valores: verdadeiro ou falso.
Nomeclatura de variáveis
Tanto o nome da variável quanto o nome do programa tem que seguir algumas regras para 
ser considerado um nome válido:
- O primeiro dígito tem que ser uma letra;
- A partir do segundo dígito podemos ter letras, números ou _ (sublinha);
- Não pode haver espaço em branco;
- Não pode ser palavra reservada da linguagem;
- Não pode haver símbolos no nome da variável.
Ex:
Num32 Válido Inicio Inválido 
5aluno Inválido prog Inválido
media aritmética Inválido total Válido
media_aritmetica Válido S432323_43 Válido
Declaração de variáveis
Toda variável antes de ser usada tem que ser obrigatoriamente declarada. É na declaração da 
variável que a máquina irá reservar espaço de memória para guardar o conteúdo desta variável, logo 
não há como atribuir um valor a uma variável sem que antes tenha sido reservado espaço na 
memória para armazenar o conteúdo da mesma. Em nossa linguagem algorítmica todas as variáveis 
devem ser declaradas no início do código do programa depois da palavra var. A declaração será uma 
lista onde irá constar o nome das variáveis e seu tipo.
Ex:
var
 nome, cidade : string
 numero, valor : inteiro
 salário, preço : real
 
3.3 – Operador de Atribuição
Uma das formas de colocarmos um valor dentro de uma variável é através de atribuição. A 
atribuição é feita usando-se um operador chamado operador de atribuição, representado em nossa 
linguagem algorítmica pelo símbolo -> . Este símbolo significa que a variável à esquerda do 
operador recebe o resultado da operação situada à direita do operador seja esta uma operação 
matemática, um valor exibido explicitamente ou mesmo o conteúdo de uma outra variável.
Num <- 10 + valor
Lê-se: num recebe 10 mais valor
3.4 – Operadores Aritméticos
+ Adição
- Subtração
* Multiplicação
/ Divisão
Serão usados os mesmos operadores aritméticos usados na matemática, observando-se as 
leis de precedência de operadores usadas na matemática também.Obs: Para o computador todo resultado de uma divisão é real, não importando se os operandos 
envolvidos na divisão são inteiros ou reais.
3.5 - Instrução de Leitura
A instrução que será usada em nosso português estruturado para ler dados de nossa entrada 
de dados padrão, no caso o teclado, é o leia.
Sintaxe:
leia (num)
A instrução acima significa que ao se dar <enter> o valor que foi digitado no teclado será 
guardado na variável chamada num (que já tem que ter sido previamente declarada). 
3.6 – Algumas Funções Matemáticas Pré-Definidas
⇒ trunca
Recebe como argumento um número real e retorna o número truncado.
Ex: num <- trunca(valor)
⇒ arrendonda
Recebe como argumento um número real e retorna o número arredondado.
Ex: num <- arredonda(valor)
⇒ quadrado
Recebe como argumento um número real ou inteiro e retorna o quadrado deste número como sendo 
um elemento do respectivo tipo.
Ex: num <- quadrado(valor)
⇒ raiz
Recebe como argumento um número real ou inteiro e retorna a raiz quadrada deste número.
Ex: num <- raiz(valor)
⇒ seno
Recebe como argumento um número real que representa um ângulo em radianos, e retorna o seno 
do ângulo.
Ex: num <- seno(valor)
⇒ cosseno
Recebe como argumento um número real que representa um ângulo em radianos, e retorna o 
cosseno do ângulo.
Ex: num <- cosseno(valor)
⇒ Obs: Conversão de graus para radianos
É interessante observar que as funções seno e cosseno trabalham com ângulos em radianos, 
entretanto no Brasil estamos acostumados a trabalhar com ângulos em graus. É importante lembrar 
de realizar a conversão dos ângulos de graus para radianos antes de usa-los nas fórmulas.
Sabendo que um radiano equivale a 180 graus usando uma simples regra de 3 podemos 
chegar a seguinte fórmula de conversão:
Obs: Praticamente todas as linguagens possuem uma constante pré-definida chamada PI que contém 
o valor de ∏.
⇒ log
Recebe como argumento um número real ou inteiro e retorna o logaritmo deste número na base 10. 
Caso necessitemos calcular logaritmos em outras bases basta efetuar uma operação de mudança de 
base e poderemos usar esta mesma função.
Ex: num <- log(valor)
Obs: Fazendo mudança de base de logaritmo
Se quisermos calcular o logaritmo de um número a em uma base b ...
... e soubermos o valor do logaritmos de a em uma base x qualquer e soubermos também o valor do 
logaritmo de b na mesma base x, podemos usar uma propriedade dos logaritmos que nos garante 
que ...
... ou seja, logaritmo de a em uma base b é igual ao logaritmo de a em uma base x dividido pelo 
logaritmo de b na mesma base.
Ex: Calcule o logaritmo de 8 na base 2
 Resultado = log(8) / log(2).
⇒ Operador resto
Na verdade resto não é uma função, é um operador binário que trabalha com dois operandos de tipo 
inteiro. É estudado aqui somente por uma questão de conveniência. O operador resto retorna o resto 
da divisão entre dois números inteiros.
Ex: num <- 10 resto 3 {num vai receber 1}
3.2 - Conceito de troca de conteúdo de variáveis
Considere o seguinte exercício: Leia 2 números inteiros em variáveis chamadas A e B 
respectivamente. Troque o conteúdo de ambas e exiba seus conteúdos trocados.
Se fizermos: 
A<- B
B<- A
Teremos que ao final ambas as variáveis estarão com o conteúdo de B.
Como deveria ser feita esta troca? Pense em 2 copos cheios de café e leite. Como você faria 
para trocar seus conteúdos?
.
.
Você teria que usar um copo auxiliar!! O mesmo raciocínio será aplicado aqui. Teremos que 
ter uma variável auxiliar para poder realizar a troca com eficiência! O algoritmo ficará:
aux <- A
A<- B
B <- aux
Agora sim, teremos o conteúdo das variáveis trocado!!
3.3 – Como Rastrear um Algoritmo
Rastrear significa acompanharmos a execução do algoritmo, isto também é conhecido como 
acompanhar no chinês. Para rastrear devemos construir uma tabela contendo uma coluna para cada 
variável declarada e ir anotando os diversos conteúdos atribuídos às variáveis ao longo do tempo, 
bem como as saídas exibidas em tela. Para preencher a tabela devem ser considerados valores 
hipotéticos de entrada.
Ex: Vejamos o seguinte algoritmo:
programa exemplo
var
n1, n2: inteiro
media: real
inicio
escreva (‘Digite dois números inteiros’)
leia (n1, n2)
media <- (n1 + n2)/2
n1 <- n2*3
escreva (‘Media =’ ,media, ‘Primeiro numero ficou:’ ,n1)
fim_prog.
Seu rastro ficaria:
VH: n1 = 5, n2 = 2
n1 n2 media Saídas
5 2
3.5
6
Media = 3.5 Primeiro numero ficou: 6
3.4 – Estruturas de Decisão
São basicamente estruturas de divisão. Até este momento o código do algoritmo era 
“executado” seguindo-se o fluxo de escrita das instruções. Começava-se a execução na primeira 
linha e terminava-se na última. 
A partir de agora iremos ter uma estrutura que irá fazer com que parte do código seja ou não 
executada, ou mesmo iremos decidir entre executar uma parte ou outra do código.
Para utilizarmos estas estruturas iremos dar subsídios para o computador tomar decisões 
com base em comparações feitas utilizando-se operadores relacionais. Vejamos os possíveis 
operadores relacionais da nossa linguagem algorítmica:
3.4.1 – Operadores Relacionais
Operador Exemplo
< Menor que A < B
> Maior que A > B
<= Menor ou igual a A <= B
>= Maior ou igual a A >= B
= Igual a A = B
<> Diferente A <> B
3.4.2 – Condicional Simples
Esta estrutura condicional fará com que determinado bloco de código, delimitado pelas 
palavras reservadas begin e end, seja ou não executado de acordo com o resultado da avaliação 
lógica de determinado teste.
Vejamos como isto acontece na figura a seguir:
Caso o resultado da avaliação da expressão lógica seja verdadeiro o bloco de instruções do 
condicional será executado, caso o resultado do teste seja falso o bloco de instruções não será 
executado e o restante do algoritmo continuará sendo executado normalmente.
SINTAXE:
se (teste) então
 inicio
 {Bloco de instruções} 
 Fim
EXEMPLO:
. . .
se (num_filhos > 0) então
 inicio
 salFamilia <- num_filhos * 70
 fim
. . .
3.4.3 – Condicional Composto
Esta estrutura condicional fará com que o programa decida entre executar um de dois blocos 
de instrução. Caso o resultado da avaliação da expressão lógica de controle seja verdadeiro o 
primeiro bloco de instruções será executado, sendo que o segundo bloco de instruções não será 
executado. Caso o resultado da avaliação da expressão lógica de controle seja falso o segundo bloco 
de instruções será executado ficando então o primeiro sem ser executado. Após o término da 
execução de um dos blocos de instruções, será executada a primeira instrução que se encontrar após 
o final do segundo bloco de instruções, continuando assim a execução do restante do algoritmo, que 
segue seu fluxo de execução normalmente .
Ambos os blocos de instruções são delimitados por instruções inicio e fim. Vejamos como 
isto acontece na figura a seguir:
SINTAXE:
se (teste) então
 inicio
 {Bloco de instruções 1} 
 fim
senão
 inicio
 {Bloco de instruções 2}
 fim
EXEMPLO:
. . .
se (num resto 2 = 0) então
 inicio
 pares <- pares + 1
 fim
senão
 inicio
 impares <- impares + 1
 fim
. . .
3.4.4 – Estruturas Condicionais Aninhadas
Chamamos de estruturas condicionais aninhadas a organização de se colocar uma estrutura 
condicional dentro da outra. É importante perceber que o condicional interno ficará totalmente 
contido dentro de um dos blocos de instruções do condicional externo, é importante que seus blocos 
de instruções comecem e terminem totalmente dentro do respectivo bloco de instruções do 
condicional externo. Podemos ter condicionais aninhados dentro de qualquer um dos blocos de 
instruções do condicionalexterno.
3.4.5 – Operadores Lógicos
Expressões relacionais podem ser combinadas para formar novas expressões relacionais. Isto 
pode ser feito com o uso de operadores lógicos. A utilização destes operadores segue uma lógica 
bem semelhante a lógica que usamos em nossa vida cotidiana quando usamos estas expressões 
condicionais sem nem mesmo atentarmos para isto. Por exemplo podemos dizer que se fizer sol e 
eu estiver de folga vou para a praia. Nesta frase podemos observar dois condicionais combinados 
através do operador “e” quais são as condições para eu ir à praia? Fazer sol e além disto, também 
estar de folga. Neste caso só vai dar praia se ambas as condições forem satisfeitas.
Vejamos os operadores lógicos de nossa linguagem algorítmica:
Operador de conjunção – and lógico – e
Ex: se ((a > b) e (b <> 0))
No exemplo acima temos 2 proposições: 
- p1 - a > b
- p2 - b <> 0
p1 p2 p1 e p2
V V V
V F F
F V F
F F F
A expressão lógica será verdadeira apenas se ambas as proposições forem verdadeiras, sendo 
falsa em qualquer outro caso.
Operador de disjunção – or lógico – ou
Ex: se ((a > b) ou (a > c))
No exemplo acima temos 2 proposições:
- p1 – a > b
- p2 – a > c
p1 p2 p1 ou p2
V V V
V F V
F V V
F F F
A expressão lógica será verdadeira caso qualquer uma das proposições seja verdadeira ou 
mesmo se ambas forem verdadeiras, sendo falsa apenas se ambas as proposições tiverem valor 
falso.
Operador de negação – not lógico – não
Ex: se nao (a < b)
No exemplo acima temos 1 proposição lógica.
- p1 – a < b
p1 não p1
V F
F V
A proposição lógica vai ter seu valor lógico invertido pelo uso do operador de negação. 
	1. Introdução
	2 – Algoritmo
	2.1 – Conceito de Algoritmo
	2.2 – Algoritmo X Programa
	2.3 – Trinômio Entrada-Processamento-Saída
	2.4 – Estrutura Básica de um Algoritmo
	3 – Pseudo-Linguagem Usada
	3.1 – Instrução de Saída
	3.2 – Variáveis
	3.3 – Operador de Atribuição
	3.4 – Operadores Aritméticos
	3.5 - Instrução de Leitura
	3.6 – Algumas Funções Matemáticas Pré-Definidas
	3.2 - Conceito de troca de conteúdo de variáveis
	3.3 – Como Rastrear um Algoritmo
	3.4 – Estruturas de Decisão
	3.4.1 – Operadores Relacionais
	3.4.2 – Condicional Simples
	3.4.3 – Condicional Composto
	3.4.4 – Estruturas Condicionais Aninhadas
	þÿ
	3.4.5 – Operadores Lógicos