Beruflich Dokumente
Kultur Dokumente
1. CONCEITOS BÁSICOS:............................................................................................................4
1.1 Virtudes de um bom algoritmo:.............................................................................................9
1.2 TIPOS DE DADOS:..............................................................................................................9
1.2.1 - C O N S T A N T E: .................................................................................................9
1.2.2 - V A R I Á V E L: ......................................................................................................9
1.3 FORMAÇÃO DE IDENTIFICADORES: ...........................................................................9
1.4 TIPOS PRIMITIVOS:.........................................................................................................11
1.4.1 - INTEIRO:..................................................................................................................11
1.4.2 - REAL:.......................................................................................................................11
1.4.3 - CARACTER:............................................................................................................11
1.4.4 - LÓGICO:...................................................................................................................12
1.6 COMENTÁRIOS:...............................................................................................................12
1.7 EXPRESSÕES ARITMÉTICAS:....................................................................................13
1.7.1 OPERADORES ARITMÉTICOS:..............................................................................13
1.8 FUNÇÕES MATEMÁTICAS:............................................................................................13
1.9 PRIORIDADES:.................................................................................................................14
1.10 - EXPRESSÕES LÓGICAS :...........................................................................................14
1.11 - RELAÇÃO: ...................................................................................................................15
1.11.1 - OPERADORES RELACIONAIS SÍMBOLO......................................................15
1.11.2 - OPERADORES LÓGICOS...................................................................................15
1.12 TABELA VERDADE:.....................................................................................................16
1.12.1 - Prioridades entre os operadores lógicos:.................................................................16
1.13 PRIORIDADE Entre todos os operadores.......................................................................16
1.14 COMANDO DE ATRIBUIÇÃO:.....................................................................................17
2. COMANDOS DE ENTRADA E SAÍDA:................................................................................18
2.1 ENTRADA DE DADOS...................................................................................................18
2.2 SAÍDA DE DADOS...........................................................................................................18
3. ESTRUTURA DO ALGORITMO: ..........................................................................................19
3.1 ESTRUTURA SEQÜENCIAL:..........................................................................................19
3.1.1 - BLOCOS: Tem a finalidade de definir os limites do algoritmo...............................19
4. COMANDOS:...........................................................................................................................21
4.1 COMANDOS DE SELEÇÃO IF:......................................................................................21
4.1.1 - SELEÇÃO SIMPLES:.............................................................................................21
4.1.2 - SELEÇÃO COMPOSTA: .........................................................................................22
4.1.3 - SELEÇÃO ENCADEADA:......................................................................................23
4.1.4 - SELEÇÃO DE MÚLTIPLA ESCOLHA:..............................................................27
4.2 COMANDOS DE REPETIÇÃO:......................................................................................29
4.2.1 - REPETIÇÃO COM VARIÁVEL DE CONTROLE (PARA):................................29
4.2.2 - REPETIÇÃO COM TESTE NO INÍCIO (ENQUANTO):....................................31
4.2.3 - REPETIÇÃO COM TESTE NO FINAL (REPITA):.............................................32
5. VETORES................................................................................................................................43
5.1 PESQUISA BINÁRIA.......................................................................................................53
6. MODULARIZAÇÃO DE ALGORITMOS: ..........................................................................54
6.1 SUBALGORITMOS: ........................................................................................................54
6.2 ESCOPO DE VARIÁVEIS...............................................................................................55
6.3 MANIPULAÇÃO DE MÓDULOS....................................................................................56
6.4 Subalgoritmos com parâmetros..........................................................................................56
6.4.1 - PASSAGEM DE PARÂMETROS POR VALOR....................................................56
6.4.2 - PASSAGEM DE PARÂMETROS POR REFERÊNCIA..........................................57
7. M A T R I Z E S:.......................................................................................................................57
8. LISTA DE EXERCÍCIOS:.....................................................................................................65
2
APÊNDICE A - Editor Pascal.......................................................................................................68
APÊNDICE B - Comandos Básicos..............................................................................................74
BIBLIOGRAFIA : ........................................................................................................................75
......................................................................................................................................................75
3
1. CONCEITOS BÁSICOS:
A lógica moderna deve-se, em grande parte, ao alemão Gottlob Frege no século XIX.
Sabe-se que a lógica teve sua maior desenvoltura na Filosofia, caminhando pela
Lingüística, Matemática e Ciência da Computação.
Segundo John Nolt (et al., 1991), "A lógica pode ser estudada de dois pontos de vista: a
formal e a informal. Lógica formal é o estudo das formas de argumento, modelos abstratos
comuns a muitos argumentos distintos. Lógica informal é o estudo de argumentos particulares
em linguagem natural e do contexto no qual eles ocorrem." Cabe aqui ressaltar que os dois
aproches não são opostos, mas se complementam.
Um outro conceito seria: a ciência das leis ideais do pensamento e a arte de aplicá-los
corretamente no processo de investigação e demonstração da verdade.
No nosso dia a dia nos deparamos com vários problemas, nos quais, usamos a "lógica" de
forma "consciente" para resolvê-los, isto é, um raciocínio detalhista, minucioso, com bastante
clareza, ou, raciocinamos de forma lógica sem tomarmos conhecimento, intuitivamente. Para
que fique claro, vamos criar uma situação !!!
Você está viajando e fura um pneu de seu carro. Encosta-o e para. Será que você é capaz
de descrever todos os passos desde a parada do carro até o pneu trocado?
Dê um tempo! Tente ... pegue uma folha e descreva passo a passo ... depois prossiga a
leitura.
Se você tentou, agora responda algumas perguntas:
Você desligou o carro?
Você ligou o alerta?
Você tirou o sinto de segurança?
Você abriu a porta do carro?
Você puxou o freio de mão?
Você levou a chave para abrir o porta-malas?
Você verificou se o socorro estava cheio?
Teríamos N detalhes que muitas vezes fizemos intuitivamente e não nos preocupamos
com isso, no entanto, quando os descrevemos chegamos a esquecer muitos deles. A lógica seria
a seqüência detalhada e clara do fato.
4
Quando alguém pergunta qual é a soma de 20 + 30, o resultado multiplicado por 4 e este
resultado dividido por dois, você faz
os cálculos "de cabeça", no entanto você geralmente segue um raciocínio, uma lógica,
como:
- Primeiro, obter o resultado da soma (20+30=50) que chamaremos de resultado 1.
- Segundo, pegar o resultado 1 que é 50 e multiplica por 4 (50*4=200) assim,
chamaremos este de resultado 2.
- Terceiro, pegar o resultado 2 que é 200 e dividir por 2 (200/2=100) que chamaremos
de resultado 3.
- Quarto, responder o resultado 3 para quem o perguntou, que neste caso é 100.
Talvez você nunca tivesse pensado que ao realizar alguma tarefa usasse tanta lógica, isto
é, seguisse tantos passos. Portanto, é a lógica que já está em você que pretendemos despertar,
levando você a um raciocínio lógico.
Existe um rio a ser atravessado por três pessoas que pesam 50, 50 e 100 Kg. Para
atravessar este rio, as três pessoas dispõe de uma canoa que leva no máximo 100 Kg por viagem.
Esta canoa tem que ser conduzida, isto é, ela não anda sozinha. Heis a questão, como estas
pessoas chegam no outro lado da margem? É um problema com resolução simples. Um dos
passos a serem seguidos poderia ser:
Depois de resolver este problema ou alguém lhe mostrar a solução, você é capaz de
resolver problemas semelhante a este ou outros do gênero e até mais complexos.
Esta é uma forma de "despertar" o Raciocínio Lógico. É impossível alguém lhe ensinar a
lógica, pois ela já está em você, o máximo que se pode fazer é torná-la consciente e mais
aprimorada.
Para comprovar tal raciocínio tente resolver um dos mais famosos casos de resolução de
problema baseando-se no exemplo anterior. Os três missionários e os três canibais. O problema
tem o seguinte enunciado:
5
- O barco suporta no máximo duas pessoas por viagem.
Certamente, com este exemplo que parece mais uma brincadeira, o que queremos mostrar
que é possível despertar lógica através de exemplos. Quanto aos exemplos acima, quem resolveu
o primeiro, ou mesmo, quem foi direto a solução já tinha um ponto de partida para resolução do
segundo, com maior chances de chegar a um resultado do que aquela pessoa que nunca se
deparou com tal problema.
Assim, como você seguiu uma lógica para resolver o exemplo dos missionários e
canibais, terá que seguir a mesma seqüência nos problemas oferecidos, só que voltada para o
computador, obedecendo regras de uma determinada linguagem especial que vamos criar no
decorrer da disciplina
Para que você entenda, o melhor exemplo de algoritmo é uma receita de bolo, porque ali
são descritos todos os passos para a construção de um bolo numa seqüência lógica. Você não vai
por o bolo no forno sem antes tê-lo feito. Você não vai colocar os ovos com casca, antes você
vai quebra-los. Todos estes detalhes, quem está fazendo o bolo deve conhecer, para isso, ele
segue uma seqüência de passos lógicos que é a receita (algoritmo).
Numa máquina de lavar roupas existe um algoritmo o qual deve ser seguido, nele o
fabricante explica passo a passo o que a dona de casa tem que fazer para ligar a máquina.
Quando você compra um vídeo cassete vem um manual explicação, passo a passo
(algoritmo), o que você deve fazer, exemplo, para instalar o vídeo.
Em outras palavras o que vamos fazer é descrever passo a passo um problema para que o
computador possa resolver. Exemplo, se pedíssemos para alguém descrever os passos de como
se acha a média de três números quaisquer teríamos:
- informar os valores
- somar estes números
- dividir por três
- apresentar o resultado
LINGUAGEM:
Talvez você já tenha percebido que, linguagem é vocabulário, palavreado, usados como
meio de expressão e de comunicação entre as pessoas.
Certamente você já estudou português, porém nunca tenha percebido as inúmeras regras
que uma linguagem possui. Pois é, o computador tem suas linguagens, isto mesmo, ele é
"poliglota" !!!
Não corra!!!, tenho certeza que é mais fácil aprender n linguagens de um computador do
6
que aprender a Língua Portuguesa.
O primeiro passo é aprender lógica, isto é, aprender a lógica computacional, depois
adaptá-la numa linguagem que o computador entenda.
O que é Sintaxe?
Segundo o dicionário Aurélio: "Sintaxe é a parte da gramática que estuda a disposição
das palavras na frase e a das frases no discurso."
Exemplos:
Se você escrever a palavra "escreva" sem a letra "r" (esceva), numa frase, certamente este
é um erro sintático.
Se você escreve a seguinte frase "Thamna tem olhos azuis", a frase está sintaticamente
courela, porém se você mudar a disposição das palavras na frase ela terá erro sintático, assim:
"Thamna azuis tem olhos". Note: não estamos preocupados como entendimento (semântica) da
frase, ou se ela faz sentido, mas com o erro sintático.
Vamos supor que você escreveu a seguinte frase: "Thamna é loira, pele clara, olhos
azuis,
ela é linda", no entanto muda-se para o seguinte: "Thamna é linda, tem olhos azuis, pele clara e é
loira". Note que nas duas frases pode se entender a mesma coisa,no entanto, a disposição das
palavras está errada, isto significa um erro sintático, caso a seqüência tenha que ser obrigatória.
O que é Semântica?
Segundo o dicionário Aurélio: "Semântica é o estudo das mudanças ou translações
sofridas, no tempo e no espaço, pela significação das palavras."
Pois é, a palavra "manga" tem um duplo significado, pode ser uma fruta ou a parte de
uma camisa. Esta é uma palavra que causa duplo entendimento.
Na frase: "Tharnier é um cara de pau", poderíamos entender que Tharnier é um cínico ou
é muito extrovertido.
Veja:
Thamna tem 2 anos
Tharnier tem 6 anos
Thessaly tem 7 anos
Se afirmo: Thessaly é mais velha que Tharnier
Tharnier é mais velho que Thamna
O que é Verbo?
Segundo o dicionário Aurélio: "palavra que designa ação, estado, qualidade ou \
existência."
Por exemplo se alguém chegar para você e disser "escreva", obviamente você lhe
perguntaria: o que escrever? (ação a tomar).
7
Nas linguagens de computador existem verbos, ou em outras palavras, ações que você
manda ele executar, como: Leia do disco ou teclado, Escreva na tela ou impressora ...
Na nossa linguagem temos como símbolos as letras (A a ...Z z), os números (0 ... 9) bem
como os demais símbolos do teclado como @, # ^& * + = e outro>. Na linguagem de
computador teremos também os símbolos a serem usados. Os símbolos tem suas funções de
acordo com a linguagem usada. Estes símbolos são os encontrados no teclado.
Linguagem Natural
É o uso da palavra como meio de expressão e de comunicação entre pessoas, é, a língua
que se usa para comunicação.
Não temos como meta atender esta ou aquela linguagem, e sim a lógica. Mostraremos os
recursos mais comuns que encontramos nas diversas linguagens de computador.
Assim, nossa linguagem terá algumas regras como veremos a seguir e chamaremos de
Pseudo-linguagem, uma linguagem não executável (aceitável) pelo computador.
OUTROS CONCEITOS:
Programa Fonte: depois de feito o algoritmo você o "traduz" para uma linguagem que o
computador entenda, em qualquer linguagem como: Delphi, C++, Clipper etc.
Feito esta passagem não se chamará mais de Algoritmo e sim de Programa (Programa
Fonte).
Definindo Programa Fonte: é uma seqüência finita de passos lógicos escritos numa
determinada linguagem que o computador entenda.
Compilação: o passo seguinte é tirar os possíveis erros que você cometeu ao passar de
algoritmo para uma determinada linguagem, isso se chama Compilar.
Programa Executável: é um programa que pode ser ativado quando desejado, pelo seu
nome.exe.
Você pode ter a certeza de que aprendendo a construir algoritmos, facilmente aprenderá
outras linguagens, pois TODAS as linguagens se baseiam na LÓGICA que estamos aprendendo.
1.2.1 - C O N S T A N T E:
A informação é dita constante quando não sofre nenhuma variação no decorrer
do tempo. O valor é fixo durante a execução do algoritmo.
Ex.: 9, "PARE", FALSO, 5.78.
1.2.2 - V A R I Á V E L:
A informação é dita variável quando sofre uma ou mais variações no decorrer do
tempo. São letras que representam valores, os quais se alteram durante a execução do
algoritmo.
Ex.: X:= 5, X:= 7, Y:= 0, Y:=10
9
Qualquer variável é identificada por um identificador. Por exemplo, o dólar, pode ser
considerado como um identificador de conteúdo variável já que a sua cotação varia
diariamente.
Regras de formação de identificadores:
Os identificadores formam-se com um ou mais caracteres, onde:
10
1.4 TIPOS PRIMITIVOS:
Constantes e/ou variáveis que manipulam a informação, são divididos em quatro tipos
primitivos:
1.4.1 - INTEIRO:
Qualquer número(negativo, nulo ou positivo) que pertença ao conjunto dos números inteiros
relativos.
INTEGER: Compreende valores entre -32.768 e 32.767.
Utiliza 2 bytes.
BYTE: Compreende valores entre 0 e 255.
Utiliza 1 byte.
SHORTINT: Compreende valores entre -128 e 127.
Utiliza 1 byte.
WORD: Compreende valores entre 0 e 65.535.
Uiliza 2 bytes.
LONGINT: Compreende valores entre -2.147.483.648 e 2.147.483.647.
Utiliza 4 bytes.
Ex. 1520, 0 , -2, 25, etc.
1.4.2 - REAL:
Qualquer número(negativo, nulo ou positivo) que pertença ao conjunto dos números reais.
REAL: Compreende valores entre 2,9x10-39 e 1,7x1038 .
Utiliza 6 bytes.
SINGLE: Compreende valores entre 1,5x10-45 e 3,4x1038.
Utiliza 4 bytes.
DOUBLE: Compreende valores entre 5x10-324 e 1,7x10308.
Utiliza 8 bytes.
EXTENDED: Compreende valores entre 3,4x10-4938 e 1,1x104938.
Utiliza 10 bytes.
COMP: Compreende valores entre -243 +1 e 243 -1.
Utiliza 8 bytes.
Ex. 23.5 , CR$ 2520.25 , 97.5 KM, etc.
OBS.: Os tipos Single, Double, Extended e Comp exigem a diretiva de compilação ($N+).
Quando um número REAL é saída de dados, ele deverá conter o número de casas antes da
vírgula e depois da mesma.
Exemplo: WRITELN(‘O número tem 2 casas antes e três casas depois da vírgula’, num:2:3);
1.4.3 - CARACTER:
Qualquer informação composto de caracteres alfanuméricos e/ou especiais.
CHAR: Valores codificados em ASCII.
Utiliza 1 byte.
STRING: Valores codificados em ASCII.
Utiliza n+1 bytes.
Ex. "23.5", água, "500", &, $, #, f, h, y, etc.
11
1.4.4 - LÓGICO:
Qualquer informação biestável, isto é a informação poderá assumir somente dois estados.
BOOLEAN: Valores lógicos.
Utiliza 1 byte.
Ex. Verdadeiro ou Falso, Aberto ou Fechado, Sim ou Não
ALGORITMO: PASCAL:
Lista de variáveis : Tipo ; VAR
Lista de variáveis : Tipo ;
Onde: Tipo : inteiro (integer, byte, shortint, word, longint)
real (real, single, double, extended, comp)
caracter (char, string)
lógico (boolean)
Exemplo.:
ALGORITMO PASCAL
NOME : Caractere ; VAR
SALÁRIO : Real ; NOME : String ;
ENDEREÇO, CIDADE : Caractere ; SALÁRIO : Real ;
RESP : Lógico ; ENDEREÇO, CIDADE : String ;
NUMMAT : Inteiro ; RESP : Boolean ;
NUMMAT : Integer ;
Exemplos inválidos:
ALGORITMO PASCAL
SALÁRIO : Inteiro ; SALÁRIO : Integer;
NUMMAT : Real ; NUMMAT : Real ;
TELEFONE : Lógico ; TELEFONE : Boolean ;
1.6 COMENTÁRIOS:
O comentário é usado com a finalidade de facilitar a compreensão de um algoritmo. É um
texto que poderá aparecer em qualquer ponto do algoritmo sempre delimitado por chaves.
Exemplo.
ALGORITMO PASCAL
SALÁRIO : Real ; {Salário do funcionário } VAR
{Este algoritmo tem a finalidade de ... } SALÁRIO : Real ; {Salário do funcionário }
LEIA (SALÁRIO) ; {Entrada de valor do {Este algoritmo tem a finalidade de ... }
salário} READLN (SALÁRIO); {Entrada de valor do
salário}
12
1.7 EXPRESSÕES ARITMÉTICAS:
São aquelas cujos operadores são aritméticos e cujos operandos são constantes e/ou variáveis
do tipo numérico (inteiro e/ou real).
Ex. t := 4x * aEXP3;
y := A + B;
ALGORITMO:
+ (ADIÇÃO) - (SUBTRAÇÃO)
* (MULTIPLICAÇÃO) / (DIVISÃO)
** (POTENCIAÇÃO) // (RADICIAÇÃO)
mod (RESTO DA DIVISÃO) div (QUOCIENTE DA DIVISÃO INTEIRA)
PASCAL:
OPERADOR OPERAÇÃO TIPO DE TIPO DE
OPERANDOS RESULTADO
* Produto Real Real
* Produto Integer Integer
* Produto Real e Integer Real
/ Divisão Real Real
/ Divisão Integer Real
/ Divisão Real e Integer Real
+ Adição Real Real
+ Adição Integer Integer
+ Adição Real e Integer Real
- Subtração Real Real
- Subtração Integer Integer
- Subtração Real e Integer Real
DIV Quociente Inteiro Integer Integer
MOD Resto Inteiro Integer Integer
Exemplo UFIR/3, A*2, Aexp3; 10 MOD 3 = 1 , 10 DIV 3 = 3
ALGORITMO PASCAL
ABS(X) - VALOR ABSOLUTO ABS(X) - VALOR ABSOLUTO
EX. ABS(-23) = 23 EX. ABS(-23) = 23
FRAC(X) - PARTE FRACIONÁRIA FRAC(X) - PARTE FRACIONÁRIA
EX. FRAC(67.5) = 5 EX. FRAC(67.5) = 5
INT(X) - PARTE INTEIRA INT(X) - PARTE INTEIRA
EX. INT(67.5) = 67 EX. INT(67.5) = 67
ROUND(X) - ARREDONDAMENTO ROUND(X) - ARREDONDAMENTO
EX. ROUND(2.6) = 3 EX. ROUND(2.6) = 3
SEN(X) - SENO DE X SIN(X) - SENO DE X
EX. SEN(0) = 0 EX. SEN(0) = 0
COS (X) - CO-SENO DE X
EX. COS(0) = 1
13
LN(X) - LOGARITMO NATURAL
EX. LN(5) = 1,609438
EXP(X) - POTENCIAÇÃO
EX. 5 EXP (5) = 25
TRUNC(X) - TRUNCA O VALOR DE X
EX. TRUNC(7.6666) = 7
SQR(X) - X ELEVADO AO QUADRADO
EX. SQR(3) = 9
SQRT(X) - RAIZ QUADRADA DE X
EX. SQRT(9) = 3
Exercício:
a) int(69.7634) = 69
b) round(29.6) = 30
c) frac(201.56) = 56
d) frac(12//x) = depende do valor de x
e) x= 10; y = 2,5; z= 4;
X mod Y = 0;
frac(Z) = 0;
int(Y) = 2;
round(Y) = 2 ou 3;
A = (((X mod Z) - 1) * frac(Y)) ** 2
A = 25
1.9 PRIORIDADES:
1) Parênteses mais internos
2) Funções matemáticas
3) ** (EXP, SQR) // (SQRT)
4) * / DIV MOD
5) + -
Exercício:
ALGORITMO PASCAL
a) 4**3 + 12 / (4 - (24mod7)) + int(17 / 3) 4exp3 + 12 / (4 - (24mod7)) + int(17 / 3)
64 + 12 / (4-3) + 5 64 + 12 / (4 -3) + 5
64 + 12 + 5 64 + 12 + 5
81 81
b) 18 / 3 - round(5.6) / 2 + 4**3 b) 18 / 3 - round(5.6) / 2 + 4exp3
6 - 3 + 64 6 - 3 + 64
67 67
14
1.11 - RELAÇÃO:
uma comparação feita entre dois valores de mesmo tipo. Estes valores poderão ser
identificadores, constantes ou expressões aritméticas. Os operadores utilizados na comparação
são os seguintes:
IGUAL =
DIFERENTE <>
MAIOR QUE >
MENOR QUE <
MAIOR OU IGUAL >=
MENOR OU IGUAL <=
CONTIDO EM IN
ALGORITMO PASCAL
E AND
OU OR
XOU XOR
NÃO NOT
15
1.12 TABELA VERDADE:
Exprime todas as combinações possíveis entre os valores de diversas variáveis lógicas.
Exemplo.
ALGORITMO PASCAL
a) 3 < 7 e 4/3 <= 2 a) 3 < 7 and 4/3 <= 2
V e V V and V
V V
b) (52div12 = 5 e 13 < 4**2) ou falso b) (52div12 = 5 e 13 < SQR(4)) or false
(4 = 5 e 13 < 16) ou falso (4 = 5 e 13 < 16) or false
(F e V) ou falso (F e V) or false
F ou F F ou F
F F
c) não verdadeiro xou 3**2/3 < 15 - 35mod7 c) not true xor 3exp2/3 < 15 - 35mod7
F xou 9/3 < 15 - 0 F xor 9/3 < 15 - 0
F xou 3 < 15 F xor 3 < 15
F xou V F xor V
V V
1) NÃO (NOT)
2) E (AND) OU (OR)
3) XOU (XOR)
16
Exercícios: Considerando as variáveis a seguir:
CIDADE = "SÃO PAULO" PESO = 54 BOOLEANO = V
ALGORITMO PASCAL
a) cidade = "Gramado" E NÃO booleano a) cidade = "Gramado" AND NOT booleano
F E F F AND F
F F
b) int(3.8) ** 2 = 9 OU peso = 55 b) SQR(int(3.8)) = 9 OR peso = 55
V OU F V OR F
V V
c) int(17/2) <> 4+2 XOU 2+3*5/3mod5 > 0 c) int(17/2) <> 4+2 XOR 2+3*5/3mod5 > 0
int(8.5) <> 6 XOU 2+ 15/3mod5 > 0 int(8.5) <> 6 XOR 2+ 15/3mod5 > 0
8 <> 6 XOU 2 + 0 > 0 8 <> 6 XOR 2 + 0 > 0
V XOU 2 > 0 V XOR 2 > 0
V XOU V V XOR V
F F
PASCAL:
SINTAXE..: <IDENTIFICADOR> := EXPRESSÃO;
Exemplos:
ALGORITMO PASCAL
A: lógico; A: boolean;
B: real; B: real;
C: inteiro; C: integer;
D: caracter; D: string;
A < --falso; A := false;
A < -- 2; ERRADO A := 2; ERRADO
B < --59.9 B := 59.9;
D < -- "JOÃO"; D := "JOÃO";
A < -- 4 < 5; ERRADO A := 4 < 5; ERRADO
Exercício clássico: Dado duas variáveis do tipo inteiro, as quais assumem os valores de 10 e
20 respectivamente, faça um algoritmo que troque os valores das mesmas, de modo que uma
fique com o valor da outra.
ALGORITMO PASCAL
X,Y,AUX : INTEIRO; VAR
X,Y,AUX : INTEGER;
AUX <-- X; AUX := X;
X <--Y; X := Y;
Y <--AUX; Y := AUX;
17
2. COMANDOS DE ENTRADA E SAÍDA:
Utilizados para permitir a entrada de informações e posterior resultado do processamento
(saída)
ALGORITMO: PASCAL:
Exemplo:
ALGORITMO PASCAL
NOME : Caracter; VAR
X,Y : Real; NOME : String;
X,Y : Real;
LEIA (NOME);
LEIA (X,Y); READLN (NOME);
READLN (X,Y);
ALGORITMO: PASCAL:
SINTAXE..: ESCREVA( Variável ) ; SINTAXE..: WRITELN( Variável ) ;
( Constante ) ; ( Constante ) ;
( Expressão ) ; ( Expressão ) ;
Exemplo:
ALGORITMO PASCAL
ESCREVA (A); ESCREVA (A);
ESCREVA (2000); ESCREVA (2000);
ESCREVA("Nome do funcionário:”, nome); ESCREVA("Nome do funcionário:”, nome);
ESCREVA (A**2); ESCREVA (SQR(A));
18
3. ESTRUTURA DO ALGORITMO:
ALGORITMO:
SINTAXE..: PROGRAMA <nome do programa>;
{ Declaração de variáveis... }
INICIO
...
Ação
...
FIM .
PASCAL:
SINTAXE..: PROGRAM <nome do programa>;
USES CRT; {Identifica as bibliotecas (units) usadas no programa.
A mais usada é a CRT.}
VAR
{Declaração de variáveis }
BEGIN
...
Ação
...
END.
Exemplo:
ALGORITMO PASCAL
PROGRAMA teste; PROGRAM teste;
... {Declaração de variáveis} USES CRT;
INICIO {Marca o inicio do algoritmo} VAR
... ... {Declaração de variáveis}
... { Comandos} BEGIN {Marca o inicio do algoritmo}
... ...
... ... { Comandos}
... ...
FIM . {Determina o fim do algoritmo} ...
...
END . {Determina o fim do algoritmo}
19
Exercícios: 1- Faça um algoritmo que leia 3 números inteiros e escreva o produto
destes números.
ALGORITMO PASCAL
PROGRAMA números; PROGRAM números;
a, b, c, produto : INTEIRO ; USES CRT;
INICIO VAR
LEIA (a, b, c); a, b, c, produto : INTEGER ;
produto < -- a*b*c BEGIN
ESCREVA("O produto entre os números
lidos é: ",produto) ; READLN (a, b, c);
FIM. produto := a*b*c;
WRITELN(‘O produto entre os números
lidos é: ‘,produto) ;
END.
2- Dado a base e a altura de um retângulo, faça o algoritmo para calcular a área deste retângulo.
ALGORITMO PASCAL
PROGRAMA retângulo; PROGRAM retângulo;
base, altura : REAL ; USES CRT;
INICIO VAR
LEIA(base, altura) ; base, altura : REAL ;
ESCREVA ("A área do retângulo", base * BEGIN
altura); READLN(base, altura) ;
FIM.. WRITELN (‘A área do retângulo’, base *
altura :3:2);
END.
3- Uma dona de casa comprou 3 quilos de açúcar, 1 quilo de arroz e 1 quilo de filé , que
custam R$ 12,00, R$ 21..50, R$ 130..00 respectivamente cada quilo. Na semana seguinte ela
efetuou a mesma compra com exceção do filé que foi substituído por carne moída.
Considerando que os preços sofreram um reajuste de 12% e que o quilo da carne moída custa
metade do preço do filé , faça o algoritmo que escreva o total gasto por esta dona de casa.
ALGORITMO PASCAL
PROGRAMA compra; PROGRAM compra;
ac, ar, fi, total : REAL ; USES CRT;
INICIO VAR
ac < -- 120.00 ; ac, ar, fi, total : REAL ;
ar < -- 213.5 ; BEGIN
fi < -- 1.300 ; ac := 120.00 ;
total < -- 3 * ac + ar + fi / 2 ; ar := 213.5 ;
total < -- total * 1.12; fi := 1.300 ;
ESCREVA ("TOTAL GASTO NESTA total := 3 * ac + ar + fi / 2 ;
SEMANA ",total); total := total * 1.12;
WRITELN (‘TOTAL GASTO NESTA
SEMANA ‘,total:4:2);
FIM. END.
20
4. COMANDOS:
ALGORITMO:
SINTAXE..: SE <condição> ENTÃO
comando; {comando único}
FIMSE;
PASCAL:
SINTAXE..: IF <condição> THEN
comando; {comando único}
Onde:
<condição> é uma expressão lógica.
Se(e somente) se a condição for verdadeira então o comando será executado.
Exemplo:
ALGORITMO PASCAL
PROGRAMA teste; PROGRAM teste;
sexo: CARACTER; USES CRT;
INICIO VAR
LEIA(sexo); sexo: CHAR;
SE sexo = “M” ENTÃO BEGIN
ESCREVA (“Masculino”); READLN(sexo);
FIMSE; IF (sexo = ‘M’) THEN
FIM. WRITELN (‘Masculino’);
END.
21
4.1.2 - SELEÇÃO COMPOSTA:
ALGORITMO:
SINTAXE..: SE <condição> ENTÃO
comando; {comando único}
SENÃO
comando; {comando único}
FIMSE;
PASCAL:
SINTAXE..: IF <condição> THEN
comando {comando único}
ELSE
comando; {comando único}
22
4.1.3 - SELEÇÃO ENCADEADA:
ALGORITMO:
SINTAXE..: SE <condição1> ENTÃO
SE <condição2> ENTÃO
INICIO
C1;
... ; {seqüência de comandos}
Cn;
FIM;
FIMSE;
SENÃO
Cn;
FIMSE;
PASCAL:
SINTAXE..: IF <condição1> THEN
IF <condição2> THEN
BEGIN
C1;
... ; {seqüência de comandos}
Cn;
END
ELSE
Cn;
Exercícios:
1- Faça um algoritmo que leia 3 valores inteiros e determine o maior dentre os três.
ALGORITMO PASCAL
PROGRAMA maior3; PROGRAM maior3;
a, b, c, maior : INTEIRO; USES CRT;
INICIO VAR
LEIA(a, b, c); a, b, c, maior : INTEGER;
SE ((a > b) E (a > c)) ENTÃO BEGIN
MAIOR< -- a; READLN (a);
SENÃO READLN (b);
SE (b > c) ENTÃO READLN (c);
MAIOR <-- b; IF ((a > b) AND (a > c)) THEN
SENÃO maior := a
MAIOR <-- c; ELSE
FIMSE; IF (b > c) THEN
FIMSE; maior := b
ESCREVA("O maior valor ",maior); ELSE
FIM. maior := c;
WRITELN(‘O maior valor ‘,maior);
END.
23
2- Faça um algoritmo que leia 3 números, se todos forem números pares efetue a soma destes,
caso todos sejam ímpares efetue uma multiplicação e em caso contrário subtraia um pelo outro.
O algoritmo deve ainda emitir mensagens do tipo:
"Todos pares, e o resultado da soma "...
"Todos ímpares, e o resultado da multiplicação "...
"Ambos e a subtração resulta em "...
ALGORITMO:
PROGRAMA pares_ímpares;
a, b, c, result : INTEIRO;
INICIO
LEIA(a,b,c);
SE ((a MOD 2 = 0) E (b MOD 2 = 0) E (c MOD 2 = 0) ENTÃO
INÍCIO
result <-- a + b + c;
ESCREVA("Todos pares, e o resultado da soma é ",result);
FIM;
SENÃO
SE ((a/2 <> INT(a/2) ) E (b/2 <> INT (b/2)) E (c/2 <> INT (c/2))) ENTÃO
INÍCIO
result <-- A*B*C;
ESCREVA(“Todos ímpares, e o resultado da multiplicação”, result);
FIM;
SENÃO
INICIO
result <-- a-b-c;
ESCREVA("Ambos, e a subtração resulta em ",result);
FIM;
FIMSE;
FIMSE;
FIM.
24
PASCAL:
PROGRAM pares_ímpares;
USES CRT;
VAR
a, b, c, result : INTEGER;
BEGIN
READLN (a);
READLN (b);
READLN (c);
IF ((a MOD 2 = 0) AND (b MOD 2 = 0) AND (c MOD 2 = 0)) THEN
BEGIN
result := a + b + c;
WRITELN(‘Todos pares, e o resultado da soma é ‘,result);
END
ELSE
IF ((a/2 <> INT(a/2) ) AND (b/2 <> INT (b/2)) AND (c/2 <> INT (c/2))) THEN
BEGIN
result := A*B*C;
WRITELN(‘Todos ímpares, e o resultado da multiplicação’, result);
END
ELSE
BEGIN
result := a - b - c;
WRITELN(‘Ambos, e a subtração resulta em ‘,result);
END;
END.
3. Faça um algoritmo que leia os três lados de um triângulo. O algoritmo deve oferecer na tela 2
opções:
a) Perímetro
b) Classificação do triângulo
Considerações:
- Triângulo uma figura geométrica em que um lado é menor do que a
soma dos outros dois.
- T. equilátero : 3 lados iguais
- T. isósceles : 2 lados iguais
- T. escaleno : 3 lados diferentes
25
ALGORITMO:
PROGRAMA triângulo;
a, b, c : INTEIRO;
INICIO
LEIA(a, b, c,) ;
SE (a < b + c) E (b < a + c) E (c < a + b) ENTÃO
INICIO
SE (a = b) E (b = c) ENTÃO
ESCREVA ("Triângulo Equilátero");
SENÃO
SE (a = b) OU (a = c) OU (b = c) ENTÃO
ESCREVA ("Triângulo Isósceles");
SENÃO
ESCREVA ("Triângulo Escaleno");
FIMSE;
FIMSE;
ESCREVA (" O perímetro ",a+b+c);
FIM;
SENÃO
ESCREVA ("Não é um triângulo");
FIMSE;
FIM.
PASCAL:
PROGRAM triângulo;
USES CRT;
VAR
a, b, c : INTEGER;
BEGIN
READLN(a);
READLN( b);
READLN( c);
IF (a < b + c) AND (b < a + c) AND (c < a + b) THEN
BEGIN
IF (a = b) AND (b = c) THEN
WRITELN (‘Triângulo Equilátero’)
ELSE
IF (a = b) OR (a = c) OR (b = c) THEN
WRITELN (‘Triângulo Isósceles’)
ELSE
WRITELN (‘Triângulo Escaleno’);
WRITELN (‘ O perímetro ‘,A+B+C);
END
ELSE
WRITELN (‘Não é um triângulo’);
END.
26
4.1.4 - SELEÇÃO DE MÚLTIPLA ESCOLHA:
ALGORITMO:
SINTAXE : ESCOLHA seletor
CASO 1: C1;
CASO 2: C2;
CASO 3: C3;
CASO CONTRÁRIO : C4;
FIMESCOLHA;
PASCAL
SINTAXE : CASE seletor OF
CASO 1: C1;
CASO 2: C2;
CASO 3: C3;
ELSE
Comando;
END;
Obs.: O comando CASE do Pascal só aceita variáveis do tipo Boolean, Byte, Char, Integer,
Longint, Shortint e Word.
27
Exemplo: Faça um algoritmo que leia a abreviatura de um estado da região sul e escreva o
nome deste estado por extenso.
ALGORITMO:
PROGRAMA estado;
est : CARACTER;
INICIO
LER(est);
ESCOLHA (est)
CASO "R" : ESCREVA ("RIO GRANDE DO SUL"),
CASO "S" : ESCREVA ("SANTA CATARINA");
CASO “P” : ESCREVA (“PARANÁ”);
CASO CONTRARIO : ESCREVA ("ESTADO INEXISTENTE");
FIM ESCOLHA.
FIM.
PASCAL:
PROGRAM estado;
USES CRT;
VAR
est : CHAR;
BEGIN
READLN(est);
CASE est OF
‘R’ : WRITELN (‘RIO GRANDE DO SUL’);
‘S’ : WRITELN (‘SANTA CATARINA’);
‘P’ : WRITELN (‘PARANÁ’);
ELSE
WRITELN (‘ESTADO INEXISTENTE’);
END;
END.
Exercício: Faça um algoritmo que leia as 3 notas de um aluno. Sabendo que a média mínima
exigida é 7, imprima a mensagem aprovado ou reprovado.
ALGORITMO:
PROGRAMA notas;
n1, n2, n3, média : REAL;
INICIO
LEIA(n1, n2, n3) ;
média <-- (n1+n2+n3)/3;
SE média >= 7 ENTÃO
ESCREVA ("APROVADO");
SENÃO ESCREVA ("REPROVADO");
FIMSE;
FIM.
28
PASCAL:
PROGRAM notas;
USES CRT;
VAR
n1, n2, n3, média : REAL;
BEGIN
READLN (n1);
READLN (n2);
READLN (n3);
média := (n1+n2+n3)/3;
IF (média >= 7) THEN
WRITELN (‘APROVADO’)
ELSE
WRITELN (‘REPROVADO’);
END.
ALGORITMO:
29
PASCAL:
SINTAXE..: FOR x := vi TO vf DO
comando único;
SINTAXE..: FOR x := vi TO vf DO
BEGIN
...
comandos;
END;
ALGORITMO:
PROGRAMA notas;
n1, n2, n3, média : REAL;
x : INTEIRO;
INICIO
PARA x DE 1 ATÉ 50 FAÇA
INICIO
LEIA(n1, n2, n3) ;
média< -- (n1+n2+n3)/3;
SE média >= 7 ENTÃO
ESCREVA ("APROVADO");
SENÃO ESCREVA ("REPROVADO");
FIMSE;
FIM;
FIMPARA;
FIM.
30
PASCAL:
PROGRAM notas;
USES CRT;
VAR n1, n2, n3, média : REAL;
x : INTEGER;
BEGIN
FOR x := 1 TO 50 DO
BEGIN
READLN(n1);
READLN(n2);
READLN(n3);
média := (n1+n2+n3)/3;
IF (média >= 7) THEN
WRITELN (‘APROVADO’)
ELSE
WRITELN (‘REPROVADO’);
END;
END.
ALGORITMO:
PASCAL:
31
Exemplo: Faça um algoritmo que escreva os números pares situados entre 1 e 20.
ALGORITMO PASCAL
PROGRAMA números; PROGRAM números;
x : INTEIRO; USES CRT;
INICIO VAR
x < -- 1; x : INTEGER;
ENQUANTO x <= 20 FAÇA BEGIN
INICIO x := 1;
SE x MOD 2 = 0 ENTÃO WHILE (x <= 20) DO
ESCREVA(x); BEGIN
FIMSE; IF (x MOD 2 = 0) THEN
x <-- x + 1; WRITELN(x);
FIM; x := x + 1;
FIMENQUANTO; END;
FIM. END.
ALGORITMO:
SINTAXE..: REPITA
...
comandos;
...
ATÉ <condição>;
PASCAL:
SINTAXE..: REPEAT
...
comandos;
...
UNTIL <condição>;
32
Exemplo. Faça um algoritmo que some todos números ímpares situados entre 20 e 50.
ALGORITMO PASCAL
PROGRAMA soma; PROGRAM soma;
x, acum : INTEIRO; USES CRT;
INICIO VAR
acum <--0; x, acum : INTEGER;
x < --21; BEGIN
REPITA acum := 0;
acum <-- acum + x; x := 21;
x < -- x + 2; REPEAT
ATÉ (x = 51); acum := acum + x;
ESCREVA("A SOMA É ",acum); x := x + 2;
FIM. UNTIL(x = 51);
WRITELN (‘A SOMA É ‘,acum);
END.
Exercícios:1- Faça um algoritmo que escreva os números pares entre 1 e 30, efetuando a soma
destes.Utilize os três tipos de comandos de repetição para visualizar as diferenças.
33
USANDO O COMANDO ENQUANTO
ALGORITMO PASCAL
PROGRAMA pares; PROGRAM pares;
par, acum : INTEIRO; USES CRT;
INICIO VAR
acum <-- 0; par, acum : INTEGER;
par < -- 2; BEGIN
ENQUANTO (par <= 30) FAÇA acum := 0;
INICIO par := 2;
ESCREVA(par); WHILE (par <=30) DO
acum := acum + par; BEGIN
par <-- par + 2; WRITELN(par);
FIM; acum := acum + par;
FIMENQUANTO; par := par + 2;
ESCREVA("SOMA DOS PARES ",acum); END;
FIM. WRITELN (‘SOMA DOS PARES’, acum);
END.
34
2- Faça um algoritmo que leia um número indeterminado de números, o algoritmo encerra
quando for digitado o número 99. O algoritmo deve fornecer ao final o percentual de números
pares e ímpares digitados.
ALGORITMO:
PROGRAMA par_ímpar;
ctn, p, i, n : INTEIRO;
percp, perci : REAL;
INICIO
ctn < -- 0;
p <-- 0;
i <-- 0;
LEIA(n);
ENQUANTO (n <> 99) FAÇA
INICIO
SE (n MOD 2 = 0) ENTÃO {TESTA SE PAR}
p <-- p + 1;
SENÃO i <-- i + 1;
FIMSE;
ctn <-- ctn + 1;
LEIA(n);
FIM;
FIMENQUANTO;
SE (ctn > 0) ENTÃO
INICIO
percp <-- (p*100)/ctn;
perci <-- 100 - percp;
ESCREVA ("PERCENTUAL DE NÚMEROS PARES ",percp);
ESCREVA ("PERCENTUAL DE N i MEROS IMPARES
",perci);
FIM
FIMSE;
FIM.
35
PASCAL:
PROGRAM par_ímpar;
USES CRT;
VAR
ctn, p, i, n : INTEGER;
percp, perci : REAL;
BEGIN
ctn := 0;
p := 0;
i := 0;
READLN(n);
WHILE (n <> 99) DO
BEGIN
IF (n MOD 2 = 0) THEN {Testa se PAR}
p := p + 1 {Antes do ELSE não tem ; }
ELSE i := i + 1;
ctn := ctn + 1;
READLN(n);
END;
IF (ctn > 0) THEN
BEGIN
percp := (p*100)/ctn;
perci := 100 - percp;
WRITELN(‘PERCENTUAL DE NÚMEROS PARES ‘,percp :3:2);
WRITELN(‘PERCENTUAL DE NÚMEROS IMPARES ‘,perci:3:2);
END;
END.
ALGORITMO PASCAL
PROGRAMA fatorial; PROGRAM fatorial;
x, n, fat : INTEIRO; USES CRT;
INICIO VAR
fat <-- 1; x, n, fat : LONGINT; { Se for do tipo
LEIA(n); integer, o fatorial só calcula até o numero 17}
SE (n <> 0) ENTÃO BEGIN
PARA x DE 1 ATE n FAÇA fat := 1;
fat <-- fat * x; READLN(n);
FIMPARA; IF (n <> 0) THEN
FIMSE; FOR x := 1 TO n DO
ESCREVA("O FATORIAL ",fat); fat := fat * x;
FIM. WRITELN(‘O FATORIAL ‘,fat);
END.
36
4- Faça o algoritmo para imprimir a série de Fibonacci até 30.
ALGORITMO:
PROGRAMA Fibonacci;
a, b, x, y : INTEIRO;
INICIO
a <-- 0;
b <-- 1;
ESCREVA (“POSIÇÃO : 1 VALOR : 0” );
ESCREVA (“POSIÇÃO : 2 VALOR : 1”);
PARA x DE 3 ATE 30 FAÇA
INICIO
ESCREVA(“POSIÇÃO :”, x);
ESCREVA(“VALOR :”, b);
y <-- 2*b + a;
a <-- b;
b <-- y;
FIM;
FIMPARA;
FIM.
PASCAL:
PROGRAM Fibonacci;
USES CRT;
VAR
a, b, x, y : INTEGER;
BEGIN
a := 0;
b := 1;
WRITELN (‘POSIÇÃO : 1 VALOR : 0’ );
WRITELN (‘POSIÇÃO : 2 VALOR : 1’);
FOR x := 3 TO 30 DO
BEGIN
y := 2*b + a;
a := b;
b := y;
WRITELN (‘POSIÇÃO : ’, x, ‘ VALOR : ’, b);
END;
END.
37
5- Faça um algoritmo que leia um número e escreva a mensagem " É primo" ou "Não é
primo".
Número primo: É o número divisível por 1 e por ele próprio somente.
ALGORITMO PASCAL
PROGRAMA fatorial; PROGRAM fatorial;
n, último, fator : INTEIRO; USES CRT;
pr: LÓGICO; VAR
INICIO n, último, fator : INTEGER;
pr <-- VERDADEIRO; pr: BOOLEAN;
fator <--2; BEGIN
LEIA(n); pr := TRUE;
último <-- N - 1; fator := 2;
ENQUANTO (pr E fator <= último) READLN(n);
FAÇA último := N - 1;
SE (n MOD fator = 0) ENTÃO WHILE ((pr) AND ( fator <= último)) DO
pr < -- FALSO; IF (n MOD fator = 0) THEN
SENÃO fator <-- fator + 1; pr := FALSE
FIMSE; ELSE fator := fator + 1;
FIMENQUANTO; IF (pr) THEN
SE (pr) ENTÃO WRITELN(‘ É PRIMO’)
ESCREVA(" É PRIMO"); ELSE WRITELN(‘NÃO É PRIMO’);
SENÃO ESCREVA("NÃO É PRIMO"); END.
FIMSE;
FIM.
6- Faça um algoritmo que calcule todos números que são quadrados perfeitos entre 1 e 500.
OBS. quadrado perfeito é o número que somado seus divisores resulta nele próprio.
ALGORITMO:
PROGRAMA quadrado;
x, a, acum : INTEIRO;
INICIO
PARA x DE 2 ATÉ 500 FAÇA
INICIO
a <--1;
acum <-- 0;
ENQUANTO (a < x) FAÇA
INICIO
SE (x MOD a = 0) ENTÃO
acum <-- acum + a;
FIMSE;
a <-- a + 1;
FIM;
FIMENQUANTO;
SE (acum = x) ENTÃO
ESCREVA("QUADRADO PERFEITO ",acum);
FIMSE;
FIM;
FIMPARA;
FIM.
38
PASCAL:
PROGRAM quadrado;
USES CRT;
VAR
x, a, acum : INTEGER;
BEGIN
FOR x := 2 TO 500 DO
BEGIN
a := 1;
acum := 0;
WHILE (a < x) DO
BEGIN
IF (x MOD a = 0) THEN
acum := acum + a;
a := a+1;
END;
IF (acum = x) THEN
WRITELN (‘QUADRADO PERFEITO ‘,acum);
END;
END.
7- Projete um algoritmo para ser utilizado em uma máquina de votar hipotética. Nesta eleição
concorrerão 4 candidatos:
LULA - 13
QUÉRCIA - 15
ACM - 20
BRIZOLA - 5
O algoritmo dever indicar o vencedor bem com seu percentual de votos sobre
o total, os votos em branco e nulo deverão ser mostrados também e seus
respectivos percentuais.
O algoritmo finaliza com voto = 99
ALGORITMO:
PROGRAMA votação;
a, l, q, b, nulo, branco, totv, venc : INTEIRO;
nvenc : CARACTER;
voto : INTEIRO;
pvenc, pbr, pn : REAL;
INICIO
a <-- 0;
l <-- 0;
q <-- 0;
b <-- 0;
totv <-- 0;
nulo <-- 0;
branco <-- 0;
LEIA(voto);
39
ENQUANTO (voto <> 99) FAÇA
INICIO
ESCOLHA VOTO
CASO 13 : l <-- l + 1;
CASO 15 : q < -- q + 1;
CASO 20 : a <-- a + 1;
CASO 5 : b < -- b + 1;
CASO 0 : branco <-- branco + 1;
CASO CONTRÁRIO : nulo < -- nulo + 1;
FIMESCOLHA;
totv <-- totv + 1;
LEIA(voto);
FIM;
FIMENQUANTO;
SE (totv >= 1) ENTÃO
INICIO
venc <-- l;
nvenc <-- “LULA”;
SE (q > venc) ENTÃO
INICIO
venc <-- q;
nvenc <--"QUERCIA";
FIM;
FIMSE;
SE (a > venc) ENTÃO
INICIO
venc < -- a;
nvenc <--"ACM";
FIM;
FIMSE;
SE (b > venc) ENTÃO
INICIO
venc <-- b;
nvenc <--"BRIZOLA";
FIM;
FIMSE;
FIM;
SENÃO ESCREVA("NENHUM VOTO COMPUTADO");
FIMSE;
pvenc <-- (venc*100)/totv;
ESCREVA("O VENCEDOR FOI ", nvenc);
ESCREVA("O PERCENTUAL FOI ", pvenc);
pbr <-- (branco*100)/totv;
pn <-- (nulo*100)/totv;
ESCREVA("VOTOS EM BRANCO ",pbr);
ESCREVA("VOTOS NULOS ",pn);
FIM.
40
PASCAL:
PROGRAM votação;
USES CRT;
VAR
a, l, q, b, nulo, branco, totv, venc : INTEGER;
nvenc : STRING;
pvenc, pbr, pn : REAL;
voto : INTEGER;
BEGIN
a := 0;
l := 0;
q := 0;
b := 0;
totv := 0;
nulo := 0;
branco := 0;
READLN (voto);
WHILE (voto <> 99) DO
BEGIN
CASE (VOTO) OF
13 : l := l + 1;
15 : q := q + 1;
20 : a := a + 1;
5 : b := b + 1;
0 : branco := branco + 1;
ELSE : nulo := nulo + 1;
END;
totv := totv + 1;
READLN(voto);
END;
IF (totv >= 1) THEN
BEGIN
venc := l;
nvenc := “LULA”;
IF (q > venc) THEN
BEGIN
venc := q;
nvenc := "QUERCIA";
END;
IF (a > venc) THEN
BEGIN
venc := a;
nvenc := "ACM";
END;
41
IF (b > venc) THEN
BEGIN
venc := b;
nvenc := "BRIZOLA";
END;
END
ELSE WRITELN (‘NENHUM VOTO COMPUTADO’);
pvenc := (venc*100)/totv;
WRITELN (‘O VENCEDOR FOI ‘, nvenc);
WRITELN (‘O PERCENTUAL FOI ‘, pvenc :3:2);
pbr := (branco*100)/totv;
pn := (nulo*100)/totv;
WRITELN (‘VOTOS EM BRANCO ‘,pbr :3:2);
WRITELN (‘VOTOS NULOS ‘,pn :3:2);
END.
8- Faça um algoritmo que leia dois números inteiros de cada vez .A leitura deve ser feita
enquanto não for digitado o numero 0. Os números lidos deverão ser apenas números ímpares e,
quando forem consecutivos deverão ser multiplicados. Ao finalizar o algoritmo deverá escrever
a soma das multiplicações.
ALGORITMO:
PROGRAMA ímpares;
a, b, acum : INTEIRO;
INICIO
acum <-- 0;
LEIA(a, b);
ENQUANTO ((a<>0) E (b<> 0)) FAÇA
INICIO
SE ((a MOD 2 = 0) E (b MOD 2 = 0)) ENTÃO
INICIO
SE ((a+2 = b) OU (b+2 = a)) ENTÃO
acum <-- acum + a*b;
FIMSE;
FIM;
SENÃO ESCREVA("SOMENTE NÚMEROS PARES");
FIMSE;
LEIA(a, b);
FIM
FIMENQUANTO;
ESCREVA ("A SOMA DAS MULTIPLICAÇÕES É ",acum);
FIM.
42
PASCAL:
PROGRAM ímpares;
USES CRT;
VAR
a, b, acum : INTEGER;
BEGIN
acum := 0;
READLN (a);
READLN(b);
WHILE ((a<>0) AND (b<> 0)) DO
BEGIN
IF ((a MOD 2 = 0) AND (b MOD 2 = 0)) THEN
BEGIN
IF ((a+2 = b) OR (b+2 = a)) THEN
acum := acum + a*b;
END
ELSE WRITELN (‘SOMENTE NÚMEROS PARES’);
READLN (a, b);
END;
WRITELN (‘A SOMA DAS MULTIPLICAÇÕES É ‘,acum);
END.
5. VETORES
É característica dos tipos primitivos, independente do tipo, que eles podem assumir somente
um "valor" de cada vez.
A palavra VETOR denomina um novo tipo, que possui a característica de uma variável
poder assumir diversos valores ao mesmo tempo, mas de um só tipo primitivo.
ALGORITMO:
SINTAXE..: IDENTIFICADOR = VETOR [Li..Lf] DE <TIPO>;
LISTA DE VARIÁVEIS : IDENTIFICADOR;
PASCAL:
SINTAXE..: VAR
IDENTIFICADOR : ARRAY [Li...Lf] OF <TIPO>;
ou
SINTAXE..: TYPE
IDENTIFICADOR = ARRAY [Li...Lf] OF <TIPO>;
VAR
VARIÁVEL : IDENTIFICADOR;
43
Onde:
IDENTIFICADOR : o novo tipo que está sendo criado.
Exemplo:
ALGORITMO PASCAL
PROGRAMA vetores; PROGRAM vetores;
notas = VETOR [1..3] DE REAL; USES CRT;
vnotas : notas; VAR
INICIO notas : ARRAY [1..3] OF REAL;
... BEGIN
FIM. ...
END.
OU
PROGRAM vetores;
TYPE
notas = ARRAY [1..3] OF REAL;
VAR
vnotas : notas;
VNOTAS:
1 2 3
44
Exercício: 1- Fazer um algoritmo que leia a população de 10 capitais brasileiras e escreva a
população média das capitais.
ALGORITMO PASCAL
PROGRAMA média_10; PROGRAM média_10;
pop, total, x : INTEIRO; USES CRT;
med : REAL; VAR
INICIO pop, total, x : INTEGER;
med <-- 0; med : REAL;
total < -- 0; BEGIN
PARA x DE 1 ATE 10 FAÇA med := 0;
INICIO total := 0;
LEIA(pop); FOR x := 1 TO 10 DO
total <-- total + pop; BEGIN
FIM; READLN(pop);
FIMPARA; total := total + pop;
med <--total / 10; END;
ESCREVA("A POPULAÇÃO MÉDIA med := total / 10;
",med); WRITELN(‘A POPULAÇÃO MÉDIA
FIM. ‘,med :2:2);
END.
No exemplo acima se quiséssemos saber se a população de uma determinada capital está acima
da média como faríamos?
Teríamos que saber a média para efetuarmos a comparação, mas a média somente será
conhecida após termos lido todas as 10 populações!!! SOLUÇÃO..:
ALGORITMO PASCAL
PROGRAMA capitais; PROGRAM capitais;
pop = VETOR [1..10] DE INTEIRO; USES CRT;
vpop : pop; TYPE
med : REAL; pop = ARRAY [1..10] OF INTEGER;
total, x : INTEIRO; VAR
INICIO vpop : pop;
med <-- 0; med : REAL;
total <-- 0; total, x : INTEGER;
PARA x DE 1 ATE 10 FAÇA BEGIN
INICIO med := 0;
LEIA(vpop[x]); total := 0;
total <--total + vpop[x]; FOR x := 1 TO 10 DO
FIM; BEGIN
FIMPARA; READLN(vpop[x]);
med <-- total/10; total := total + vpop[x];
PARA x DE 1 ATE 10 FAÇA END;
SE (vpop[x] > med) ENTÃO med := total/10;
ESCREVA("A CAPITAL ",x, FOR x := 1 TO 10 DO
“ESTA ACIMA DA IF (vpop[x] > med) THEN
MEDIA"); WRITELN(‘A CAPITAL ‘,x, ’ESTA ACIMA
FIMSE; DA MEDIA’);
FIMPARA; END.
FIM.
45
Exercícios: 1- Faça um algoritmo para ler um vetor de 5 elementos e imprimi-los ao final da
leitura. Os elementos são do tipo caracter.
ALGORITMO PASCAL
PROGRAMA vetor5; PROGRAM vetor5;
cinco = VETOR [1..5] DE CARACTER; USES CRT;
vcinco : cinco; VAR
x : INTEIRO; vcinco : ARRAY [1..5] OF CHAR;
INICIO x : INTEGER;
PARA x DE 1 ATE 5 FAÇA BEGIN
LEIA(vcinco[x]); FOR x := 1 TO 5 DO
FIMPARA; READLN(vcinco[x]);
PARA x DE 1 ATÉ 5 FAÇA FOR x := 1 TO 5 DO
ESCREVA(vcinco[x]); WRITELN(vcinco[x]);
FIMPARA; END.
FIM.
2- Faça um algoritmo que leia um vetor de 20 elementos, após a leitura deste vetor dever ser
lido um número qualquer. O algoritmo deve escrever quantas vezes o número lido aparece no
vetor lido, caso não exista deve escrever "Número não encontrado".
ALGORITMO:
PROGRAMA vetor_20;
tab = VETOR[1..20] DE INTEIRO;
vtab : tab;
num, x, vexes : INTEIRO;
INICIO
PARA x DE 1 ATÉ 20 FAÇA
LEIA(vtab[x]);
FIMPARA;
LEIA (num);
PARA x DE 1 ATE 20 FAÇA
SE (vtab[x] = num) ENTÃO
vezes <--vezes + 1;
FIMSE;
FIMPARA;
SE (vezes = 0) ENTÃO
ESCREVA("NUMERO NÃO ENCONTRADO");
SENÃO ESCREVA("O NUMERO", num, "FOI ENCONTRADO", vezes,
"VEZES");
FIMSE;
FIM.
46
PASCAL:
PROGRAM vetor_20;
USES CRT;
VAR
vtab : ARRAY [1..20] OF INTEGER;
num, x, vezes : INTEGER;
BEGIN
FOR x := 1 TO 20 DO
READLN(vtab[x]);
READLN (num);
FOR x := 1 TO 20 DO
IF (vtab[x] = num) THEN
vezes := vezes + 1;
IF (vezes = 0) THEN
WRITELN (‘NUMERO NÃO ENCONTRADO’)
ELSE WRITELN(‘O NUMERO’, num, ‘FOI ENCONTRADO’, vezes,
‘VEZES’);
END.
ALGORITMO PASCAL
PROGRAMA inverso; PROGRAM inverso;
inv = VETOR [1..10] DE REAL; USES CRT;
vinv : inv; TYPE
x : INTEIRO; inv : ARRAY [1..10] OF REAL;
INICIO VAR
PARA x DE 1 ATÉ 10 FAÇA vinv : inv;
LEIA(vinv[x]); x : INTEGER;
FIMPARA; BEGIN
PARA x DE 10 ATE 1 PASSO -1 FAÇA FOR x := 1 TO 10 DO
ESCREVA(vinv[x]); READLN(vinv[x]);
FIMPARA; FOR x := 10 DOWNTO 1 DO
FIM. WRITELN(vinv[x] :2:2);
END.
47
4- Faça um algoritmo que leia um vetor de 50 elementos, todos inteiros. O algoritmo deve gerar
um outro vetor de 50 elementos do tipo lógico, que assume verdadeiro na posição
correspondente se o número no vetor original for par e falso caso contrário.
ALGORITMO:
PROGRAMA vetor_par_ímpar;
num = VETOR [1..50] DE INTEIRO;
vnum : num;
aux = VETOR [1..50] DE LÓGICO;
vaux : aux;
x : INTEIRO;
INICIO
PARA X DE 1 ATE 50 FAÇA
INICIO
LEIA(vnum[x]);
SE (vnum[x] MOD 2 = 0) ENTÃO
vaux[x] <-- VERDADEIRO;
SENÃO vaux[x] <-- FALSO;
FIMSE;
FIM;
FIMPARA;
FIM.
PASCAL:
PROGRAM vetor_par_ímpar;
USES CRT;
VAR
num : ARRAY [1..50] OF INTEGER;
aux : ARRAY [1..50] OF BOOLEAN;
x : INTEGER;
BEGIN
FOR x := 1 TO 50 DO
BEGIN
READLN(num[x]);
IF (num[x] MOD 2 = 0) THEN
aux[x] := TRUE
ELSE aux[x] := FALSE;
END;
END.
48
5- Crie um algoritmo que leia 2 vetores de 10 elementos reais. Após a leitura, um terceiro vetor
deverá ser criado com 10 elementos inteiros e seu conteúdo deve ser gerado da seguinte maneira:
O número lido no vetor A deve ser pesquisado no vetor B e o número de vezes que for
encontrado neste vetor irá gerar o vetor C.
ALGORITMO:
PROGRAMA vetores;
vet = VETOR [1..10] DE REAL;
a, b : VET;
vet1= VETOR [1..10] DE INTEIRO;
c : VET1;
vezes, x, y : INTEIRO;
INICIO
vezes <--0;
PARA x DE 1 ATE 10 FAÇA
INICIO
LEIA(a[x]);
LEIA(b[x]);
FIM;
FIMPARA;
PARA x DE 1 ATE 10 FAÇA
INICIO
y <--1;
ENQUANTO (y <= 10) FAÇA
INICIO
SE a[x] = b[y] ENTÃO
vezes <-- vezes + 1;
FIMSE;
y <--y + 1;
FIM;
FIMENQUANTO;
C[x] <-- vezes;
vezes <-- 0;
FIM;
FIMPARA;
FIM.
49
PASCAL:
PROGRAM vetores;
USES CRT;
TYPE
vet = ARRAY [1..10] OF REAL;
vet1= ARRAY [1..10] OF INTEGER;
VAR
a, b : vet;
c : vet1;
vezes, x, y : INTEGER;
BEGIN
vezes := 0;
FOR x := 1 TO 10 DO
BEGIN
READLN(a[x]);
READLN(b[x]);
END;
FOR x := 1 TO 10 DO
BEGIN
y := 1;
WHILE (y <= 10) DO
BEGIN
IF (a[x] = b[y]) THEN
vezes := vezes + 1;
y := y + 1;
END;
c[x] := vezes;
vezes := 0;
END;
END.
50
6- FAÇA um algoritmo que leia um vetor de 25 elementos numéricos reais. O número lido deverá ser único isto
é, sem repetição. Emita a mensagem "Número inválido" quando necessário.
ALGORITMO:
PROGRAMA sem_repetição;
num = VETOR [1..25] DE REAL;
vnum : num;
x, y, cont : INTEIRO;
INICIO
LEIA(vnum[1]);
PARA x DE 2 ATE 25 FAÇA
INICIO
cont <-- 0;
ENQUANTO (cont = 0) FAÇA
INICIO
LEIA(vnum[x]);
PARA y DE (x-1) ATE 1 PASSO -1 FAÇA
SE (vnum[x] = vnum[y]) ENTÃO
INICIO
cont <-- 1;
y <-- 1;
FIM;
FIMSE;
FIMPARA;
SE (cont = 1 ) ENTÃO
cont <--0;
SENÃO cont <--1;
FIMSE;
FIM;
FIMENQUANTO;
FIM;
FIMPARA;
FIM.
PASCAL:
PROGRAM sem_repetição;
USES CRT;
VAR
vnum = ARRAY [1..25] OF REAL;
x, y, cont : INTEGER;
BEGIN
READLN(vnum[1]);
FOR x := 2 TO 25 DO
BEGIN
cont := 0;
WHILE (cont = 0) DO
BEGIN
READLN(vnum[x]);
FOR y := (x-1) DOWNTO 1 DO
IF (vnum[x] = vnum[y]) THEN
BEGIN
cont := 1;
y := 1;
END;
IF (cont = 1 ) THEN
cont := 0
ELSE cont := 1;
END;
END;
END.
51
7- FAÇA um algoritmo que leia um vetor de 30 elementos e os coloque em ordem alfabética.
ALGORITMO:
PROGRAMA ordem;
vet = VETOR [1..30] DE INTEIRO;
a : vet;
chave, x, aux : INTEIRO
INICIO
PARA x DE 1 ATE 30 FAÇA
LEIA(a[x]);
FIMPARA;
chave <--0;
ENQUANTO (chave = 0) FAÇA
INICIO
PARA x DE 1 ATE 29 FAÇA
SE (a[x] > a[x+1] ) ENTÃO
INICIO
aux <-- a[x];
a[x] <-- a[x+1];
a[x+1] <-- aux;
chave <--1;
FIM;
FIMSE;
FIMPARA;
SE ( chave = 1 ) ENTÃO
chave <-- 0;
SENÃO ( chave <-- 1);
FIMSE;
FIM;
FIMENQUANTO;
PARA X DE 1 ATE 30 FAÇA
ESCREVA(a[x]);
FIMPARA;
FIM.
PASCAL:
PROGRAM ordem;
USES CRT;
VAR a: ARRAY [1..30] OF INTEGER;
chave, x, aux : INTEGER;
BEGIN
FOR x := 1 TO 30 DO
READLN (a[x]);
chave := 0;
WHILE (chave = 0) DO
BEGIN
FOR x := 1 TO 29 DO
IF (a[x] > a[x+1] ) THEN
BEGIN
aux := a[x];
a[x] := a[x+1];
a[x+1] := aux;
chave := 1;
END;
IF ( chave = 1 ) THEN
chave := 0
ELSE chave := 1;
END;
FOR x := 1 TO 30 DO
WRITELN(a[x]);
END.
52
5.1 PESQUISA BINÁRIA
8- Faça um algoritmo que efetue a pesquisa binária sobre um vetor de 100 elementos, já
preenchido.
ALGORITMO:
PROGRAMA pesqisa_binária;
inicio, fim, meio, n : INTEIRO;
vet = VETOR [1..100] DE INTEIRO;
a : vet;
INICIO
LEIA (n); {NUMERO PROCURADO}
inicio := 1;
fim := 100;
REPITA
meio <-- ((inicio + fim) DIV 2); { DIV resulta em um inteiro }
SE (n < a[meio] ) ENTÃO
fim <-- meio - 1;
SENÃO inicio <-- meio + 1;
FIMSE;
ATÉ ((a[meio] = n) OU (inicio > fim));
SE (a[meio] <> n) ENTÃO
ESCREVA ("ELEMENTO INEXISTENTE");
SENÃO ESCREVA("ELEMENTO EXISTE NO VETOR ");
FIMSE;
FIM.
PASCAL:
PROGRAM pesqisa_binária;
USES CRT;
VAR
inicio, fim, meio, n : INTEGER;
a : ARRAY [1..100] OF INTEGER;
BEGIN
READLN (n); {NUMERO PROCURADO}
inicio := 1;
fim := 100;
REPEAT
meio := ((inicio + fim) DIV 2); { DIV resulta um inteiro }
IF (n < a[meio] ) THEN
fim := meio - 1
ELSE inicio := meio + 1;
UNTIL ((a[meio] = n) OU (inicio > fim));
IF (a[meio] <> n) THEN
WRITELN (‘ELEMENTO INEXISTENTE’)
ELSE WRITELN (‘ELEMENTO EXISTE NO VETOR ‘);
END.
53
6. MODULARIZAÇÃO DE ALGORITMOS:
À medida que os algoritmos vão se tornando mais complexos, surge a necessidade de
modularizarmos eles.
Modularizar um algoritmo significa transforma-lo em vários algoritmos menores; facilitando a
compreensão, pois o problema é dividido em partes. Eventualmente um módulo do algoritmo
poderá resolver diversos problemas semelhantes, tornando-se um módulo genérico.
Ao modularizar um algoritmo, buscamos aumentar a legibilidade das partes que formam um
conjunto.
6.1 SUBALGORITMOS:
Um subalgoritmo comporta-se como qualquer outro algoritmo, tendo a sua estrutura igual a de
um algoritmo visto até agora.
ALGORITMO:
Sintaxe..: PROCEDURE <nome da procedure>;
Definição de variáveis;
INICIO
Corpo do programa;
FIM;
PASCAL:
Sintaxe..: PROCEDURE <nome da procedure>;
VAR
Definição de variáveis;
BEGIN
Corpo do programa;
END;
Exemplo:
ALGORITMO PASCAL
PROCEDURE Cálculo; PROCEDURE Cálculo;
x : INTEIRO; VAR
y : REAL; x : INTEGER;
INICIO y : REAL;
y <-- x**2/2; BEGIN
ESCREVA ("O valor de y é ", y); y := SQR(x)/2;
FIM; WRITELN (‘O valor de y é ‘, y);
END;
54
ALGORITMO PASCAL
PROGRAMA exemplo; PROGRAM exemplo;
Definição de variáveis do programa principal; USES CRT;
PROCEDURE Cálculo; VAR
INICIO Definição de variáveis do programa principal;
x : INTEIRO; PROCEDURE Cálculo;
y : REAL; BEGIN
LEIA (x); x : INTEGER;
y <-- x**2 / 2; y : REAL;
ESCREVA ("O valor de y é ", y); READLN (x);
FIM; y := SQR(x) / 2;
{ Aqui inicia o programa principal } WRITELN (‘O valor de y é ‘, y);
INICIO END;
ESCREVA ("Digite o valor de X:"); { Aqui inicia o programa principal }
Calculo; BEGIN
Resto do programa; WRITELN (‘Digite o valor de X:’);
FIM. Calculo;
Resto do programa;
END.
55
A variável “x”, sob o ponto de vista do programa principal é considerada uma variável global. Já
a variável “c”, para o programa principal é uma variável dita local. Mas para a procedure onde
ela está definida, é considerada como global.
ALGORITMO PASCAL
PROGRAMA passagem_por_valor; PROGRAM passagem_por_valor;
x : INTEIRO; USES CRT;
{Declaração de variáveis do programa VAR { Decl. de variáveis do programa
principal } principal }
PROCEDURE Cálculo (a : INTEIRO); x : INTEGER;
y : REAL; PROCEDURE Cálculo (a : INTEGER);
INICIO VAR
y <-- a**2 / 2; y : REAL;
ESCREVA ("O valor de y é ", y); BEGIN
FIM; y := SQR(a) / 2;
{ Aqui inicia o programa principal } WRITELN (‘O valor de y é ‘, y :
INICIO 2:2);
ESCREVA ("Digite o valor de X:"); END;
LEIA (x); { Aqui inicia o programa principal }
Cálculo(x); BEGIN
FIM. WRITELN (‘Digite o valor de X:’);
READLN (x);
Cálculo(x);
END.
56
6.4.2 - PASSAGEM DE PARÂMETROS POR REFERÊNCIA
Caracteriza-se pelo fato de um valor calculado dentro da procedure, poder ser utilizado pelo
programa principal (sem utilizar variáveis globais).
O resto comporta-se de forma igual a passagem de parâmetros por valor.
Exemplo:
ALGORITMO PASCAL
PROGRAMA passagem_por_referência; PROGRAM passagem_por_referência;
{ Definição de variáveis do programa principal } USES CRT;
x : INTEIRO; VAR
y : REAL; { Definição de variáveis do programa principal }
PROCEDURE Cálculo(a: inteiro; VAR b: real); x : INTEGER;
INICIO y : REAL;
b <-- a**2/2; PROCEDURE Cálculo(a: integer; VAR b: real);
FIM; BEGIN
{ Aqui inicia o programa principal } b := SQR(a) / 2;
INICIO END;
ESCREVA (“Digite o valor de x: “); { Aqui inicia o programa principal }
LEIA (x); BEGIN
Cálculo(x,y); WRITELN (‘Digite o valor de x: ‘);
ESCREVA (“O valor de y é “, y); READLN (x);
FIM. Cálculo(x,y);
WRITELN (‘O valor de y é ‘, y :2:2);
END.
* Obrigatoriamente deve ser utilizado VAR antes da variável que se quer que retorne o valor
* Separar parâmetros com ;
7. M A T R I Z E S:
1 2 3 4 5 6 7 8 9 10
1200
preço[6] = 1200
Admitindo a hipótese de que além dos preços nós tivéssemos que armazenar as quantidades
em estoque de cada produto. Como seria solucionado ?
1 2 3 4 5 6 7 8 9
10
1200
230
57
Temos agora não mais um vetor unidimensional mas sim um vetor bidimensional, a quem
chamamos de MATRIZ.
Um determinado elemento para ser acessado deve possuir dois índices : linha e coluna.
ALGORITMO:
SINTAXE..: IDENTIFICADOR = MATRIZ [Li..Lf,Li1..Lf1] DE <TIPO>;
LISTA DE VARIÁVEIS : IDENTIFICADOR;
PASCAL:
SINTAXE..: TYPE
IDENTIFICADOR = ARRAY [Li..lf, Li..Lf] OF <TIPO>;
VAR
VARIÁVEL : IDENTIFICADOR;
ou,
SINTAXE..: VAR
IDENTIFICADOR : ARRAY[[Li..Lf, Li..Lf] OF <TIPO>;
Onde:
IDENTIFICADOR : o novo tipo que está sendo criado.
Li : o limite inicial da linha da matriz.
Lf : o limite final da linha da matriz.
Li1: o limite inicial da coluna da matriz.
Lf1: o limite final da coluna da matriz.
TIPO : qualquer um dos tipos primitivos já conhecidos.
LISTA DE VARIÁVEIS: Identifica a(s) variáveis que serão do tipo matriz, ou
não.
Exemplo:
ALGORITMO PASCAL
mat = MATRIZ [1..2,1..4] DE REAL; TYPE
a : mat; mat = ARRAY [1..2,1..4] OF REAL;
b : INTEIRO; VAR
a : mat;
b : INTEGER;
ou
VAR
mat : ARRAY[1..2,1..4] OF REAL;
b : INTEGER;
58
1 2 3 4
1 4 4.5 1.2 98.5
2 6 8.9 0.5 3.56
a[1,1] = 4
a[1,2] = 4,5
a[1,3] = 1,2
a[1,4] = 98,5
a[1,5] = ERRADO
a[2,1] = 6
a[2,2] = 8,9
a[2,3] = 0,5
a[2,4] = 3,56
No exemplo acima fica claro que para acessarmos um determinado elemento necessitamos do
número da linha e coluna do mesmo.
2- Elabore um algoritmo que leia uma matriz 2x5 e escreva o total de números pares
encontrados.
ALGORITMO:
PROGRAMA matriz25;
mat = MATRIZ[1..2,1..5] DE INTEIRO;
a : mat;
l, c, cont : INTEIRO;
INICIO
cont <-- 0;
PARA l DE 1 ATE 2 FAÇA
PARA C DE 1 ATÉ 5 FAÇA
INICIO
LEIA(a[l,c]);
SE (a[l,c] MOD 2 = 0) ENTÃO
cont <-- cont + 1;
FIMSE;
FIM;
FIMPARA;
FIMPARA;
ESCREVA ("FORAM ENCONTRADOS ",cont, “NÚMEROS PARES");
FIM.
59
PASCAL:
PROGRAM matriz25;
USES CRT;
TYPE
mat = ARRAY [1..2,1..5] OF INTEGER;
VAR
a : mat;
l, c, cont : INTEGER;
BEGIN
cont := 0;
FOR l := 1 TO 2 DO
FOR C := 1 TO 5 DO
BEGIN
READLN (a[l,c]);
IF (a[l,c] MOD 2 = 0) THEN
cont := cont + 1;
END;
WRITELN (‘FORAM ENCONTRADOS ‘,cont, ’NÚMEROS PARES’);
END.
3- Dada uma matriz quadrada (l = c) FAÇA um algoritmo para escrever somente os elementos
da diagonal principal de uma matriz de 16 elementos.
ALGORITMO PASCAL
PROGRAMA matiz_quadrada; PROGRAM matiz_quadrada;
mat = MATRIZ [1..4,1..4] DE INTEIRO; USES CRT;
a : mat; TYPE
l, c : INTEIRO; mat = ARRAY [1..4,1..4] OF INTEGER;
INICIO VAR
PARA l DE 1 ATÉ 4 FAÇA a : mat;
PARA c DE 1 ATÉ 4 FAÇA l, c : INTEGER;
SE (l = c) ENTÃO BEGIN
ESCREVA(a[l,c]); FOR l := 1 TO 4 DO
FIMSE; FOR c := 1 TO 4 DO
FIMPARA; IF (l = c) THEN
FIMPARA; WRITELN(a[l,c]);
FIM. END.
60
4- Admitindo-se uma matriz 3x5, FAÇA um algoritmo que percorra esta matriz e acumule
somente os elementos que estão em índices ímpares.
ALGORITMO PASCAL
PROGRAMA índices_ímpares; PROGRAM índices_ímpares;
mat = MATRIZ [1..3,1..5] DE INTEIRO; USES CRT;
a : mat; TYPE
l, c, acum : INTEIRO; mat = ARRAY [1..3,1..5] OF INTEGER;
INICIO VAR
acum <-- 0; a : mat;
PARA l DE 1 ATÉ 3 PASSO 2 FAÇA l, c, acum : INTEGER;
PARA c DE 1 ATÉ 5 PASSO 2 FAÇA BEGIN
acum <-- acum + a[l,c]; acum := 0;
FIMPARA; l := 1;
FIMPARA; c := 1;
ESCREVA("TOTAL--- > ",acum); WHILE (l <= 3) DO
FIM. BEGIN
WHILE (c <= 5 )DO
BEGIN
acum := acum + a[l,c];
c := c + 2;
END;
l := l + 2;
END;
WRITELN (‘TOTAL : ‘,acum);
END.
5- Faça um algoritmo que leia duas matrizes 6x7 e crie uma terceira com o resultado da
multiplicação das duas matrizes lidas imprimindo a mesma.
ALGORITMO PASCAL
PROGRAMA mat67; PROGRAM mat67;
mat = MATRIZ [1..6,1..7] DE INTEIRO; USES CRT;
a, b, d : mat; TYPE
l, c : INTEIRO; mat = ARRAY [1..6,1..7] OF INTEGER;
INICIO VAR
PARA l DE 1 ATE 6 FAÇA a, b, d : mat;
PARA c DE 1 ATÉ 7 FAÇA l, c : INTEGER;
INICIO BEGIN
LEIA (a[l,c]]); FOR l := 1 TO 6 DO
LEIA (b[l,c]); FOR c := 1 TO 7 DO
d[l,c] <-- a[l,c] * b[l,c]; BEGIN
FIM; READLN (a[l,c]);
FIMPARA; READLN (b[l,c]);
FIMPARA; d[l,c] := a[l,c] * b[l,c];
PARA l DE 1 ATÉ 6 FAÇA END;
PARA c DE 1 ATÉ 7 FAÇA FOR l := 1 TO 6 DO
ESCREVA(d[l,c]); FOR c := 1 TO 7 DO
FIMPARA; WRITELN (d[l,c]);
FIMPARA; END.
FIM.
61
6- Faça um algoritmo que leia 50 nomes de alunos, seus respectivos graus parciais (3) e crie um
vetor com as médias. O algoritmo deverá escrever, ao final, o nome do aluno, sua média e o
conceito aprovado ou reprovado.
MÉDIA >= 7 APROVADO
ALGORITMO PASCAL
PROGRAMA média50; PROGRAM média50;
vet = VETOR[1..50] DE REAL; USES CRT;
vet1= VETOR[1..50] DE CARACTER; TYPE
mat = MATRIZ[1..50,1..3] DE REAL; vet = ARRAY [1..50] OF REAL;
nome : vet1; vet1= ARRAY [1..50] OF STRING;
notas: mat; mat = ARRAY [1..50,1..3] OF REAL;
média: vet; VAR
l, c : INTEIRO; nome : vet1;
acum : REAL; notas: mat;
INICIO média: vet;
PARA l DE 1 ATÉ 50 FAÇA l, c : INTEGER;
INICIO acum : REAL;
LEIA(nome[l]); BEGIN
acum <-- 0; FOR l := 1 TO 50 DO
PARA c DE 1 ATÉ 3 FAÇA BEGIN
INICIO READLN (nome[l]);
LEIA(notas[l,c]); acum := 0;
acum <-- acum + notas[l,c]; FOR c := 1 TO 3 DO
FIM; BEGIN
FIMPARA; READLN (notas[l,c]);
média [l] <-- acum/3; acum := acum + notas[l,c];
FIM; END;
FIMPARA; média [l] := acum/3;
PARA l DE 1 ATÉ 50 FAÇA END;
INICIO FOR l := 1 TO 50 DO
ESCREVA (nome[l]); BEGIN
ESCREVA(média[l]); WRITELN (nome[l]);
SE (média[l] >= 7) ENTÃO WRITELN (média[l]);
ESCREVA ("APROVADO"); IF (média[l] >= 7) THEN
SENÃO WRITELN (‘APROVADO’)
ESCREVA ("REPROVADO"); ELSE
FIMSE; WRITELN (‘REPROVADO’);
FIM; END;
FIMPARA; END.
FIM.
62
7- Na teoria de sistemas define-se como elemento minimax de uma matriz, o menor elemento da
linha em que se encontra o maior elemento da matriz. Escrever o algoritmo que verifique na
matriz 10x10 o elemento minimax.
ALGORITMO PASCAL
PROGRAMA minimax; PROGRAM minimax;
mat = MATRIZ[1..10,1..10] DE INTEIRO; USES CRT;
a : mat; TYPE
mini, l, c, laux, maior : INTEIRO; mat = ARRAY [1..10,1..10] OF INTEGER;
INICIO VAR
maior <-- a[1,1]; a : mat;
laux <-- 0; mini, l, c, laux, maior : INTEGER;
PARA l DE 1 ATÉ 10 FAÇA BEGIN
PARA c DE 1 ATÉ 10 FAÇA maior := a[1,1];
SE ( a[l,c] > maior) ENTÃO laux := 0;
INICIO FOR l := 1 TO 10 DO
laux <-- l; FOR c := 1 TO 10 DO
maior <-- a[l,c]; IF ( a[l,c] > maior) THEN
FIM; BEGIN
FIMSE; laux := l;
FIMPARA; maior := a[l,c];
FIMPARA; END;
mini <-- a[laux,1]; mini := a[laux,1];
PARA c DE 1 ATÉ 10 FAÇA FOR c := 1 TO 10 DO
SE (a[laux,c] < mini) ENTÃO IF (a[laux,c] < mini) THEN
mini <-- a[laux,c]; mini := a[laux,c];
FIMSE; WRITELN(‘O ELEMENTO MINIMAX ‘,
FIMPARA; mini);
ESCREVA("O ELEMENTO MINIMAX ", END.
mini);
FIM.
63
8- Escreva um algoritmo que leia uma matriz 7x8, a seguir divida cada um dos oito números da
linha pelo maior número da linha. Escreva a matriz lida e a matriz transformada.
Utilize um vetor de 7 posições para armazenar o maior número.
ALGORITMO PASCAL
PROGRAMA maior_número; PROGRAM maior_número;
mat = MATRIZ[1..7,1..8] DE REAL; USES CRT;
vet = VETOR [1..7] DE REAL; TYPE
a, b : mat; mat = ARRAY [1..7,1..8] OF REAL;
v : vet; vet = ARRAY [1..7] OF REAL;
l, c : INTEIRO; VAR
INICIO a, b : mat;
PARA l DE 1 ATÉ 7 FAÇA v : vet;
PARA c DE 1 ATÉ 8 FAÇA l, c: INTEGER;
LEIA(a[l,c]); BEGIN
FIMPARA; FOR l := 1 TO 7 DO
FIMPARA; FOR c := 1 TO 8 DO
PARA l DE 1 ATÉ 7 FAÇA READLN (a[l,c]);
v[l] <-- a[l,1]; FOR l := 1 TO 7 DO
FIMPARA; v[l] := a[l,1];
PARA l DE 1 ATÉ 7 FAÇA FOR l := 1 TO 7 DO
PARA c DE 1 ATÉ 8 FAÇA FOR c := 1 TO 8 DO
SE (a[l,c] > v[l] ) ENTÃO IF (a[l,c] > v[l] ) THEN
v[l] <-- a[l,c]; v[l] := a[l,c];
FIMSE; FOR l := 1 TO 7 DO
FIMPARA; FOR c := 1 TO 8 DO
FIMPARA; b[l,c] := a[l,c] / v[l];
PARA l DE 1 ATÉ 7 FAÇA FOR l := 1 TO 7 DO
PARA c DE 1 ATÉ 8 FAÇA FOR c := 1 TO 8 DO
b[l,c] <-- a[l,c] / v[l]; BEGIN
FIMPARA; WRITELN (‘MATRIZ’ , a[l,c]:2:2);
FIMPARA; WRITELN (‘TRANSFORMADA
PARA l DE 1 ATÉ 7 FAÇA ‘ , b[l,c]:2:2);
PARA c DE 1 ATÉ 8 FAÇA END;
INICIO END.
ESCREVA("MATRIZ " , a[l,c]);
ESCREVA("TRANSFORMADA
" , b[l,c]);
FIM;
FIMPARA;
FIMPARA;
FIM.
64
8. LISTA DE EXERCÍCIOS:
2 - Duas tartarugas possuem 3,1 e 4,5 cm respectivamente. A menor tartaruga cresce 0,21 cm ao
ano e a maior 0,16 cm ao ano.
Faça um algoritmo que calcule o número de anos necessários para que a tartaruga menor fique
maior que a maior atualmente.
3 - Faça um algoritmo que leia um número e escreva a soma de todos números menores e não
múltiplos.
4 - Dado dois times de basquete, com cinco componentes cada, sendo dois alas, dois pivôs e um
armador para cada time. Faça um algoritmo que leia os seguintes dados: nome do jogador, nome
do time, número de pontos de cada uma das três partidas anteriores. O algoritmo deve selecionar
um "DREAM TEAM" ou seja o melhor em cada posição.
É considerado o melhor na posição aquele com uma média melhor de "cestas".
O algoritmo deve prever os seguintes detalhes...
a) A posição dos jogadores na hora em que for feita a comparação deve ser igual.
b) Uma vez lidos por exemplo os dois pivôs, o algoritmo não deverá aceitar a comparação entre
pivôs novamente.
c) Não esqueça que são cinco jogadores para cada lado.
5 - Faça um algoritmo que escreva todas as combinações possíveis de números da SENA. Obs.:
O cartão é numerado de 00 a 49.
7 - Um certo edifício possui um número ilimitado de andares. Este edifício possui quatro
elevadores A, B, C, D, que são usados livremente. Foi feito uma pesquisa entre os usuários com
o objetivo de atingir-se uma otimização na utilização de elevadores.
Os usuários responderam as seguintes questões:
Qual elevador que ele utiliza
Qual o turno, seguindo os códigos Manhã, Tarde e Noite.
O algoritmo deve fornecer o elevador mais usado, o menos usado, qual turno em que os
elevadores são mais utilizados e a diferença percentual entre o mais usado e o menos utilizado.
O algoritmo encerra com um tipo de elevador inválido.
8 - Faça um algoritmo que leia números Dia, Mês, Ano respectivamente ou seja uma data
qualquer e faça a consistência desta data(se é válida ou não).
O algoritmo deve prever ano bissexto(divida por quatro se der inteiro é bissexto).
65
9 - Dados os valores de X e Y fazer o algoritmo:
a) Se X for maior que Y calcular e imprimir Z=(X+Y)
3X
b) Se X for menor ou igual a Y calcular e imprimir Z = X(Y-X)
11 - Dados vários valores numéricos fazer o algoritmo que determine a soma dos números pares
e a soma dos números ímpares fornecidos.
12 - Considerando a altura dos N alunos de uma turma faça o algoritmo para calcular a média
das alturas e determinar a quantidade de alunos com alunos com altura > 1,60m e < 1,75m.
13 - Um banco utiliza recursos computacionais para efetuar suas transações uma das
necessidades bancárias é saber o total de dinheiro que o banco girou durante o dia. Para tanto a
cada débito ou crédito que o caixa executa é digitado o respectivo valor sendo que o débito
ésempre precedido do sinal negativo. Faça o algoritmo para calcular o total de créditos, débitos e
o total global em valor absoluto.
16 - Para uma competição esportiva foi feito um levantamento entre os 80 atletas participantes e
coletados as seguintes informações: SEXO, PESO, IDADE, ALTURA
O algoritmo deverá representar a solução dos seguintes itens:
a) Calcula o número de atletas do sexo masculino
b) Determinar a média dos pesos das atletas de sexo feminino
c) Determinar o número de atletas com idade entre 15 e 18 anos
d) Calcula o número de atletas com idade > 18 anos, peso superior a 65 Kg e altura maior que
1,65m.
17 - Faça um algoritmo que calcule o preço de um produto a partir do seu preço unitário e da
quantidade a ser adquirida.
66
19 - Fazer um algoritmo que calcula o preço à vista e preço no cartão de crédito de uma
mercadoria. Sendo que sobre o preço à vista é dado um desconto e para o pagamento a prazo é
embutido acréscimo de 30% sobre o preço da mercadoria.
20 - Construa um algoritmo que calcule a quantidade de latas de tinta necessárias e o custo para
pintar tanques cilíndricos de combustível, onde são fornecidas a altura e o raio desse cilindro.
Sabendo que:
- a lata de tinta custa R$ 5,00
- cada lata contém 5 litros
- cada litro de tinta pinta 3m2
21 - Faça um algoritmo para calcular as raízes de uma equação do segundo grau, sendo que os
valores A, B e C são fornecidos pelo usuário.
23 - Faça um programa que lê o código da peça 1, o número de peças 1, o valor unitário da peça
1, faça o mesmo para a peça 2 e calcula o valor total a ser pago.
67
APÊNDICE A - Editor Pascal
NEW - Cria um arquivo novo e abre uma nova janela. Antes de ser salvo, este novo arquivo tem
o nome de NONAME__, onde __ corresponde a uma seqüência numérica iniciada em 00.
OPEN (F3) - Permite a abertura de um ou mais arquivos previamente gravados. Através de uma
caixa de diálogo é possível selecionar o nome do arquivo a ser aberto.
SAVE (F2) - Salva uma listagem de programa. Caso este arquivo for novo, então será aberta
uma caixa de diálogo onde será necessário um nome para este novo arquivo. Caso contrário, o
arquivo será simplesmente atualizado no disco com o nome anterior. A extensão default do
Pascal é *.PAS.
SAVE AS - Um arquivo novo deverá ser salvo pela primeira vez nesta opção, onde é possível
dar um nome ao arquivo. Se o arquivo já tiver sido salvo alguma vez é possível salvá-lo com
outro nome, drive ou diretório.
SAVE ALL - Salva todos os arquivos modificados, solicitando um novo nome sempre que
houver um com o nome de “NONAME”.
CHANGE DIR - Troca o diretório default, permite que através de uma janela seja escolhido o
nome do novo diretório.
PRINTER SETUP - Permite alterar o filtro do dispositivo de saída para impressão. Deve ser
mudado o programa PRNFLTR.PAS . Os parâmetros são:
/ EPSON - Para impressora padrão EPSON.
/ HP - Para impressora padrão HP LaserJet.
/ PS - Para impressoras com cartucho PostScript.
/ ASCII - Elimina os códigos “highlight” (Default).
/ Lxx - Linhas por página (Default 55).
/ Txx - Tamanho da tabulação (Default 8).
/ O[arquivo] - Saída para arquivo ou dispositivo (Default LPT1).
Na opção “Send highlighting escape codes “ informa se serão ou não enviados para a
impressora os códigos de controle de caracteres especiais.
DOS SHELL - Permite um saída temporária para o DOS. Para retornar ao Turbo Pascal, basta
digitar EXIT no Prompt do DOS.
EXIT (Alt - X) - Finaliza a sessão do Turbo Pascal. Caso algum arquivo não tiver sido salvo, é
apresentada uma caixa de diálogo onde é permitida esta ação.
68
MENU EDIT - (Alt - E)
COPY (Crtl - Ins) - Copia o texto para a área de transferência. O texto não é removido do
arquivo.
CLEAR (Crtl - Del) - Remove o texto sem enviá-lo para a área de transferência,
impossibilitando assim, a sua recolocação no arquivo.
SHOW CLIPBOARD - Mostra a janela da área de transferência. A parte do texto que estiver
marcada é a que pode ser usada pelo comando Paste.
FIND (Crtl - QF) - Permite uma procura no programa através de uma palavra inteira ou pedaço
dela. Estas opções estão definidas na caixa de diálogo Find.
REPLACE (Crtl - QA) - Permite que uma palavra seja substituída rapidamente.
Onde: “Text to Find” - Texto a ser encontrado;
“New Text” - Texto pelo qual a palavra será substituída.
SEARCH AGAIN (Crtl - L) - Permite que seja repetido o último comando de busca ou de
troca, inclusive com os mesmos efeitos.
GO TO LINE NUMBER - Permite uma movimentação rápida dentro do arquivo. Basta digitar
a página a ser encontrada.
SHOW LAST COMPILER ERROR - Este comando só está disponível quando ocorre um erro
de compilação. Neste caso, a mensagem de erro está no topo da tela e o cursor na posição dele.
FIND ERROR - Este comando permite que se encontre um erro apenas pelo seu endereço. Se
houver movimentação do cursor após localizar o erro, basta que se pressione a combinação de
teclas Crtl - QW para retornar ao último erro localizado.
FIND PROCEDURE - Este comando só está disponível durante a depuração do programa. Ele
permite que se ache uma procedure.
69
MENU RUN ( Alt - R )
TRACE INTO (F7) - Executa um programa linha a linha, permitindo a sua depuração. a linha
que estiver sendo executada aparecerá em reverso.
PARAMETERS - Permite que seja passado um parâmetro. É aberta uma caixa de diálogo onde
constam os últimos parâmetros digitados.
COMPILE (Alt - F9) - Permite a compilação do programa que estive na janela ativa do editor.
Ao final da compilação basta pressionar uma tecla para remover a tela de compilação. Se houver
algum erro, a descrição fica no canto superior direito da tela e o cursor se posiciona geralmente
uma linha abaixo do erro.
BUILD - Compila o programa e todos os que estiverem ligados a ele. A diferença do Build e do
Make, é que neste último apenas os arquivos alterados são recompilados, e no Build todos são.
DESTINATION - Se o destino for disk (disco) através do comando Make, é criada uma versão
executável do programa.
PRIMARY FILE - Permite determinar qual será o arquivo principal, ou seja, aquele que será
carregado em primeiro lugar pelo Make ou pelo Build. Se a compilação for feita pelo Alt-F9, o
primeiro arquivo não terá efeito.
INFORMATION - É aberta uma caixa de diálogo onde são mostradas as informações dos
último programa compilado em memória.
70
DEBUG (Alt - D)
BREAKPOINTS (Crtl - F8) - Marca um ponto no programa e faz com que este, durante a
execução, pare ali.
CALL STACK (Crtl - F3) - É aberta uma janela onde são mostradas as seqüências de
chamadas de rotinas, exibindo seus nomes e valores passados como parâmetros.
REGISTER - Abre uma janela onde são mostrados os registradores e os “flags” da CPU.
WATCH - Coloca a janela “Watches” como ativa. Através dela, podemos acompanhar o
comportamento das variáveis do programa.
OUTPUT - É aberta uma janela onde será exibida a tela de saída, somente no modo texto.
SER SERENE (Alt - F5) - É exibida a tela do usuário, tanto no modo texto como no modo
gráfico. Para retornar ao ambiente do Turbo Pascal, basta pressionar uma tecla ou com um
clique do mouse.
EVALUTE / MODIFY (Crtl - F4) - Avalia expressões, constantes ou variáveis. Além destas,
também podemos usar expressões do próprio Pascal.
TOOLS (Alt - T)
GREP (Shift - F3) - O programa grep.exe permite que se procurem seqüências de caracteres em
programas no disco.
71
MENU OPTIONS (Alt - O)
LINKER - No Turbo Pascal, quando é criada a versão executável do programa, o Link elimina
todos os códigos que não são usados.
DEBUGGER - Através de uma caixa de diálogo são estabelecidos os critérios para depuração
de um programa.
SAVE - Permite que seja salvo o arquivo que tem o ambiente do Turbo Pascal. Normalmente o
arquivo chama-se TURBO.TP.
SAVE AS - Permite que o arquivo de ambiente do turbo Pascal seja salvo, mas com nome
diferente de TURBO.TP.
CASCADE - permite o reordenamento das janelas abertas. Somente a janela ativa ficará
inteiramente visível, as demais, ficarão apenas com as bordas aparentes.
SIZE / MOVE (Crtl - F5) - Altera o tamanho de uma janela pressionando-se a combinação de
setas com a tecla Shift.
ZOOM (F5) - Altera o tamanho de uma janela para o seu tamanho máximo, ou para um
tamanho previamente estabelecido.
72
CLOSE - Fecha a janela ativa. Se houver necessidade, uma caixa de diálogo aparecerá,
permitindo que o arquivo seja salvo.
LIST (Alt - O) - Abre uma janela onde é mostrada uma lista contendo todas as janelas abertas
e permitindo que se altere a ativa.
CONTENTS - Lista os conteúdos a serem pesquisados. Por exemplo, podemos através da tecla
TAB, com as setas, com o mouse ou ainda digitando as iniciais da palavra iniciar uma pesquisa
por ali. Exemplo: digitando-se a letra D, o help listara todas as palavras que começam com D.
Podemos ser ainda mais precisos, digitando-se DE, o help listará apenas as palavras que
começam com DE.
TOPIC SEARCH (Crtl - F1) - Permite que uma palavra detectada no texto seja procurada no
help.
73
APÊNDICE B - Comandos Básicos
UNIT CRT:
74
BIBLIOGRAFIA :
75