Material_LEA

Prévia do material em texto

Algoritmos IFSP prof. Claudio.
AALGORITMOSLGORITMOS EE L LÓGICAÓGICA DEDE P PROGRAMAÇÃOROGRAMAÇÃO
1
b
a
= a
(a+ b)
=φ=1,61803...
Prof. Cláudio
IFSP
Cristóbal Vila – Nature by Numbers
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
... ... ...
Algoritmos IFSP prof. Claudio.
Í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
Algoritmos IFSP prof. Claudio.
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
Algoritmos IFSP prof. Claudio.
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 = 27210
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 7508210, por exemplo, pode ser descrito como 
7.10000 + 5.1000 + 0.100 + 8.10 + 2.1 = 7.104 + 5.103 + 0.102 + 8.101 + 2.100 .
Seguindo a mesma lógica:1001111012 =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 base10:
a)10112 b)1001012 c)11101012
d)108 e)1318 f)10148
g)FF16 h)100016 i)ABCD16
2.Converta cada número abaixo da base10 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
Algoritmos IFSP prof. Claudio.
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 é 
uma receita culinária (veja Quadro 1.1): cada 
passo deve ser detalhado e executado em 
sequência para se atingir o resultado final 
desejado. 
Ao descrever um algoritmo devemos definir 
as ações de modo claro e específico. Partimos de 
um estado inicial e, após um período de tempo 
previsto, chegamos a um resultado previsto e 
definido.
Um algoritmo estabelece uma norma de 
execução e um final previsto que sempre será 
alcançado se o mesmo algoritmo for executado 
novamente.
Um exemplo seria a definição de como 
desenhar um quadrado. Podemos dizer que, para 
desenhar um quadrado, podemos fazer quatro 
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):
5
BISCOITOS DE NOZES 
Ingredientes:
• 1 xícara de manteiga ou margarina
• 1/2 xícara açúcar de confeiteiro
• 1 colher (chá) baunilha
• 2 1/4 xícaras de farinha de trigo
• 1 pitada de sal
• 3/4 xícara de nozes bem picadas
• Açúcar de confeiteiro para enfeitar
Preparo:
1 – Misture bem a manteiga e o açúcar. 2 – Junte a 
baunilha e a farinha peneirada com o sal. 3 – Misture 
novamente. 4 – Adicione as nozes e leve a massa à 
geladeira por uns 15 minutos. 5 – Aqueça o forno em 
temperatura média (200 graus). 6 – Faça bolinhas de 
2 cm de diâmetro e 7 – coloque numa assadeira sem 
untar. 8 – Leve para assar por uns 10 a 12 minutos. 
9 – Passe no açúcar de confeiteiro enquanto estão 
mornos.
Quadro 1.1: Exemplo de Algoritmo
4 3 2 1 0
Algoritmos IFSP prof. Claudio.
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
Algoritmos IFSP prof. Claudio.
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
Escreva numero, “ ao quadrado é “, numero * numero
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
Escreva numero, “ ao quadrado é “, numero * numero
numero  numero – 1
Enquanto (numero > 0)
Escreva “Acabei!”
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
Escreva numero, “ ao quadrado é “, numero * numero
Fim_Faça
Escreva “Acabei!”
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
Algoritmos IFSP prof. Claudio.
13 Fim_Se
Não é obrigatório ter senão.
1.4.4 - Relação entre Português Estruturado e Fluxograma
a) Enquanto
b) Repetir
c) Faça
8
Saída:
4 ↵
4
3
2
1
...
Leia x
Enquanto (x > 0) faça
Escreva x
x  x – 1
Fim_Enquanto
...
Saída:
4 ↵
4
3
2
1
...
Leia x
Repetir
Escreva x
x  x – 1
Enquanto (x > 0)
...
Saída:
-2 ↵
Saída:
-2 ↵
-2
Saída:
4 ↵
4
4
4
4
...
Leia x
Faça i  1 até x
Escreva x
Fim_Faça
...
Saída:
-2 ↵
Algoritmos IFSP prof. Claudio.
9
Algoritmos IFSP prof. Claudio.
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 2o grau a.x2 + b.x + c = 0 é dada pela 
fórmula x=−b±b
2−4.a.c
2.a , apresente um fluxograma ou o pseudo-código de um 
algoritmo que, utilizando a fórmula, resolva uma equação de 2o 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.
13.Escreva o algoritmo em Português estruturado ou em fluxograma que leia um valor x 
inteiro positivo e imprime o maior divisor de x que é menor que x.
10
Algoritmos IFSP prof. Claudio.
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!
18.Escreva o algoritmo em Português estruturado ou em fluxograma que leia um valor x 
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 
o fluxograma que imprime o valor da soma S=12
3
4
5
6
...
 x−1
