Material LEA

Algoritmos IFSP prof. Claudio.
ALGORITMOS E LÓGICA DE PROGRAMAÇÃO

Prof. Cláudio
IFSP
b a
= =φ =1,61803...
a (a+ b)
A menor parte está para a maior assim
como a maior está para o todo...
1
1 1/1 = 1,0
2 2/1 = 2,0
3 3/2 = 1,5
5 5/3 = 1,6666
8 8/5 = 1,6000
13 13 / 8 = 1,6250
21 21 / 13 = 1,6154
34 34 / 21 = 1,6190
55 55 / 34 = 1,6176
89 89 / 55 = 1,6182
144 144 / 89 = 1,6179
233 233 / 144 = 1,6180

... ... ...
Cristóbal Vila – Nature by Numbers
1
Índice
1 - Programação..................................................................................................3
1.1 - Conceitos........................................................................................................................ 3
1.2 - Linguagens e Programas................................................................................................ 3
1.3 - Representação Numérica............................................................................................... 3
1.3.1 - Mudanças de Base................................................................................................... 4
1.4 - Algoritmos...................................................................................................................... 5
1.4.1 - Descrição Narrativa................................................................................................. 6
1.4.2 - Fluxograma............................................................................................................. 6
1.4.3 - Pseudo-código (Português estruturado ou Portugol)...............................................7
1.4.4 - Relação entre Português Estruturado e Fluxograma...............................................8
1.5 - Tipos de Dados............................................................................................................. 13
1.5.1 - Variáveis................................................................................................................ 13
1.5.2 - Constantes............................................................................................................ 13
2 - Linguagem Pascal.........................................................................................14
2.1 - Introdução.................................................................................................................... 14
2.2 - Operações.................................................................................................................... 15
2.3 - Variáveis em Pascal...................................................................................................... 18
2.3.1 - Constantes............................................................................................................ 18
2.3.2 - Declaração de Variáveis........................................................................................ 18
2.3.3 - Enumeração.......................................................................................................... 19
2.3.4 - Tipos Primitivos Padrão em Pascal........................................................................19
2.4 - Entrada e Saída de Dados............................................................................................ 22
2.4.1 - Entrada de Dados.................................................................................................. 22
2.4.2 - Saída de dados...................................................................................................... 22
2.5 - Comandos e Blocos...................................................................................................... 24
2.6 - Decisão......................................................................................................................... 24
2.6.1 - Decisão Simples.................................................................................................... 24
2.6.2 - Decisão Composta................................................................................................. 26
2.7 - Laços............................................................................................................................ 27
2.7.1 - For......................................................................................................................... 27
2.7.2 - While..................................................................................................................... 30
2.7.3 - Repeat Until .......................................................................................................... 31
2.8 - Estruturas de Dados..................................................................................................... 35
2.8.1 - Vetores.................................................................................................................. 35
2.8.2 - Matrizes................................................................................................................. 38
2.9 - Procedimentos e Funções............................................................................................. 42
2
1 - Programação
1.1 - Conceitos
Computador:
autômato que executa processos computacionais segundo regras precisamente
estabelecidas;
possui um número limitado de instruções conhecidas, que entende e obedece;
processa com rapidez e confiabilidade;
processa (incansavelmente) sequências longas de instruções que se transformam em
um conjunto quase infinito de ações;
O ato de agrupar sequências de instruções em “receitas” representando tarefas com -
putacionais é chamado de programação.
1.2 - Linguagens e Programas

Comandos:
duração finita (somar dois números);
efeito conhecido e bem definido (resultado da soma);
subentende objetos sobre os quais a ação será executada (números);
provoca mudança de estado reconhecível nos objetos (acumulador);
descrita segundo uma linguagem (sintaxe: a := b + c “a recebe o valor de b mais c”);
descrição chama-se comando;
se puder ser decomposta: processo ou computação;
sequencial: partes executadas em rigorosa ordem cronológica e nenhuma delas
simultânea;
programa: conjunto de comandos;
Quem executa as ações: processador.
Fornece os dados: memória.
Linguagens
Inicialmente:
codificação complexa;
amarrada a cada arquitetura, nada portável; mudou a máquina, recomeça do zero;
propensa a erros;
completamente não estruturado: dificílima correção!
criadas então as linguagens de alto nível ;
Compiladores
traduzem todos os comandos em linguagem de alto nível para linguagem de baixo
nível todos de uma vez;
cria programa “compilado” (binário);
Interpretadores
processam os comandos de alto nível, transformando-os um por vez em baixo nível;
existe apenas a versão “alto nível”; quem a executa é um interpretador.
1.3 - Representação Numérica

Modo que o computador armazena as informações;
bit: menor unidade de armazenamento; registra apenas sim (1) ou não (0);
byte: elemento composto de bits;
Os computadores, devido ao bit possuir apenas dois estados (0 | 1), trabalha na base 2.
3
1.3.1 - Mudanças de Base

Dizemos que um número está em uma determinada “base” x quando foi representado
utilizando-se x símbolos. Assim a base 10 (base10) possui 10 símbolos: 0, 1, 2, 3, 4, 5, 6,
7, 8, 9; a base2 dois: 0 e 1 e a base16 dezesseis: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.
É comum representar a base junto com o número, para evitar confusões:
Que número é 110?
1102 = 610, 1108 = 7210, 11016 = 272 10
A posição de cada dígito em um número diz quantas vezes ele multiplica a potência
daquela posição. O número 75082 10, por exemplo, pode ser descrito como
7.10000 + 5.1000 + 0.100 + 8.10 + 2.1 = 7.10 4 + 5.103 + 0.102 + 8.101 + 2.100 .
Seguindo a mesma lógica:
100111101 2 =1.28 + 0.27 + 0.26 + 1.25 + 1.24 + 1.23 + 1.22+ 0.21+ 1.20=
1.256 + 0.128 + 0.64 + 1.32+ 1.16 + 1.8 + 1.4 + 0.2 + 1.1 = 31710
7138 =7.82 + 1.81 + 3.80 =
7.64 + 1.8 + 3.1 = 45910
2F81A16 = 2.164 + F.163 + 8.162 + 1.161 + A.160 =
2.65536 + 15.4096 + 8.256 + 1.16 + 10.1 = 194 586
(lembrar-se que A=10, B=11, C=12, D=13, E=14 e F=15)
Para passar para uma determinada base, o raciocínio é invertido: em vez de
multiplicar pela potência da base, vai-se dividindo pela base:
Exercícios:
1.Converta cada número abaixo para a base 10:
a)1011 2 b)100101 2 c)1110101 2
d)108 e)1318 f)10148
g)FF16 h)100016 i)ABCD16
2.Converta cada número abaixo da base 10 para a base indicada:
a)10 → base2 b)33 → base2 c)256 → base2
d)100 → base8 e)64 → base8 f)1001 → base8
g)256 → base16 h)762 → base16 i)51966 → base16
4
1.4 - Algoritmos
Conjunto de regras de operação cuja aplicação permite resolver um problema enunciado
por meio de um número finito de operações. Um algoritmo pode ser traduzido segundo uma
linguagem de programação em um programa que pode ser executado por um computador.
O exemplo mais corriqueiro de algoritmo é
BISCOITOS DE NOZES
uma receita culinária (veja Quadro 1.1): cada Ingredientes:
passo deve ser detalhado e executado em • 1 xícara de manteiga ou margarina
sequência para se atingir o resultado final • 1/2 xícara açúcar de confeiteiro
desejado. • 1 colher (chá) baunilha
• 2 1/4 xícaras de farinha de trigo
Ao descrever um algoritmo devemos definir • 1 pitada de sal
as ações de modo claro e específico. Partimos de • 3/4 xícara de nozes bem picadas
um estado inicial e, após um período de tempo • Açúcar de confeiteiro para enfeitar
previsto, chegamos a um resultado previsto e Preparo:
definido. 1 – Misture bem a manteiga e o açúcar. 2 – Junte a
baunilha e a farinha peneirada com o sal. 3 – Misture
Um algoritmo estabelece uma norma de novamente. 4 – Adicione as nozes e leve a massa à
execução e um final previsto que sempre será geladeira por uns 15 minutos. 5 – Aqueça o forno em
alcançado se o mesmo algoritmo for executado temperatura média (200 graus). 6 – Faça bolinhas de
novamente. 2 cm de diâmetro e 7 – coloque numa assadeira sem
untar. 8 – Leve para assar por uns 10 a 12 minutos.
Um exemplo seria a definição de como 9 – Passe no açúcar de confeiteiro enquanto estão
mornos.
desenhar um quadrado. Podemos dizer que, para
desenhar um quadrado, podemos fazer quatro Quadro 1.1: Exemplo de Algoritmo
vezes as ações de riscar um traço e mudar a
direção em 90° para a direita. Vejamos como fica no programa Scratch (scratch.mit.edu):
4 3 2 1 0
5
Há diversos modos de expressar um algoritmo:
1.4.1 - Descrição Narrativa

Descrição dos passos a serem executados segundo o algoritmo para atingir o objetivo:
Média: some todos os números; divida a soma pela quantidade de números.
1.4.2 - Fluxograma
Comandos são representados por símbolos gráficos e uma indicação do fluxo:
6
1.4.3 - Pseudo-código (Português estruturado ou Portugol)

Entrada
Em geral uma instrução para ler (Leia, Ler)
Exemplo: Leia idade
Leia numero
Saída:
Um comando que indica que algo será impresso, escrito na saída (Escreva,Imprima)
Exemplo Escreva “sua idade é “,idade,” anos.”
Escreva numero, “ ao quadrado é “, numero * numero
Interação / Laços
Enquanto: Repete os seus comandos enquanto a condição for verdadeira. Testa se
é verdadeira antes de começar a executar seus comandos. ←
Exemplo Escreva “Digite um numero:”
Leia numero
Enquanto (numero > 0) faça
numero  numero – 1
Fim_Enquanto
Escreva “Acabei!”
Repare que se o número for menor ou igual a zero ele nem calcula, vai direto
para “Acabei!”.
Repetir/Enquanto: Inicia um grupo de comandos e só volta a repetir se a condição
de Enquanto for verdadeira.
Exemplo Escreva “Digite um numero:”
Leia numero
Repetir
numero  numero – 1
Enquanto (numero > 0)
Repare que ele só vai checar se continua a repetição depois de ter executado
seus comandos. Se o número for negativo, ele escreve e depois vai pra “Acabei!”
Faça para: Repete uma interação um número fixo e conhecido de vezes.
Exemplo Faça para numero de 1 até 10
Fim_Faça
Sabe-se que são 10 vezes.
Decisão:
Se uma condição for verdadeira, então realiza uma ação, senão executa outra.
Exemplo 1 Escreva “Digite sua idade:”
2 Leia idade
3 Se (idade > 0 E idade < 12)
4 Então
5 Escreva “A criança tem “, idade, “anos.”
6 Senão
7 Se (idade < 18)
8 Então
9 Escreva “O adolescente precisa de permissão.”
10 Senão
11 Escreva “Adulto, hein? É bom ter juízo.”
12 Fim_Se
7
13 Fim_Se
Não é obrigatório ter senão.
1.4.4 - Relação entre Português Estruturado e Fluxograma

a) Enquanto
... Saída: Saída:

Leia x 4↵ -2 ↵
Enquanto (x > 0) faça 4
Escreva x 3
2
xx–1
1
Fim_Enquanto
...
b) Repetir
...
Saída: Saída:
Leia x
4↵ -2 ↵
Repetir
4 -2
Escreva x
3
xx–1 2
Enquanto (x > 0) 1
...
c) Faça
... Saída: Saída:

Leia x 4↵ -2 ↵
Faça i  1 até x 4
Escreva x 4
Fim_Faça 4
... 4
8
9
Exercícios:
1.Faça o fluxograma ou escreva o pseudo-código de um algoritmo que lê três valores a, b e
c e imprime o maior deles.
2.Faça um algoritmo em Português estruturado que lê um valor para o raio, calcula e
imprime os seguintes resultados para este raio: o perímetro de uma circunferência
(perímetro = 2.π.raio), a área (área = π.raio²) e o volume de uma esfera (volume = 4/3.π.raio³).
Considere π= 3,1416.
3.Desenhe o fluxograma de um algoritmo que lê um valor (em graus Fahrenheit) e
imprime o valor convertido para graus Celsius segundo a fórmula: C = (F-32).5/9 .
4.Faça um algoritmo em Português estruturado que leia quatro valores (a, b, c e d) e
imprime a amplitude entre eles (amplitude é a diferença entre o maior e o menor) e a
média deles (média é a soma dos valores pela quantidade de valores).
5.Faça um algoritmo em Português estruturado que lê três valores – dia, mês e ano atual – e
imprime quantos dias faltam até o ano novo.
6.Faça um algoritmo que lê seis valores: dia, mês e ano de nascimento e dia, mês e ano atual. O
algoritmo diz quantos dias aproximadamente de idade a pessoa tem. Considere todos os
meses com 30 dias e todos os anos não-bissextos.
7.Faça um algoritmo em Português estruturado que leia três valores a, b e c. Supondo que
sejam os lados de um triângulo, o algoritmo deve imprimir “equilátero” se os lados
forem iguais, “isósceles” se apenas dois forem iguais ou “escaleno” se não tiver um lado
igual ao outro. Se não for um triângulo (soma dos dois menores lados for menor que o
valor do maior) então deverá escrever:”não é triângulo”.
8.Sabendo-se que a solução de uma equação de 2 o grau a.x2 + b.x + c = 0 é dada pela
−b± b2 −4.a.c
fórmula x= , apresente um fluxograma ou o pseudo-código de um
2.a
algoritmo que, utilizando a fórmula, resolva uma equação de 2 o grau e apresente as
raízes possíveis, em função de a, b e c ou “não há raízes reais” caso não haja raízes.
9.Desenhe o fluxograma ou escreva o pseudo-código de um algoritmo que, dado um
número inteiro positivo n, calcula a soma de todos os número de 1 até n.
10.Desenhe o fluxograma ou escreva o pseudo-código de um algoritmo que calcula a soma
de todos os números que sejam múltiplos de 5 ou de 7 existentes entre 1 e 10000.
Observação:Utilize e função resto: y MOD x. A função resto devolve o resto de uma

divisão inteira de y por x. Quando o resultado de resto de um valor y por x é 0, significa
que y é múltiplo de x.
Assim: 9 MOD 5 = 4 lê-se “nove resto 5 é quatro” pois 9 / 5 = 1 e resta 4.
8 MOD 3 = 2 10 MOD 5 = 0 (10 / 5 = 2 e resta 0)
1000 MOD 999 = 1 5 MOD 8 = 5 (5 / 8 = 0 e resta 5)
0 MOD 3 = 0 1 MOD 3 = 1 2 MOD 3 = 2
3 MOD 3 = 0 4 MOD 3 = 1 5 MOD 3 = 2
6 MOD 3 = 0 7 MOD 3 = 1 8 MOD 3 = 2
9 MOD 3 = 0 10 MOD 3 = 1 11 MOD 3 = 2 ...
Observe que os múltiplos de 3 têm resto zero...
11.Escreva o algoritmo em Português estruturado ou em fluxograma que lê um número
inteiro positivo n e imprime todos os divisores inteiros positivo de n. Por exemplo, se
entrado o valor 18, o programa deverá retornar 1 2 3 6 9 18.
12.Escreva o algoritmo em Português estruturado ou em fluxograma que leia um valor x
inteiro positivo e imprime o primeiro múltiplo de 9 que é maior que x.
inteiro positivo e imprime o maior divisor de x que é menor que x.
10
14.Faça um algoritmo em Português estruturado que lê dois valores inteiros positivos a e b e

imprime o maior divisor comum entre eles.
15.Faça o fluxograma ou escreva o pseudo-código de um algoritmo que, dado um número
inteiro positivo x, encontre e imprima um valor M que é o primeiro múltiplo de 11 maior
ou igual a x. Se m for par, escrever “m é par”; caso contrário: “m é ímpar”. Só são
permitidas as operações de soma, subtração e resto ( MOD).
16.Desenhe o fluxograma ou escreva o pseudo-código de um algoritmo que calcula para os
números entre 1 e n (dado) um valor que é a soma dos que sejam múltiplos de 11 e a
subtração dos números múltiplos de 7. Se o valor final calculado for par, ele deve ser
dividido por dois antes de ser apresentado; se for ímpar, deve ser subtraído de um e
depois dividido por dois antes de ser mostrado.
17.Construa um fluxograma ou o pseudo-código que calcula o fatorial de x (x!). Pela
definição, fatorial de 1 (1!) é 1 e fatorial de x é o produto de todos os valores positivos
até x: x ! =x. x−1.  x−2 . x−3 ..... 4.3.2.1 ou ainda: x ! =x. x−1!
inteiro positivo e diz se x é número primo ou não. Um número é dito primo se não tem
divisores exceto 1 e ele mesmo.
19.Faça um algoritmo em Português estruturado que lê um valor inteiro positivo n, encontre
e imprima o primeiro número primo maior ou igual a n.
20.Dado um número inteiro positivo par x, escreva o algoritmo em Português estruturado ou
1 3 5  x−1
o fluxograma que imprime o valor da soma S =   ... .
2 4 6 x
1 3 5 7
Exemplo: se x = 8 então S =    =2,958333333 .
2 4 6 8
21.Dado um número inteiro positivo x, escreva o algoritmo em Português estruturado que
2.i−1
imprime o valor da soma S = 1 − 1  1 − 1  1 −... −1 . Observe a troca de sinais.
1 2 3 4 5 x
1 1 1 1 1 1
Exemplo: se x = 6 então S = −  −  − =0,616666667 .
1 2 3 4 5 6
22.Dado um número inteiro positivo par x, escreva o algoritmo em Português estruturado
1 2 3 x
que imprime o valor da soma S =   ... .
01 12 23  x−1x 
1 2 3 4 5
Exemplo: se x = 5 então S =     =3,393650794
01 12  23  34   45 
11
23.Execute o algoritmo abaixo (teste de mesa) e escreva no quadro qual a saída:

x← + 2 use no espaço o último dígito não nulo do seu RA
y← + 2 use no espaço o penúltimo dígito não nulo do seu RA
se (x = y)
entao
y←y+4
fimse
se (x > 9)
entao
x ← (x MOD 6) + 2
fimse
se (y > 9)
entao
y ← (y MOD 7) + 1
fimse
Escreva(“valores: x=”, x, “ y=”, y)
se (x > y)
entao
m←x*y
senao
m←y+x
fimse
a←x Quadro de Respostas
b←y
se (a > b)
entao
a←y
b←x
fimse
Escreva(” m=”, m)
Repita
se (a = b)
entao
interrompa
fimse
x←x–a
y←y+b
a←a+1
fimrepita
Escreva(“finais x=”, x, “ y=”, y)
fimAlgoritmo
24.Desenhe o fluxograma de um algoritmo que constrói o seguinte número inteiro positivo:
dado um valor n lido, constrói um número que tem n dígitos e cada dígito é a sua
posição no número. 0 < n < 10.
Exemplo: para n = 5 o número é 12345; para n = 8 o número é 12345678.
Lembrar que: 12345 = 1 . 10000 + 2 . 1000 + 3 . 100 + 4 . 10 + 5 . 1
ou ainda que: 12345 = 1 . 10.10.10.10 + 2 . 10.10.10 + 3 . 10.10 + 4 . 10 + 5
25.Faça um algoritmo em Português estruturado que leia três valores: xi, xf e nd. Esses
valores representam, respectivamente, o valor inicial de x, o valor final de x e o número
de dados – igualmente espaçados entre xi e xf – a serem calculados e impressos. O
algoritmo imprime uma tabela para o valores de x utilizados e os valores de y calculados
segundo a fórmula y = 4x³ –2x² +6x -16 .
26.A sequência de Fibonacci é verificada em diversos locais da natureza: número de
sementes por anel interno do girassol, tamanho das folhas em um ramo de samambaia
etc. Nesta sequência, cada termo é a soma dos dois termos anteriores (ou seja,
ni = ni-1 + ni-2), sendo que o primeiro é 1 e o segundo é 1. Assim, a sequência de Fibonacci
12
para o 8o termo é:
posição: 1o 2o 3o 4o 5o 6o 7o 8o
valor: 1, 1, 2, 3, 5, 8, 13, 21 ⇒ o 8 o termo é 21
Faça o fluxograma ou o pseudo-código de um algoritmo que leia um número inteiro n