x . 
Exemplo: se x = 8 então S=1
2
3
4
5
6
 7
8
=2,958333333 .
21.Dado um número inteiro positivo x, escreva o algoritmo em Português estruturado que 
imprime o valor da soma S=1
1
−1
2
1
3
−1
4
1
5
−...−1
2.i−1
x
. Observe a troca de sinais.
Exemplo: se x = 6 então S=11−
1
2
1
3
−1
4
1
5
−1
6
=0,616666667 .
22.Dado um número inteiro positivo par x, escreva o algoritmo em Português estruturado 
que imprime o valor da soma S= 101
2
12 
 3
23 
... x
 x−1x  . 
Exemplo: se x = 5 então S= 101
2
12 
 3
23 
 4
34 
 5
45 
=3,393650794
11
Algoritmos IFSP prof. Claudio.
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
 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
Quadro de Respostas
Algoritmos IFSP prof. Claudio.
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
Algoritmos IFSP prof. Claudio.
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
Algoritmos IFSP prof. Claudio.
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:
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
fonte: Programming Language Design Concepts de David A. Watt
Algoritmos IFSP prof. Claudio.
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
Operador Ação
Número de 
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.)
Operador Ação
> maior que
>= maior ou igual a ()
< menor que
<= menor ou igual a ()
= igual a
<> diferente de (≠)
c) Lógicos
Operador Ação Número de 
operandos
and e (∧) dois
or ou (∨) dois
not não (¬) um
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
Algoritmos IFSP prof. Claudio.
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:
17
((ano MOD 4 = 0) and (ano MOD 100 <> 0)) or (ano MOD 400 = 0)
2028 é bissexto!
=
00
V
28 280 0
<>
V
=
F
and
V
or
V
Algoritmos IFSP prof. Claudio.
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
Algoritmos IFSP prof. Claudio.
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
Algoritmos IFSP prof. Claudio.
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
Algoritmos IFSP prof. Claudio.
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
Algoritmos IFSP prof. Claudio.
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
Algoritmos IFSP prof. Claudio.
23
Algoritmos IFSP prof. Claudio.
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
Algoritmos IFSP prof. Claudio.
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
Algoritmos IFSP prof. Claudio.
Exemplos:
Saída:
26
 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.
Algoritmos IFSP prof. Claudio.
27
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.37R$ 214.37
Algoritmos IFSP prof. Claudio.
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
Algoritmos IFSP prof. Claudio.
 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:
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
 1 If ( (x MOD 2) = 0 )
 2 Then
 3 If (x > 0)
 4 Then
 5 Writeln('Par positivo')
 6 Else
 7 Writeln('Ímpar');
se x for zero → Ímpar!!!
 1 If ( (x MOD 2) = 0 )
 2 Then
 3 begin
 4 If (x > 0)
 5 Then
 6 Writeln('Par positivo');
 7 end
 8 Else
 9 Writeln('Ímpar');
se x for zero → não imprime nada;
é par mas não positivo...
Algoritmos IFSP prof. Claudio.
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
Algoritmos IFSP prof. Claudio.
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
Algoritmos IFSP prof. Claudio.
Código:
Program DesenhoAsterisco;
Var i,j,tam,m, aux, posit : Integer;
BEGIN
 ReadLn(tam); (* recomendado: 22 *)
 ReadLn(m); (* recomendado: 5 *)
 posit := -1;
 For i := -m to m do begin
 aux := posit * i;
 if (i = 0)
 Then
posit := 1;
 Write(i:2,' ');
 For j := 1 to aux do 
 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 < 1 2 > 2 < 1 2 > 3 < 1 2 > ) 
 2 ( 1 < 1 2 > 2 < 1 2 > 3 < 1 2 > ) 
 3 ( 1 < 1 2 > 2 < 1 2 > 3 < 1 2 > ) 
 4 ( 1 < 1 2 > 2 < 1 2 > 3 < 1 2 > ) 