(n  3) e calcule o valor de Fibonacci deste n-ésimo termo.
27.Faça um algoritmo em Português estruturado que lê dois valores a e b
(0 < b < a < 10000, validar) e imprime todos os múltiplos de b que existem entre 1 e a
(inclusive).
28.Desenhe um fluxograma ou construa o pseudo-código de um algoritmo que multiplica
um número inteiro por outro retornando o resultado, utilizando apenas soma e
subtração.
29.Construa um fluxograma ou o pseudo-código de um algoritmo que divide um número
inteiro por outro, devolvendo o quociente e o resto, utilizando apenas soma e
subtração.
13
1.5 - Tipos de Dados

1.5.1 - Variáveis
Variáveis são reservatórios de valores, dados, utilizados em um programa. Armazenam
tanto valores numéricos de diversas capacidades quanto texto, na forma de cadeias de
caracteres. Uma metáfora para descrever suas funcionalidades seria a de uma gaveta com
um rótulo – seu nome – ou de uma conta-corrente – para valores.
Visando a sintaxe de Pascal, adotaremos que nomes de variáveis devem começar com
letra ou sublinhado e serem seguidos por letras, números ou sublinhado. Evitar caracteres
especiais (“, #, $, %, @, & etc) pois, em geral, são inválidos ou têm significação especial para
a linguagem.
Convém evitar nomes de variáveis com acentos ou cedilha: mes em vez de mês; mae em
vez de mãe, macan em vez de maçã, etc. O motivo é que os acentos e a cedilha são mapeados
em diversos lugares diferentes e podem ser exibidos incorretamente além de confundir o
compilador.
a) Numéricas
Representam um número: inteiro ou de ponto flutuante:
n = 19 Soma = 2314.87 Raiz_Quadrada = 121.32 pessoas_4 = 53 etc.
Obs: a parte fracionária do número será representada por ponto em vez de vírgula!
b) Alfa-numéricas
Representam uma sequencia de letras, números ou ambos simultaneamente. Os
números representados por uma variável alfa-numérica não são computáveis.
pessoa = “Dom Pedro I” enderecoRes = “Rua dos Tamoios, 200”
cep = “21078-300” conta = “898876” banco = “275”
Observação: geralmente banco + conta = “275898876”
c) Lógicas ou Booleanas
Assumem apenas valores verdadeiro ou falso (1/0, V/F, T/F, true/false etc).
presente = V eleitor = V casado = F
1.5.2 - Constantes
São variáveis cujos valores não podem ser alterados:
PI = 3.1415926537 MAE = “Márcia Marques” NATURAL_DO_BRASIL = V
É convenção usar sempre letras maiúsculas para os nomes de constantes.
Exercícios:
1.Diga quais afirmações abaixo são válidas para atribuir valores a variáveis ou constantes.
Se for inválida, diga o porquê.
a) Apto3xSemJuros = 11.22 b) 5xNoCartao = 119.334 c) NomePai = 12
d) _nome_ = “Augusto” e) nUMcONTA = 1343.11224 f) x1847773 = “São Paulo”
g) Nome Mae = “ Marcia” h) PI = “Juscelino” i) 4x4 = “JEEP”
j) EXP = 2.722 k) CONSTANTE_12 = 0.001 l) valor$ = 1.99
m) reuniao_tercas = V n) 0filhos = V o) ZEROfilhos = F
2.Crie os nomes das variáveis e os conteúdos para as diversas situações abaixo:

a) dados de um aluno de universidade;
b) dados de um automóvel;
c) conta em um banco.
14
2 - Linguagem Pascal
2.1 - Introdução
A linguagem de programação Pascal foi criada em torno de 1970 pelo professor de
informática suiço Niklaus Wirth. A linguagem, nomeada em homenagem ao matemático
Blaise Pascal, foi construída de modo a encorajar a programação estruturada e ser didática.
Pascal tornou-se popular na década de 80, com o aparecimento de um compilador
popular chamado Turbo Pascal. O Turbo Pascal evoluiu incluindo conceitos de Orientação a
Objetos (a partir da versão 5.5) e deu origem ao Delphi e sua versão atual multiplataforma
conhecida por Lazarus.
Wirth criou a partir do Pascal outras linguagens de programação: Modula, Modula-2
(1978) e Oberon (1986).
Genealogia da linguagem Pascal:
fonte: Programming Language Design Concepts de David A. Watt
A linguagem de programação Pascal foi construída de modo a favorecer a programação

estruturada e modular, onde cada elemento (módulo) induzisse o programador a evitar a
inter-dependência entre os módulos (acoplamento) e promovesse assim um maior foco
operacional interno ao módulo (coesão).
Pascal utiliza-se de procedimentos e funções como ferramentas para a programação
modular.
Há diversos compiladores Pascal (inclusive com ambientes de desenvolvimento – IDEs)
disponíveis. Vários deles são livres (código aberto) , gratuitos ou ambos.
15
Eis alguns compiladores:
FreePascal
Livre e gratuito - GPL;
Endereço: www.freepascal.org ;
Compatível com TurboPascal e Delphi;
Linha de comando;
IDEs (Ambientes de Desenvolvimento):
Lazarus: www.lazarus.freepascal.org ;
DevPascal www.bloodshed.net/devpascal.html .
Pascal Zim!
Gratuito;
Endereço: pascalzim.tripod.com;
Compilador básico e incompleto, com IDE em Português mas muito bom como base;
Desenvolvido e mantido por um professor da UNB;
Possui manuais e livros-texto sobre Pascal.
2.2 - Operações
a) Aritméticas
Número de
Operador Ação operandos
+ soma inteira e de ponto flutuante dois
- subtração inteira e de ponto flutuante um ou dois
* multiplicação inteira e de ponto flutuante dois
/ divisão de ponto flutuante dois
DIV divisão inteira dois
MOD resto de divisão inteira dois
b) Relacionais (sempre DOIS oper.) c) Lógicos
Operador Ação Operador Ação Número de
> maior que operandos
>= maior ou igual a () and e (∧) dois
< menor que
or ou (∨) dois
<= menor ou igual a ()
= igual a not não (¬) um
<> diferente de (≠)
d) Tabela Verdade para Operadores Lógicos

“E lógico” ∧ (and) “Ou lógico” ∨ (or) “Não lógico” ¬ (not)
A B A and B A B A or B A not A
V V V V V V V F
V F F V F V F V
F V F F V V
F F F F F F
Exemplos:
A: motor ligado A: tem gasolina no tanque A: tem crachá
B: marcha engatada B: tem álcool no tanque ¬A: não tem crachá
carro anda se A and B carro flex tem comb. se A or B ! B: porta trancada
¬B: porta destrancada
Entra se A and not B
16
e) Precedência
Em geral: Aritméticos > Relacionais > lógicos:
( ) > not - > * / MOD > +- > < <= = <> >= > > and > or > :=
Exemplos de expressões e precedência:

verdadeiro se y é maior que 5 e menor que 350, ou seja, 5 < y < 350:
(y > 5) and (y < 350)
verdadeiro se j é maior ou igual a 10 e menor que 100 ou maior que 900 e menor ou
igual a 1000, ou seja, (10  j < 100) ∨ (900 < j  1000):
( (j >= 10) and (j < 100) ) or ( (j > 900) and (j <= 1000) )
verdadeiro se x é par e maior ou igual a zero ou x é ímpar e menor que zero:

(x MOD 2 = 0) and (x >= 0) or (x MOD 2 <> 0) and (x < 0)
verdadeiro se k não é nem múltiplo de 3 nem múltiplo de 7:

not(k MOD 3 = 0) and not(k MOD 7 = 0)
um ano é bissexto se for múltiplo de 4 (mas não de 100) ou múltiplo de 400:
supondo o ano como 2028:
((ano MOD 4 = 0) and (ano MOD 100 <> 0)) or (ano MOD 400 = 0)
0 0 28 0 28 0
= <> =
V V
and
V F
or
V
2028 é bissexto!
17
Exercícios:
1.Escreva na notação de Pascal as expressões lógicas (∨ é “ou”, ∧ é “e”, ¬ é “não”):
a) 1  x < y b) (-5 < x < 5) ∧ (5 > y > -5)
c) ¬((x > y) ∨ (y < z)) d) 1 < x  y  z < 100
e) (x = y) ∧ (y ≠ z) f) ¬(a > b) ∧ ((b < c) ∨ ¬(c < d))
g) (sald > saq) ∨ (cred + sald) > saq h) (idade > 18 ∧ ¬casado) ∨ nfilhos = 0
2.Escreva a expressão lógica que retorna verdadeiro se a variável mes (1  mes  12)
representa um mês que tem 31 dias.
3.Escreva a expressão lógica que retorna verdadeiro se o aluno foi aprovado. Para ser
aprovado, o aluno deve obter notas em avaliações. As avaliações são compostas por
duas provas, dois trabalhos e uma prova geral. As notas das provas têm peso 0,8; dos
trabalhos, 0,2 e provas e trabalhos juntos têm peso 0,9. A nota da prova geral tem peso
0,1. O aluno é aprovado se a média final (média das provas com os trabalhos e da geral)
for maior ou igual a 6,0.
4.Escreva a expressão lógica que reproduz a capacidade do(a) aluno(a) ir a uma festa.
Ele(a) precisa, inevitavelmente, da permissão de um dos pais. Tendo a permissão, ou
ele(a) tem dinheiro para o taxi, ou tem carona, ou permissão para usar o carro. Para
entrar na festa ele(a) precisa ou ter dinheiro para a entrada ou convite.
18
2.3 - Variáveis em Pascal

Variáveis são abstrações de posições de memória; o conteúdo da variável é na verdade
o conteúdo da memória referenciada pelo nome (endereço) da variável. Em Pascal, nomes de
variáveis não são sensíveis à caixa:
maiúsculas = minúsculas (SOMA = Soma = soma)
2.3.1 - Constantes
Constantes são valores tidos como fixos e que, portanto, não podem ser alterados
durante a execução do programa.
Constantes são definidas pela palavra reservada Const, seguida por uma lista de nomes
e seus valores.
Por convenção, os nomes de constantes são maiúsculas.
de nomes de variáveis e, entre parênteses, os valores possíveis que podem assumir.
Forma:
Const nome = valor;
Exemplo:
Const PI = 3.14159237;
NUM_DENTES = 32;
NUM_SEGUNDOS_DIA = 86400;
2.3.2 - Declaração de Variáveis

Para que uma variável possa ser utilizada em Pascal ela precisa ter seu nome e tipo
definidos em uma parte do programa chamada declaração. A declaração é iniciada pela
palavra reservada Var, seguida por uma lista de nomes de variáveis e seus tipos.
Forma:
Var nome1 : Tipo1;
nome2 : Tipo2;
...
nomen : Tipon;
Exemplo:
Var idade : Integer;
altura, custo : Real;
opcao : Char;
eh_brasileiro, primeira_consulta : Boolean;
Atribuição: a atribuição de valores é feita através do operador de atribuição := (lê-se
“recebe”).
idade := 21; (* idade recebe 21 *)
custo := 793.24; (* custo recebe 793.24*)
eh_brasileiro := true; (* eh_brasileiro recebe true *)
19
2.3.3 - Enumeração
A enumeração cria um tipo novo através da discriminação, da listagem dos seus
possíveis valores. A declaração é iniciada pela palavra reservada Type, seguida por uma lista
de nomes de variáveis e, entre parênteses, os valores possíveis que podem assumir.
Forma:
Type t = (v1, v2, v3, ... , vn);
Especificando que o novo “tipo” de dados t poderá assumir apenas um dos possíveis
valores v1, v2, v3, ... , vn .
Exemplos:
Type figura = (retangulo, circulo, triangulo, quadrado);
Type cor_primaria = (azul, vermelho, amarelo);
Type semana = (domingo, segunda, terca, quarta,quinta, sexta, sabado);
Type situacao = (erro, inicial, processando, final);
Type sexo = (masculino, feminino);
Type estado_civil = (solteiro, casado, separado, viuvo, junto);
Os novos tipos definem não só o novo identificador ( figura) como também o conjunto
de valores de identificadores possíveis para ele ( retangulo, circulo etc).
É possível então criar variáveis:
VAR s : sexo;
d : semana;
f : figura;
Atribuições válidas:
s := masculino;
d := quarta;
f := triangulo;
Muito mais claras que: s := 1; d := 4; f := 3;
as quais são as representações internas dos valores enumerados.
Outra vantagem é que as atribuições são controláveis:
f := elipse; ou f := 5; não existem.
2.3.4 - Tipos Primitivos Padrão em Pascal

Tipos primitivos são aqueles disponíveis sem a necessidade de definição.
a) Inteiros
Os inteiros representáveis no computador são um sub-conjunto dos total de números
inteiros. Em um computador utilizando n bits em complemento de dois, os valores possíveis
para uma variável x inteira estão entre -2n-1 ≤ x ≤ 2 n - 1. Tentar representar um valor fora
desta faixa causa erro de estouro (overflow).
Exemplo:
VAR num_filhos : Integer;
quant_comodos : Integer;
dias_uteis : Integer;
num_filhos := 1 ;
quant_comodos := 6 ;
dias_uteis := 45;
Operações:
+ - * → operações normais:
num_total_comodos := quant_comodos * num_andares ;
20
DIV → Divisão inteira:

resultado := 19 DIV 5; (* a divisão inteira de 19 por 5 é 3 *)
MOD → Resto da divisão inteira:
resultado := 19 MOD 5; (* resto da divisão inteira de 19 por 5 é 4 *)
21
b) Real
Os números reais armazenam valores com casas decimais.
Exemplo:
VAR peso : Real;
distancia : Real;
tempo : Real;
peso := peso / 1000.0 ; (* passando de g para Kg *)

distancia := 2.0 * 3.14 * raio ; (* perímetro = 2 * Pi * Raio *)
tempo := tempo / 3.6666 ; (* conversão *)
Operações:
+ - * / → operações normais
c) Double
As variáveis do tipo Double são variáveis que armazenam valores com casas decimais
como as Real, porém, com o dobro da precisão.
d) Boolean
As variáveis do tipo Boolean aceitam apenas dois valores: true (verdadeiro) ou false
(falso). São usadas para controlar estados ou situações dentro do código.
Exemplo:
VAR apto_votar: Boolean;
brasileiro: Boolean;
idade : Integer;
apt_votar := brasileiro and (idade >= 16);

Operações lógicas:
e lógico: and
ok := pag_efetuado and despachado;
ou lógico: or
tem_combustivel := abast_etanol or abast_gasolina;
não lógico: not
saque_possivel := not cartao_bloqueado and (saldo >= saque);
e) Char
As variáveis do tipo Char guarda um caractere alfabético, numérico ou um símbolo e
estruturas com várias delas juntas são úteis para manipular nomes, endereços etc.
Exemplo:
VAR classe : Char;
operacao : Char;
classe := 'A';
operacao := '*';
Operações:
Ordem na tabela de códigos: Ord(x)
posicao := Ord(classe); (* a posição da letra 'A' é 65 *)
Caractere da tabela de códigos: Pos(x)
classe := Pos(66); (* classe agora contém 'B' *)
Maiúscula: UpCase(x)
classe := 'x';
classe := UpCase(classe); (* a classe agora vale 'X' *)
22
23
Exercícios:
1.Defina três constantes e seus valores fixos.
2.Defina um tipo de enumeração com ao menos três valores possíveis e crie uma variável
atribuindo um valor.
3.Crie as variáveis definindo seus tipos e nomes para os seguintes dados:
a) área em metros quadrados de um apartamento;
b) dados de um cachorro;
c) dados de uma locadora de DVDs.
24
2.4 - Entrada e Saída de Dados

Receber dados e devolver resultados é a utilidade básica de todo programa.
2.4.1 - Entrada de Dados

Entendemos por “entrada de dados” o recebimento de dados que não fazem parte do
programa, serão utilizados no programa e geralmente são diferentes a cada execução. Aqui
trataremos da entrada de dados pelo teclado.
a) Read / ReadLn
Para ler algo do teclado para alguma variável usamos os comando Read (ler) ou
ReadLn (ler e pular linha).
Forma:
Read (variável1, variável2, ..., variáveln); (* ou *)
ReadLn (variável1, variável2, ..., variáveln);
A separação, durante a digitação, dos valores é feita por um “branco” (espaço,
tabulação ou enter).
A forma ReadLn. retorna um “pular linha” a cada entrada porém o efeito não é
reconhecível e os comportamentos entre Read e ReadLn acabam sendo confundidos.
Apesar da construção permitir a entrada de múltiplas variáveis por comando, isso
deve ser evitado pois variáveis do tipo caractere não são corretamente atribuídas.
A recomendação então é que cada entrada de dados seja feita por um único Read ou
ReadLn.
Exemplos:
ReadLn (idade, peso, sexo);
(* seria preferível fazer: *)
ReadLn (idade);
ReadLn (peso);
ReadLn (sexo);
2.4.2 - Saída de dados

A saída é modo de obtermos os resultados processados pelo programa.
a) Write / WriteLn
Para escrever algo na tela utilizamos os comando Write (escrever) ou WriteLn (escrever
e pular para a próxima linha).
Forma:
Write (Texto_e_Dados);
WriteLn (Texto_e_Dados);
Texto_e_Dados é uma lista de nenhum, um ou mais textos (e seus formatos opcionais

) seguidos de nenhuma, uma ou mais variáveis (e seus formatos opcionais).
25
Exemplos:
1 Program teste (input, output);
2 VAR idade : Integer;
3 altura, saldo : Real;
4 sexo : Char;
5 solteiro : Boolean;
6 BEGIN
7 Write ('Idade: ');
8 Readln(idade);
9 Write ('Altura: ');
10 Readln(altura);
11 Write ('Sexo(m/f):');
12 Readln(sexo);
13 Write ('Saldo: ');
14 Readln(saldo);
15 Writeln('* Saída sem formato ou nova linha *');
16 Write('Você tem ', idade, ' anos, ');
17 Write(altura,' metros, ');
18 Write('seu sexo é', UpCase(sexo), ' ');
19 Write('e o saldo é ', saldo, 'R$ ', saldo);
20 Writeln();
21 Writeln();
22 Writeln('* Saída sem formato com nova linha =');
23 Writeln('Você tem ', idade, ' anos, ');
24 Writeln(altura,' metros, ');
25 Writeln('seu sexo é', UpCase(sexo), ' ');
26 Writeln('e o saldo é ', saldo, 'R$ ', saldo);
27 Writeln();
28 Writeln('* Saída com formato e nova linha *');
29 Writeln('Você tem ', idade, ' anos, ');
30 Writeln(altura:6:2, ' metros, ');
31 Writeln('seu sexo é', UpCase(sexo):5, ' ');
32 Writeln('e o saldo é ', saldo:8:2, 'R$ ':15, saldo:0:2);
33 END.
Saída:
26
Idade: 21
Altura: 1.78
Sexo(m/f):m
Saldo: 214.37
* Saída sem formato ou nova linha *
Você tem 21 anos, 1.78000000000000E+000 metros, seu sexo éM e o saldo é
2.14370000000000E+002R$ 2.14370000000000E+002
* Saída sem formato com nova linha *