32
Saída:
 22
 5
 -5 *****#*****
 -4 ****###****
 -3 ***#####***
 -2 **#######**
 -1 *#########*
 0 ###########
 1 *#########*
 2 **#######**
 3 ***#####***
 4 ****###****
 5 *****#*****
Algoritmos IFSP prof. Claudio.
 2 : 1 ( 1 < 1 2 > 2 < 1 2 > 3 < 1 2 > ) 
 2 ( 1 < 1 2 > 2 < 1 2 > 3 < 1 2 > ) 
 3 ( 1 < 1 2 > 2 < 1 2 > 3 < 1 2 > ) 
 4 ( 1 < 1 2 > 2 < 1 2 > 3 < 1 2 > ) 
 3 : 1 ( 1 < 1 2 > 2 < 1 2 > 3 < 1 2 > ) 
 2 ( 1 < 1 2 > 2 < 1 2 > 3 < 1 2 > ) 
 3 ( 1 < 1 2 > 2 < 1 2 > 3 < 1 2 > ) 
 4 ( 1 < 1 2 > 2 < 1 2 > 3 < 1 2 > ) 
Exercícios:
1.Faça um programa que imprime a contagem regressivade 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):
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
a)
 #####
 # #
 # #
 # #
 #####
e)
 #####
 ####
 ###
 ##
 #
c)
 #
 ##
 ###
 ####
 #####
d)
 #
 ##
 ###
 ####
 #####
f)
 #
 #
 #####
 # 
 #
b)
 ###
 # #
 # #
 # #
 ### 
g)
 #
 # #
 # #
 # #
 #
Algoritmos IFSP prof. Claudio.
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
Algoritmos IFSP prof. Claudio.
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
Algoritmos IFSP prof. Claudio.
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
Entre com um custo (custo > 0): 100
Entre com a taxa de juros (0 < juros < 3): 1
Entre com a quantidade de meses (mês > 3): 1
Entre com um custo (custo > 0): 100
Entre com a taxa de juros (0 < juros < 3): 1
Entre com a quantidade de meses (mês > 3): 10
Ok.
custo: 100.00 juros:1.000 meses:10
36
Algoritmos IFSP prof. Claudio.
 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;
24 end
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
 Creator:KDE 4.4.5 (KDE 4.4.5)
 CreationDate:sex out 15 16:04:17 2010