Você tem 21 anos,
1.78000000000000E+000 metros,
seu sexo éM
e o saldo é 2.14370000000000E+002R$ 2.14370000000000E+002
* Saída com formato e nova linha *

Você tem 21 anos,
1.78 metros,
seu sexo é M
e o saldo é 214.37 R$ 214.37
27
Exercícios:
1.Escreva um programa em Pascal que lê um número inteiro entre 1 e 12 (inclusive) e
imprime TRUE se o mês lido tem 31 dias e FALSE caso contrário.
Observações:
- você não pode usar comandos de decisão (if);
- não é necessário checar se o número é válido; supõe-se que sim.
Refaça, agora em Pascal, os exercícios de 1 até 7 para fluxogramas ou Português
estruturado da página 10.
2.5 - Comandos e Blocos

Uma expressão como x := y / 2; ou Write('o valor de x é ',x); tornam-se comandos ao serem
encerrados pelo terminador “;”. Porém algumas vezes é necessário agrupar comandos em
um comando maior, composto. Este comando composto é chamado de bloco e é indicado
pela presença de begin e end agrupando os comandos.
2.6 - Decisão
O comando de decisão é o responsável por, em função de uma condição, desviar o fluxo
de execução do programa.
2.6.1 - Decisão Simples

A decisão simples – Se (condição) Então / Senão – é o desvio mais comum. Ela desvia o
fluxo caso condição seja verdadeira e continua após a execução dos comandos de Então ou
Senão.
Forma:
If (expressão lógica)
Then (* então – quando expressão retorna verdadeiro *)
comando1
Else (* senão – quando expressão é falsa; opcional! *)
comando2;
Exemplos:
Write('O sexo é ');
If (sexo = 'F')
Then
Writeln('Feminino')
Else
Writeln('Masculino');
O comando If supõem, como todos os comandos de Pascal, que será executado

apenas um comando em Then ou Else. Se mais comandos precisam ser executados,
então eles precisam ser agrupados por blocos de begin e end.
28
1 Writeln('Processando a idade:');
2 If (idade > 0) (* Reparar no deslocamento do código. Chama-se indentação e *)
3 Then (* serve para indicar qual comando é mais interno – está dentro – de
qual *)
4 begin
5 If (idade < 13)
6 Then
7 Write('Criança')
8 Else
9 If (idade < 18)
10 Then
11 Write('Adolescente')
12 Else
13 Write('Adulto');
14 Writeln(' com ', idade,' anos.');
15 end
16 Else
17 Writeln('Idade negativa? Não nasceu ainda?');
18 Writeln('Processando a altura:');
O Else é opcional mas se ele aparece, ele sempre se refere ao último If:
1 If ( (x MOD 2) = 0 ) 1 If ( (x MOD 2) = 0 )
2 Then 2 Then
3 If (x > 0) 3 begin
4 Then 4 If (x > 0)
5 Writeln('Par positivo') 5 Then
6 Else 6 Writeln('Par positivo');
7 Writeln('Ímpar'); 7 end
8 Else
se x for zero → Ímpar!!!
9 Writeln('Ímpar');
se x for zero → não imprime nada;
é par mas não positivo...
Exercício:
1.Faça um programa que, dado um número inteiro n, imprime “o número <valor de n> é
maior/menor/igual a zero” conforme o número for maior, menor ou igual a zero.
Refaça, agora em Pascal, o exercício 8 para fluxogramas ou Português estruturado da

página 10.
29
2.6.2 - Decisão Composta

O conjunto If-Else-If ocorre com tanta frequência que há uma construção específica
para programar esta decisão múltipla: Case. O Case testa se uma expressão casa com algum
dos valores constantes e desvia o fluxo do programa conforme o resultado.
Forma:
Case expressão Of
valor1 : comando1;
valor2 : comando2;
valor3 : comando3;
valorn : comandon;
Else : comando_caso_contrário; (* se não for nenhum dos anteriores *)
End
Exemplos:
1 ReadLn (mes);
2 ReadLn (ano);
3 Case mes Of
4 1, 3, 5, 7, 8, 10, 12 : dias := 31;
5 4, 6, 9, 11 : dias := 30;
6 2 : begin
7 if ( ( ((ano MOD 4) = 0) and ((ano MOD 100) <> 0)) or
8 ( ano MOD 400 = 0) )
9 Then
10 dias := 29
11 Else
12 dias := 28;
13 end;
14 end;
Exercício:
1.Faça um programa que lê dois números reais e depois um caractere. Conforme o
caractere for um símbolo de operação + , - , * ou / , escreve o resultado da operação –
soma, subtração, produto ou divisão, respectivamente – do primeiro valor lido pelo
segundo.
2.Faça um programa que simula um menu de operações. O programa lê um valor inteiro e
escreve a operação que ele realizaria. As operações são as seguintes:
1 – Listagem dos dados
2 – Inserção de dados
3 – Alteração de dados
4 – Exclusão de dados
5 – Relatório geral
6 – Sair do sistema
Caso seja entrado um valor diferente dos relacionados, o programa deve avisar com a
mensagem “Opção inválida. Escolha uma opção entre 1 e 6, inclusive”.
30
2.7 - Laços
Os laços são responsáveis pela interação de comandos dentro de um programa. São eles
que controlam quantas vezes, enquanto o que ou até quando os comandos ou blocos de
comandos serão executados. Assim, eles controlam as repetições e interações dentro de um
programa.
2.7.1 - For
O comando For controla as repetições que tenham um número fixo de vezes para
ocorrer. Definem que uma variável irá de um valor inicial até (inclusive) um valor final. Será
um laço crescente se o valor inicial for menor que o final (e for especificado que vai até – to –
valor final) ou decrescente se valor inicial for maior que final e for especificado que vai
diminuir até – downto – valor final.
Forma:
(* Crescente: valor_inicial  valor_final; caso contrário não entra no laço *)
For variável := valor_inicial To valor_final do
comando;
ou
(* Decrescente: valor_inicial  valor_final; caso contrário não entra no laço *)
For variável := valor_inicial DownTo valor_final do
comando;
Exemplos:
Código:
1 Program FormaMatriz;
2 VAR i, j, k : Integer;
3 BEGIN
4 For i := 1 to 4 do begin
5 For j := 1 to 6 do begin
6 If (i < j)
7 Then k := j – i
8 Else k := i – j;
9 Write(' (',i,',',j,') ',k);
10 end;
11 Writeln();
12 end;
13 END.
Saída:
(1,1) 0 (1,2) 1 (1,3) 2 (1,4) 3 (1,5) 4 (1,6) 5
(2,1) 1 (2,2) 0 (2,3) 1 (2,4) 2 (2,5) 3 (2,6) 4
(3,1) 2 (3,2) 1 (3,3) 0 (3,4) 1 (3,5) 2 (3,6) 3
(4,1) 3 (4,2) 2 (4,3) 1 (4,4) 0 (4,5) 1 (4,6) 2
31
Código: Saída:
Program DesenhoAsterisco; 22
Var i,j,tam,m, aux, posit : Integer; 5
BEGIN -5 *****#*****
ReadLn(tam); (* recomendado: 22 *) -4 ****###****
ReadLn(m); (* recomendado: 5 *) -3 ***#####***
posit := -1; -2 **#######**
For i := -m to m do begin -1 *#########*
aux := posit * i; 0 ###########
if (i = 0) 1 *#########*
Then 2 **#######**
posit := 1; 3 ***#####***
Write(i:2,' '); 4 ****###****
For j := 1 to aux do 5 *****#*****
Write('*');
For j := 1 to (tam DIV 2) - (2 * aux) do
Write('#');
For j := 1 to aux do
Write('*');
Writeln;
end;
END.
Código:
Program ForAninhado;
Var i, j, k, m, f : Integer;
BEGIN
For i := 1 to 3 do begin
f := 3;
Write(i:3, ' :');
For j := 1 to 4 do begin
Write(j:f,' (');
f := 8;
For k := 1 to 3 do begin
Write(k:2, ' <');
For m := 1 to 2 do
Write(m:2);
Write(' > ');
end;
WriteLn(') ');
end;
Writeln;
end;
END.
Saída: 1: 1(1<12> 2<12> 3<12> )

2(1<12> 2<12> 3<12> )
3(1<12> 2<12> 3<12> )
4(1<12> 2<12> 3<12> )
32
2: 1(1<12> 2<12> 3<12> )
2(1<12> 2<12> 3<12> )
3(1<12> 2<12> 3<12> )
4(1<12> 2<12> 3<12> )
3: 1(1<12> 2<12> 3<12> )

2(1<12> 2<12> 3<12> )
3(1<12> 2<12> 3<12> )
4(1<12> 2<12> 3<12> )
Exercícios:
1.Faça um programa que imprime a contagem regressiva de 1000 até 1 e depois imprime
“fogo!”.
2.Faça um programa em Pascal que crie uma escala de um termômetro. A escala impressa
vai de 0 até 100 em incrementos de 1°C. Ao lado de cada gradação em Celsius o
programa também imprime o valor correspondente em Fahrenheit, sendo que a conversão
é F = 9/5.C + 32.
3.Mostre a saída do seguinte trecho de código:

For i := 1 to 4 do begin
For j := i to i + 3 do
Write ( (i + j):3 );
Writeln;
end;
4.Faça um programa que calcula e imprime a soma dos múltiplos de 7 que estão entre 1 e
10000.
5.Faça um programa que lista todos as permutações possíveis de se sortear 'A', 'B' ou 'C'
quatro vezes (com reposição). A resposta seria algo como 'AAAA', 'AAAB', 'AAAC',
'AABA', ... , 'CCCC'.
6.Faça um programa que lê um valor inteiro n, (0 < n < 11) e imprime a tabuada de n.
7.Faça um programa que imprime todas as tabuadas: de 1 ao 10.
8.Faça um programa que lê um valor ímpar inteiro n, (2 < n < 20) e imprime as figuras a
seguir, com n caracteres de lado (os exemplos mostram n = 5):
a) b) c) d) e) f) g)
##### ### # # ##### # #
# # # # ## ## #### # ##
# # # # ### ### ### ##### # #
# # # # #### #### ## # ##
##### ### ##### ##### # # #
Observação: os itens c a g precisam de dois laços e g é particularmente complexo.
9.Faça um programa que imprime todas as equações de segundo grau a.x2 + b.x + c = 0
que têm uma ou duas raízes reais (não imprima as raízes, apenas as equações) para todos
os valores inteiros de a, b e c que estejam entre -3 e 3.
Exemplo: -3.x2 + -3.x + 0 = 0
-3.x2 + -3.x + 1 = 0
-3.x2 + -3.x + 2 = 0
...
Reparar que (a=-3, b=-3, c=-3 / c=-2 / c=-1) não foram impressas por não terem raízes reais!
Note ainda que não deve ser calculado para quando a = 0, pois a equação não é de 2o
33
grau!
10.Faça um programa que calcula quanto é o valor resultante quando são depositados
R$ 430,00 por 72 meses em uma poupança que rende 1% de juros ao mês.
Refaça os exercícios 9 em diante, agora em Pascal, para fluxogramas ou Português

estruturado da página 10.
34
2.7.2 - While
O comando While é bastante semelhante ao For. Ele mantém a interação enquanto a
condição for verdadeira e a verifica antes de começar o novo ciclo. A principal diferença entre
o While e o For é que o primeiro não sabe de antemão quantas vezes o processo vai se
repetir.
Forma:
While (expressão_lógica) do
comando;
Exemplos:
Código:
1 PROGRAM While_raiz;
2 VAR valor:Double;
3 cnt:Integer;
4 BEGIN
5 Readln(valor);
6 cnt := 1;
7 Write(valor:10:4);
8 While (valor > 1.5) do begin
9 valor := Sqrt(valor);
10 cnt := cnt + 1;
11 Write(valor:10:4);
12 end;
13 Writeln;
14 Writeln('Precisei tirar ',cnt,' raízes: ', valor:10:4);
15 END.
Saída:
100
100.0000 10.0000 3.1623 1.7783 1.3335
Precisei tirar 5 raízes: 1.3335
35
2.7.3 - Repeat Until

A dupla de comandos Repeat Until é bastante semelhante ao While. Eles marcam a
abrangência do laço que será executado até que (until) a condição seja verdadeira (mantém
executando enquanto for falsa). O Repeat Until é similar ao While no sentido em que não
se sabe de início quantas vezes vai ser executado porém, como o teste é feito no final do
laço, todos os comandos entre Repeat Until são executados (logo, pelo menos uma vez o
laço executa todos os comandos).
Forma:
Repeat
comando;
Until(expressão_lógica);
Exemplos:
Código:
1 PROGRAM Validar;
2 VAR custo, juros : Real;
3 nmes : Integer;
4 BEGIN
5 Repeat
6 Write('Entre com um custo (custo > 0): ');
7 Readln(custo);
8 Write('Entre com a taxa de juros (0 < juros < 3): ');
9 Readln(juros);
10 Write('Entre com a quantidade de meses (mês > 3): ');
11 Readln(nmes);
12 Until ( (custo > 0) and (juros > 0) and (juros < 3) and (nmes > 3) );
13 Writeln('Ok.');
14 Writeln('custo:',custo:10:2, 'juros:',juros:5:3,'meses:', nmes);
15 END.
Saída:
Entre com um custo (custo > 0): 5
Entre com a taxa de juros (0 < juros < 3): 5
Entre com a quantidade de meses (mês > 3): 5
Ok.
custo: 100.00 juros:1.000 meses:10
36
1 PROGRAM AcharRaiz;
2 VAR delta, x1, x2, xp, y1, y2, yp, xr, yr : Double;
3 int : Integer;
4 BEGIN
5 Write('Entre valor inicial inferior:');
6 Readln(x1);
7 Write('Entre valor inicial superior:');
8 Readln(x2);
9 Write('Entre precisão:');
10 Readln(delta);
11 int := 0;
12 Repeat
13 y1 := x1*x1*x1 - 12*x1*x1 + 47*x1 - 59.3; (* cálculo no ponto x1 *)
14 y2 := x2*x2*x2 - 12*x2*x2 + 47*x2 - 59.3; (* cálculo no ponto x2 *)
15 xp := (x1 + x2) / 2;
16 yp := xp*xp*xp - 12*xp*xp + 47*xp - 59.3;(* cálculo no ponto xp *)
17 int := int + 1;
18 Write(int:3,x1:15:10,'(',y1:12:9,')');
19 Write(xp:15:10,'(',yp:12:9,')',x2:15:10,'(',y2:12:9,')');
20 If ( (yp*y2) < 0 ) (*se o ponto médio e y2 tem sinais diferentes*)
21 Then begin (* então "encolha" puxando x1 *)
22 x1 := xp;
23 y1 := yp; Creator:KDE 4.4.5x²(KDE
f  x= x³−12 4.4.5)
47 x−59,3
24 end CreationDate:sex out 15 16:04:17 2010
25 Else begin(* senão puxando x2 *)
26 x2 := xp;
27 y2 := yp;
28 end;(* até que resposta < delta *)
29 Until( (Abs(yp) < delta) );
30 If ( Abs(y1) < Abs(y2) )
31 Then begin
32 xr := x1;
33 yr := y1;
34 end
35 Else begin
36 xr := x2;
37 yr := y2;
38 end;
39 Writeln('A raiz é ', xr:15:10,' (',Abs(yr):-12:10,' < ', delta:12:10,')');
40 END.
Entre valor inicial inferior:2.2

Entre valor inicial superior:6
Entre precisão:0.0001
1 2.2000000000(-3.332000000) 4.1000000000( 0.601000000) 6.0000000000( 6.700000000)
2 2.2000000000(-3.332000000) 3.1500000000( 0.935875000) 4.1000000000( 0.601000000)
3 2.2000000000(-3.332000000) 2.6750000000(-0.301203125) 3.1500000000( 0.935875000)
4 2.6750000000(-0.301203125) 2.9125000000( 0.501361328) 3.1500000000( 0.935875000)
5 2.6750000000(-0.301203125) 2.7937500000( 0.151109131) 2.9125000000( 0.501361328)
6 2.6750000000(-0.301203125) 2.7343750000(-0.061661530) 2.7937500000( 0.151109131)
7 2.7343750000(-0.061661530) 2.7640625000( 0.047991673) 2.7937500000( 0.151109131)
8 2.7343750000(-0.061661530) 2.7492187500(-0.006008149) 2.7640625000( 0.047991673)
9 2.7492187500(-0.006008149) 2.7566406250( 0.021197230) 2.7640625000( 0.047991673)
37
10 2.7492187500(-0.006008149) 2.7529296875( 0.007646061) 2.7566406250( 0.021197230)
11 2.7492187500(-0.006008149) 2.7510742188( 0.000831856) 2.7529296875( 0.007646061)
12 2.7492187500(-0.006008149) 2.7501464844(-0.002584919) 2.7510742188( 0.000831856)
13 2.7501464844(-0.002584919) 2.7506103516(-0.000875725) 2.7510742188( 0.000831856)
14 2.7506103516(-0.000875725) 2.7508422852(-0.000021733) 2.7510742188( 0.000831856)
A raiz encontrada é 2.7508422852 (0.0000217333 < 0.0001000000)
38
Exercício:
Vocês já estão capacitados para fazer em Pascal os exercícios feitos para Português
estruturado e fluxograma (todos os exercícios da página 10).
1.Faça um programa em Pascal que lê (e faz a validação) dos números reais
juros (0 < juros < 5),
depósito_inicial (depósito_inicial > 100),
depósito_mensal (depósito_mensal > 0),
número_de_meses (número_de_meses > 12)
e imprime o capital_final com o rendimento de juros, a partir de um depósito inicial e o
acréscimo de um depósito mensal ao fim do período de número de meses.
2.Altere o programa do Exercício 1 de modo que opere de modo inverso, ou seja, diga
quantos meses serão necessários para que a partir de um depósito_inicial e um
investimento de depósito_mensal todo mês, com um rendimento de juros mensal, seja
atingido um capital_final pré-definido.
3.“Corredor Cansado”:Faça um programa que conta quantos minutos são necessários para
um corredor correr 1000 metros sendo que, a cada minuto, o corredor cumpre metade
da distância que resta. Faça uma tabela imprimindo os minutos e a distância percorrida
até ali.
4.Faça um programa que joga contra um humano. O programa conta quantos palpites o
jogador precisou até adivinhar um número inteiro sorteado entre 1 e 1000, inclusive.
Cada vez que o jogador erra, o programa diz quantas tentativas já foram feitas e dá uma
dica. A dica informa se o número chutado é maior ou menor que o número sorteado. O
jogo vai estreitando o intervalo de números possíveis conforme as tentativas vão sendo
feitas. O programa ainda imprime uma avaliação do desempenho do jogador, segundo a
seguinte tabela: tentativas avaliação
1a5 excelente!
6 ou 7 bom
8 a 12 normal
13 ou 14 ruim
15 ou mais trágico
Um exemplo de execução pode ser visto a seguir:
Tentativa: 1. Entre um número maior que 0 e menor que 1001 : 150
Muito baixo.
Muito baixo.
Muito alto.
Muito alto.
Muito baixo.
Muito baixo.
Muito alto.
Muito baixo.
Você acertou o número 487 em 9 tentativas.
Você, como adivinhador, é normal
Observação: a função Random(x) em Pascal retorna um número aleatório entre 0 e (x-1),
39
inclusive. Assim, Random(20) retorna um valor no intervalo [0;19].
5.Faça um programa que sorteia 6000 lançamentos de um dado de seis faces e conta
quantas vezes saiu cada face. O programa então imprime um gráfico de barras lateral
com caracteres, onde cada símbolo # corresponde a 30 resultados. A saída seria algo
parecido com a figura a seguir:
1:########################
2:####################
3:#######################
4:#####################
5:##########################
6:#######################
6.fim
40
2.8 - Estruturas de Dados