f  x=x³−12 x²47 x−59,3 
Algoritmos IFSP prof. Claudio.
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
Algoritmos IFSP prof. Claudio.
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: 
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.
Tentativa: 2. Entre um número maior que 150 e menor que 1001 : 400
Muito baixo.
Tentativa: 3. Entre um número maior que 400 e menor que 1001 : 600
Muito alto.
Tentativa: 4. Entre um número maior que 400 e menor que 600 : 500
Muito alto.
Tentativa: 5. Entre um número maior que 400 e menor que 500 : 430
Muito baixo.
Tentativa: 6. Entre um número maior que 430 e menor que 500 : 480
Muito baixo.
Tentativa: 7. Entre um número maior que 480 e menor que 500 : 490
Muito alto.
Tentativa: 8. Entre um número maior que 480 e menor que 490 : 486
Muito baixo.
Tentativa: 9. Entre um número maior que 486 e menor que 490 : 487
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
tentativas avaliação
1 a 5 excelente!
6 ou 7 bom
8 a 12 normal
13 ou 14 ruim
15 ou mais trágico
Algoritmos IFSP prof. Claudio.
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
Algoritmos IFSP prof. Claudio.
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 nota5 ou, mais simplesmente, por nota[5]. Essa 
estrutura é um vetor. A seguir vemos uma representação de um vetor de 50 notas:
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
[1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [49] [50]
1.3 ? ? ? ? ?notas 8.4 7.2 7.8 9.0 5.8 2.9 6.6
Algoritmos IFSP prof. Claudio.
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.39.1−1.3 , 9.1−1.39.1−1.3 , 5.5−1.39.1−1.3 , 2.7−1.39.1−1.3 , 1.3−1.39.1−1.3 ,]=[0.78,1.0,0.54,0.18,0.0 ]
[3.1, 4.8, 8.3,−2.5 ]→[3.1−(−2.5)8.3−(−2.5) , 4.8−(−2.5)8.3−(−2.5 ) , 8.3−(−2.5)8.3−(−2.5) ,−2.5−(−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.
Usar y = sqrt(x) para .
6.Faça um programa em Pascal que lê um número inteiro positivo n (0 < n < 21), lê 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.
8.Faça um programa em Pascal que lê um número inteiro positivo n (0 < n < 21), lê n 
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
média=
∑
i=1
i=n
x i
n desvio=√∑i=1
i=n
(xi−média) ²
n
y=√x
Algoritmos IFSP prof. Claudio.
ordenados. 
10.Faça um programa que lê umvetor 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
Algoritmos IFSP prof. Claudio.
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:
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
[1]
turmas
[2]
[3]
[4]
[1] [2] [3] [4] [5] [6] [7] [8] [9] [10]
1.38.4 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]
9.85.3 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]
8.21.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]
7.36.0 8.9 1.8 3.5 7.8 6.9 6.1 8.8 7.1
Algoritmos IFSP prof. Claudio.
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 An,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, 
compostas dos valores decrescentes de n até 1.
10. Faça um programa que lê um número inteiro impar positivo n 
(2 < n < 22) e cria uma matriz de nível n x n na qual cada lateral 
da matriz seja um nível – iniciando por 1 – acrescentando 1 até o 
centro. Assim, para n = 7, a matriz seria como a matriz A, vista 
ao lado.
11. Faça um programa em Pascal que lê um número n (3 < n < 9; n é 
par) e preenche a matriz An,n com as linhas ímpares crescentes e as 
linhas pares decrescentes. Exemplo: para n = 4, a matriz ficaria 
como aquela representada na figura ao lado.
12. Faça um programa em Pascal que inicia com uma matriz A8,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
A=[
1 1 1 1 1 1 1
1 2 2 2 2 2 1
1 2 3 3 3 2 1
1 2 3 4 3 2 1
1 2 3 3 3 2 1
1 2 2 2 2 2 1
1 1 1 1 1 1 1
]
A=[ 1 2 3 48 7 6 59 10 11 12
16 15 14 13
]
Algoritmos IFSP prof. Claudio.
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
Algoritmos IFSP prof. Claudio.
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
Algoritmos IFSP prof. Claudio.
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
	1 - Programação
	1.1- Conceitos
	1.2 - Linguagens e Programas
	1.3 - Representação Numérica
	1.3.1 - Mudanças de Base
	1.4 - Algoritmos
	1.4.1 - Descrição Narrativa
	1.4.2 - Fluxograma
	1.4.3 - Pseudo-código (Português estruturado ou Portugol)
	1.4.4 - Relação entre Português Estruturado e Fluxograma
	a) Enquanto
	b) Repetir
	c) Faça
	1.5 - Tipos de Dados
	1.5.1 - Variáveis
	a) Numéricas
	b) Alfa-numéricas
	c) Lógicas ou Booleanas
	1.5.2 - Constantes
	2 - Linguagem Pascal
	2.1 - Introdução
	2.2 - Operações
	a) Aritméticas
	b) Relacionais (sempre DOIS oper.)
	c) Lógicos
	d) Tabela Verdade para Operadores Lógicos
	e) Precedência
	2.3 - Variáveis em Pascal
	2.3.1 - Constantes
	2.3.2 - Declaração de Variáveis
	2.3.3 - Enumeração
	2.3.4 - Tipos Primitivos Padrão em Pascal
	a) Inteiros
	b) Real
	c) Double
	d) Boolean
	e) Char
	2.4 - Entrada e Saída de Dados
	2.4.1 - Entrada de Dados
	a) Read / ReadLn
	2.4.2 - Saída de dados
	a) Write / WriteLn
	2.5 - Comandos e Blocos
	2.6 - Decisão
	2.6.1 - Decisão Simples
	2.6.2 - Decisão Composta
	2.7 - Laços
	2.7.1 - For
	2.7.2 - While
	2.7.3 - Repeat Until
	2.8 - Estruturas de Dados
	2.8.1 - Vetores
	2.8.2 - Matrizes
	2.9 - Procedimentos e Funções