Estruturas de dados é o recurso em computação para manipular dados. Vetores e
Matrizes são provavelmente as estruturas de dados mais utilizadas. Uma vez que todos os
elementos em vetores e matrizes são do mesmo tipo, diz-se que são estruturas homogêneas.
É necessário com frequência trabalhar com uma grande quantidade de variáveis do
mesmo tipo que representam a mesma coisa porém referem-se a elementos diferentes como,
por exemplo: altura dos alunos de uma classe, rendimento em km/l dos carros de uma frota,
consumo de água em cada um dos bairros de uma cidade etc. Como trataríamos os dados de
50 alunos? Utilizando 50 variáveis n1, n2, ... , n50 ? E se a classe passar para 100 alunos?
2.8.1 - Vetores
A solução é a utilização de uma estrutura de dados que permita referenciar todos os
dados de uma vez indicando cada um individualmente através de um índice. Assim
poderíamos falar da nota do 5º aluno por nota 5 ou, mais simplesmente, por nota[5]. Essa
estrutura é um vetor. A seguir vemos uma representação de um vetor de 50 notas:
[1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [49] [50]
notas 8.4 1.3 7.2 7.8 9.0 5.8 2.9 6.6 ? ? ? ? ?

Os vetores são definidos especificando quantos elementos ele vai armazenar através da
especificação “Array”:
Exemplo de utilização:
VAR notas : Array 50 of Real ;
consumo : Array 12 of Real ;
fez1prova : Array 50 of Boolean ;
Se a mesma estrutura for utilizada muitas vezes, pode ser simplificada e resumida
como um “tipo” criado:
CONST MAX_ALUNOS = 50 ;
TYPE DadosAlunos : Array MAX_ALUNOS of Real ;
VAR notas : DadosAlunos ;

alturas : DadosAlunos ;
medias_finais : DadosAlunos ;
Os valores para os índices também podem ter o intervalo definido:
VAR concentracao_sal : Array [-100..100] of Real ;

(* há 201 valores para a concentração de sal: de -100 até -1, zero, de 1 até 100 *)
(* assim podemos dizer concentracao_sal[-32] := -0.81222; por exemplo*)
Exemplos:
notas[1] := 6.7 ; (* a nota do primeiro aluno é 6,7 *)
altura[32] := 1.81 ; (* a altura do 32º aluno é 1,81 metros *)
medias_finais[51] := 9.2 ; (* ERRO! Pascal sabe que só há 50 alunos! *)
41
Exercício:
Vocês já estão capacitados para fazer em Pascal os exercícios feitos para Português
estruturado e fluxograma (todos os exercícios da página 10).
1.Faça um programa em Pascal que lê as notas de 30 alunos, calcula a média e imprime
as notas que estão acima da média.
2.Faça um programa que lê, identifica e imprime o valor máximo, o valor mínimo e a
média de um vetor de n posições de inteiros. O usuário entra com o valor de n (3  n 
100).
3.Faça um programa que lê um vetor de n ( 3  n  10) inteiros não negativos e subtrai, de
cada posição, o valor mínimo dos valores do vetor.
4.Faça um programa que normaliza os valores de um vetor de n dados. Normalizar um

vetor significa reduzir os valores do vetor ao intervalo [0;1] subtraindo de cada elemento
o menor (mínimo) deles e dividindo cada elemento pela diferença entre o maior
(máximo) do vetor e o menor (mínimo), ou seja:
elemento_normalizadoi = (elementoi – min_vetor)/(max_vetor – min_vetor).
Exemplos:
[ ]
[7.4, 9.1,5.5, 2.7, 1.3 ] → 7.4−1.3 , 9.1−1.3 , 5.5−1.3 , 2.7−1.3 , 1.3−1.3 , =[ 0.78, 1.0,0.54, 0.18, 0.0 ]
9.1−1.3 9.1−1.3 9.1−1.3 9.1−1.3 9.1−1.3
[3.1, 4.8, 8.3,−2.5 ]→ [ 3.1−(−2.5) 4.8−(−2.5) 8.3−(−2.5) −2.5−(−2.5)

, , ,
8.3−(−2.5) 8.3−(−2.5 ) 8.3−(−2.5) 8.3−(−2.5) ]
=[ 0.52,0.68,1.0 ,0.0 ] .
5.Faça um programa em Pascal que lê um número inteiro positivo n (3 < n < 201), lê n
dados em um vetor e obtém o vetor padronizado na curva normal Z. Para padronizar em
Z, cada elemento deve ser subtraído do valor da média e dividido pelo valor do desvio
padrão.
√
i=n i =n
∑ xi ∑ ( xi −média) ² Usar y = sqrt(x) para y= √x .
i=1
média= desvio= i=1
n n
dados (0 < dado) em um vetor e retira a raiz quadrada ( y = sqrt(x)) de cada dado até que
a soma dos valores do vetor seja menor que 2*n.
7.Faça um programa em Pascal que lê um número inteiro positivo

par n (0 < n < 21), lê n dados em um vetor x e depois resume o
vetor x em outro vetor y, no qual cada posição de y é a soma de
duas posições de x.
dados em um vetor, troca o valor da primeira posição com o valor da posição onde está
o menor dos valores (mínimo) e depois troca o valor da última posição com o valor da
posição onde está o maior dos valores (máximo).
Exemplo: n = 7
9.Faça um programa em Pascal que lê n valores reais (0 < n  100) e os imprime

42
ordenados.
10.Faça um programa que lê um vetor de n número reais ( n = 2k+1, 3 < k < 11) e processa
este vetor fazendo com que o conteúdo de cada posição par seja o resultado da soma do
valor nesta posição (par) mais o conteúdo das posições ímpares vizinhas.
11.Faça um programa em Pascal que lê oito valores que podem ser 0 ou 1 e imprime o
número na base dez correspondente àquele número de oito dígitos na base dois.
Exemplo:
001111012 = 0.27 + 0.26 + 1.25 + 1.24 + 1.23 + 1.22 + 0.21 + 1.20=
0.128 + 0.64 + 1.32+ 1.16 + 1.8 + 1.4 + 0.2 + 1.1 = 6110
Observações:
- não utilizar nenhuma função de potência;
- os “bits” devem ser armazenados em um vetor.
12.Faça um programa em Pascal que lê um número inteiro n (0 < n < 101, validar), lê n
valores em um vetor. O programa lê um número x ( -10 < x < 10, validar). Se x for
negativo, o programa cicla os dados do vetor para a esquerda (dado da posição i vai
parar na posição i-1; primeiro vai parar no último); se x for positivo, o programa cicla os
dados para a direita (dado da posição i vai parar na posição i+1; dado da última posição
– n – vai parar na primeira) e se for zero, o programa imprime o vetor e acaba.
43
2.8.2 - Matrizes
Assim como pode-se criar uma variável com várias posições, podemos também criar
uma estrutura em que cada uma destas posições também possa ter diversas posições, ou
seja, que cada posição de um vetor também seja um vetor. Nesse caso, chamamos o vetor de
vetores de matriz. A seguir temos uma representação de uma matriz:
turmas
[1] [2] [3] [4] [5] [6] [7] [8] [9] [10]
[1] 8.4 1.3 7.2 7.8 9.0 5.8 2.9 6.6 3.6 8.1
[1] [2] [3] [4] [5] [6] [7] [8] [9] [10]
[2] 5.3 9.8 2.9 1.1 8.9 8.6 6.8 4.9 7.7 2.5
[1] [2] [3] [4] [5] [6] [7] [8] [9] [10]
[3] 1.2 8.2 9.6 6.4 9.2 4.8 7.9 5.6 9.1 8.7
[1] [2] [3] [4] [5] [6] [7] [8] [9] [10]
[4] 6.0 7.3 8.9 1.8 3.5 7.8 6.9 6.1 8.8 7.1
Exemplo de utilização:
VAR turmas : Array 4 of Array of 10 of Real ;
(* 4 posições onde cada uma delas guarda 10 valores: matriz4,10 *)
(* o significado seria a nota de cada um dos 10 alunos para cada uma das 4 turmas*)
VAR turmas : Array [1..4,1..10] of Real ;

(* notação simplificada: só a lista das dimensões: 4 e 10*)
turmas[3,7] := 7.9;
(* na 3ª turma, a nota do 7º aluno é 7,9*)
Exemplo:
PROGRAM Medias;
CONST NUM_TURMAS = 4, NUM_ALUNOS = 10;
VAR turmas : Array [1..NUM_TURMAS,1..NUM_ALUNOS] of Real;
somaturma, somatotal : Real;
nturma, ntotal, i, j : Integer;
BEGIN
...
(* preenchimento da matriz...*)
...
somatotal := 0.0;
ntotal := NUM_TURMAS * NUM_ALUNOS;
For i := 1 to NUM_TURMAS do begin
somaturma := 0.0;
For j := 1 to NUM_ALUNOS do begin
somaturma := somaturma + turmas[i][j];
end;
somatotal = somatotal + somaturma;
Writeln('média turma ',i,': ',(somaturma / NUM_ALUNOS):4:1);
end;
Writeln('média total dos ',ntotal,' alunos : ',
(somatotal / ntotal):4:1);
END.
44
Exercícios:
1. Faça um programa que faz a soma C = A + B e imprime o valor de C, dado que A e B são
matrizes quadradas de 3 x 3.
2. Faça um programa em Pascal que lê um número inteiro positivos n (0 < n < 21) e cria
uma matriz identidade In x n . A matriz identidade é uma matriz onde: ai , j = 1, se i = j
ai , j = 0, se i ≠ j
3. Faça um programa que faz a soma C = A + B e imprime o valor de C, dado que A e B são
matrizes quadradas de n x n. Tanto n (3  n  10) quanto os valores de A e B são lidos do
teclado.
4. Faça um programa que soma duas matrizes n x m de dados de ponto flutuante. Os dados
das matrizes e os valores n (3  n  10) e m (3  m  10) devem ser lidos do teclado.
5. Faça um programa que codifica um tabuleiro de xadrez em
uma matriz de inteiros. Casas pretas desocupadas são
representadas como 1 e brancas como -1. Peças pretas são
positivas e brancas, negativas. As peças tem a seguinte
codificação: peões 2, cavalos 4, bispos 8, torres 16, rainhas 32
e reis 64.
6. Faça um programa em Pascal que lê um valor n (3 < n < 11), lê
os dados de uma matriz A n,n, lê um valor k (1 < k < n) e calcula
e imprime a soma dos elementos da sub-matriz constituída
pelas linhas que vão de k até n e das colunas que vão de k até
n, inclusive.
7. Faça um programa que lê uma matriz de números reais n x m (1 < n < 21, 1 < m < 21).
Depois lê dois valores a e b. Se a e b forem positivos então o programa troca o conteúdo
da linha a com o conteúdo da linha b, sendo que 1 < a  n e 1 < b  n. Se a e b forem
negativos, então o programa troca o conteúdo da coluna - a com o conteúdo da coluna - b,
sendo que 1 < -a  m e 1 < -b  m. Se a ou b forem zero ou tiverem sinais trocados, o
programa acaba.
8. Faça um programa que lê um vetor de n número reais (3 < n < 20) e constrói uma matriz
quadrada n x n onde as colunas da matriz são réplicas do vetor.
9. Faça um programa que lê um número inteiro positivo n (3 < n < 20) e preenche uma
matriz n x n de tal modo que as linhas ímpares sejam compostas
[ ]
dos valores de 1 até n (conteúdo das colunas) e as linhas pares, 1 1 1 1 1 1 1
compostas dos valores decrescentes de n até 1. 1 2 2 2 2 2 1
1 2 3 3 3 2 1
10. Faça um programa que lê um número inteiro impar positivo n A= 1 2 3 4 3 2 1
(2 < n < 22) e cria uma matriz de nível n x n na qual cada lateral 1 2 3 3 3 2 1
da matriz seja um nível – iniciando por 1 – acrescentando 1 até o 1 2 2 2 2 2 1
centro. Assim, para n = 7, a matriz seria como a matriz A, vista
1 1 1 1 1 1 1
ao lado.
11. Faça um programa em Pascal que lê um número n (3 < n < 9; n é
[ ]
1 2 3 4
par) e preenche a matriz A n,n com as linhas ímpares crescentes e as 8 7 6 5
linhas pares decrescentes. Exemplo: para n = 4, a matriz ficaria A=
9 10 11 12
como aquela representada na figura ao lado. 16 15 14 13
12. Faça um programa em Pascal que inicia com uma matriz A 8,8 com zero em todas
posições. O programa então lê dois valores: x e y. Se x ou y forem negativos, o programa
termina. Caso contrário, ele soma 8 ao conteúdo da posição x,y da matriz e subtrai 1 dos
seus vizinhos (desde que ainda estejam dentro do limite da matriz 8x8). Ao terminar, o
programa imprime a matriz.
45
13. Faça um programa em Pascal que lê um valor n (9 < n < 21, validar), lê os dados de uma
matriz An,n. O programa então lê um número x ( -101 < x < 101, validar). O programa
operará nas diagonais conforme o valor de x do seguinte modo:
par positivo soma 1 aos dados da diagonal principal;
par negativo soma 1 aos dados da diagonal secundária;
ímpar positivo subtrai 1 dos dados da diagonal principal;
ímpar negativa subtrai 1 dos dados da diagonal secundária;
zero imprime a matriz e termina o programa.
14. fim
46
Exercícios:
1. Faça um programa que lê e imprime uma cadeia de caracteres digitada de trás para frente.
Por exemplo, se for digitado AMOR deve imprimir ROMA.
2. Faça um programa que verifica se uma palavra ou número é palíndromo, isto é, se ela é
igual a ela mesma escrita de trás para frente.
3. Faça um programa que conta o número de vogais de uma frase.
4. Faça um programa que exclui todas vogais de uma frase.
47
2.9 - Procedimentos e Funções

É muito comum em programas determinadas operações mais complexas serem
necessárias mais de uma vez, em diversos pontos do programa. Para evitar repetição de
código, que aumenta o tamanho, a complexidade e a propensão a erros no programa, utiliza-
se do recurso de funções. Funções são sub-rotinas e podem ser chamadas de qualquer parte
do programa.
usar exemplo de fat / comb / prob
res = cos(p)*sin(q)/(sin(p+q) * cos(p+q));

return res;
}
48

Material LEA

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Material LEA

Enviado por

Direitos autorais:

Formatos disponíveis

Algoritmos IFSP prof. Claudio.

ALGORITMOS E LÓGICA DE PROGRAMAÇÃO

144 144 / 89 = 1,6179

233 233 / 144 = 1,6180

Cristóbal Vila – Nature by Numbers

1.2 - Linguagens e Programas

1.3 - Representação Numérica

1.3.1 - Mudanças de Base

1.4.1 - Descrição Narrativa

1.4.3 - Pseudo-código (Português estruturado ou Portugol)

1.4.4 - Relação entre Português Estruturado e Fluxograma

... Saída: Saída:

... Saída: Saída:

Observação:Utilize e função resto: y MOD x. A função resto devolve o resto de uma

14.Faça um algoritmo em Português estruturado que lê dois valores inteiros positivos a e b e

23.Execute o algoritmo abaixo (teste de mesa) e escreva no quadro qual a saída:

Faça o fluxograma ou o pseudo-código de um algoritmo que leia um número inteiro n

1.5 - Tipos de Dados

2.Crie os nomes das variáveis e os conteúdos para as diversas situações abaixo:

fonte: Programming Language Design Concepts de David A. Watt

A linguagem de programação Pascal foi construída de modo a favorecer a programação

d) Tabela Verdade para Operadores Lógicos

Exemplos de expressões e precedência:

verdadeiro se x é par e maior ou igual a zero ou x é ímpar e menor que zero:

verdadeiro se k não é nem múltiplo de 3 nem múltiplo de 7:

2.3 - Variáveis em Pascal

2.3.2 - Declaração de Variáveis

2.3.4 - Tipos Primitivos Padrão em Pascal

DIV → Divisão inteira:

peso := peso / 1000.0 ; (* passando de g para Kg *)

apt_votar := brasileiro and (idade >= 16);

2.4 - Entrada e Saída de Dados

2.4.1 - Entrada de Dados

2.4.2 - Saída de dados

Texto_e_Dados é uma lista de nenhum, um ou mais textos (e seus formatos opcionais

* Saída sem formato com nova linha *

* Saída com formato e nova linha *

2.5 - Comandos e Blocos

2.6.1 - Decisão Simples

O comando If supõem, como todos os comandos de Pascal, que será executado

Refaça, agora em Pascal, o exercício 8 para fluxogramas ou Português estruturado da

2.6.2 - Decisão Composta

Saída: 1: 1(1<12> 2<12> 3<12> )

3: 1(1<12> 2<12> 3<12> )

3.Mostre a saída do seguinte trecho de código:

Refaça os exercícios 9 em diante, agora em Pascal, para fluxogramas ou Português

2.7.3 - Repeat Until

Entre valor inicial inferior:2.2

A raiz encontrada é 2.7508422852 (0.0000217333 < 0.0001000000)

Observação: a função Random(x) em Pascal retorna um número aleatório entre 0 e (x-1),

inclusive. Assim, Random(20) retorna um valor no intervalo [0;19].

2.8 - Estruturas de Dados

notas 8.4 1.3 7.2 7.8 9.0 5.8 2.9 6.6 ? ? ? ? ?

TYPE DadosAlunos : Array MAX_ALUNOS of Real ;

VAR notas : DadosAlunos ;

VAR concentracao_sal : Array [-100..100] of Real ;

4.Faça um programa que normaliza os valores de um vetor de n dados. Normalizar um

[3.1, 4.8, 8.3,−2.5 ]→ [ 3.1−(−2.5) 4.8−(−2.5) 8.3−(−2.5) −2.5−(−2.5)

7.Faça um programa em Pascal que lê um número inteiro positivo

9.Faça um programa em Pascal que lê n valores reais (0 < n  100) e os imprime

VAR turmas : Array [1..4,1..10] of Real ;

11. Faça um programa em Pascal que lê um número n (3 < n < 9; n é

2.9 - Procedimentos e Funções

res = cos(p)sin(q)/(sin(p+q) cos(p+q));