Você está na página 1de 76

ALGORITMOS

2
SUMÁRIO

SUMÁRIO.........................................................................................................................................
1. CONCEITOS BÁSICOS:..............................................................................................................
1.1 Virtudes de um bom algoritmo:................................................................................................
1.2 TIPOS DE DADOS:................................................................................................................
1.2.1 - C O N S T A N T E:........................................................................................................
1.2.2 - V A R I Á V E L:...........................................................................................................
1.3 FORMAÇÃO DE IDENTIFICADORES:...............................................................................
1.4 TIPOS PRIMITIVOS:.............................................................................................................
1.4.1 - INTEIRO:.......................................................................................................................
1.4.2 - REAL:............................................................................................................................
1.4.3 - CARACTER:..................................................................................................................
1.4.4 - LÓGICO:........................................................................................................................
1.6 COMENTÁRIOS:...................................................................................................................
1.7 EXPRESSÕES ARITMÉTICAS:...........................................................................................
1.7.1 OPERADORES ARITMÉTICOS:...................................................................................
1.8 FUNÇÕES MATEMÁTICAS:................................................................................................
1.9 PRIORIDADES:......................................................................................................................
1.10 - EXPRESSÕES LÓGICAS :................................................................................................
1.11 - RELAÇÃO:.........................................................................................................................
1.11.1 - OPERADORES RELACIONAIS SÍMBOLO............................................................
1.11.2 - OPERADORES LÓGICOS.........................................................................................
1.12 TABELA VERDADE:..........................................................................................................
1.12.1 - Prioridades entre os operadores lógicos:......................................................................
1.13 PRIORIDADE Entre todos os operadores...........................................................................
1.14 COMANDO DE ATRIBUIÇÃO:..........................................................................................
2. COMANDOS DE ENTRADA E SAÍDA:.....................................................................................
2.1 ENTRADA DE DADOS........................................................................................................
2.2 SAÍDA DE DADOS...............................................................................................................
3. ESTRUTURA DO ALGORITMO:................................................................................................
3.1 ESTRUTURA SEQÜENCIAL:...............................................................................................
3.1.1 - BLOCOS: Tem a finalidade de definir os limites do algoritmo.......................................
4. COMANDOS:................................................................................................................................
4.1 COMANDOS DE SELEÇÃO IF:............................................................................................
4.1.1 - SELEÇÃO SIMPLES:...................................................................................................
4.1.2 - SELEÇÃO COMPOSTA:..............................................................................................
4.1.3 - SELEÇÃO ENCADEADA:...........................................................................................
4.1.4 - SELEÇÃO DE MÚLTIPLA ESCOLHA:....................................................................
4.2 COMANDOS DE REPETIÇÃO:...........................................................................................
4.2.1 - REPETIÇÃO COM VARIÁVEL DE CONTROLE (PARA):.......................................
4.2.2 - REPETIÇÃO COM TESTE NO INÍCIO (ENQUANTO):.........................................
4.2.3 - REPETIÇÃO COM TESTE NO FINAL (REPITA):..................................................
5. VETORES....................................................................................................................................
5.1 PESQUISA BINÁRIA............................................................................................................
6. MODULARIZAÇÃO DE ALGORITMOS:.................................................................................
6.1 SUBALGORITMOS:.............................................................................................................
6.2 ESCOPO DE VARIÁVEIS.....................................................................................................
6.3 MANIPULAÇÃO DE MÓDULOS........................................................................................
6.4 Subalgoritmos com parâmetros...............................................................................................
6.4.1 - PASSAGEM DE PARÂMETROS POR VALOR...........................................................
6.4.2 - PASSAGEM DE PARÂMETROS POR REFERÊNCIA...............................................

3
7. M A T R I Z E S:............................................................................................................................
8. LISTA DE EXERCÍCIOS:.........................................................................................................
APÊNDICE A - Editor Pascal............................................................................................................
APÊNDICE B - Comandos Básicos..................................................................................................
BIBLIOGRAFIA :..............................................................................................................................

4
1. CONCEITOS BÁSICOS:

LÓGICA: é o estudo dos pensamentos corretos. É a forma de pensar através de um


raciocínio coerente e correto.

A lógica pode ser atribuída à mente de Aristóteles, que sistematizou e codificou o assunto
de tal modo que não foi significativamente ultrapassado por mais de dois milênios.

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.

Do ponto de vista da ciência da computação(lógica computacional), que se trabalha com o


sentido semântico dos operadores lógicos (princípio de bivalência - verdade, falso) a lógica formal
predomina.

Segundo o dicionário Aurélio, lógica significa "coerência de raciocínio, de idéias. Modo


de raciocinar peculiar a alguém, ou a um grupo. Seqüência coerente, regular e necessária de
acontecimentos, de coisas."

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.

5
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.

Miller, Galanter e Pribram (1960) introduziram um exemplo popular de sistema de retro-


alimentação para descrever os processos ao se pregar um prego. Escrito como um algoritmo de
computador (uma seqüência de passos lógicos) os processos poderiam estar em forma de uma
lista a ser lida de alto a baixo:

a: Teste o prego. Se ele se apoiar vá para b; caso contrário, pare.


b: Teste o martelo. Estando deitado, erga-o; caso contrario, vá para c.
c: Bata o prego
d: Vá para a.

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.

Raciocínio Lógico: é a forma de resolver os problemas coerentemente.

Vamos expor a seguinte charada !!!

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:

Na margem de um rio encontram-se três missionários e três canibais, os quais devem ir


para a outra margem, para isso deve-se seguir as seguintes regras para a resolução do problema:

- O barco não navega sozinho, um dos seis envolvidos deve remá-lo;


- Não pode em hipótese alguma o número de canibais superar os missionários, pois os
canibais devorariam os missionários. O contrario é permitido e o empate também.

6
- O barco suporta no máximo duas pessoas por viagem.

Tente seguindo o modelo de resolução anterior. Faça com palitos de fósforo.

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

ALGORITMO: um conjunto finito de ações em uma determinada ordem que obedecidas


atingem um objetivo em um tempo finito.
É um conjunto de passos lógicos para a solução de um problema.
É uma seqüência finita de passos lógicos escrito numa linguagem natural, em caso
particular uma pseudo-linguagem.

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

Exemplo prático: Troca de uma lâmpada, pneu, receita de bolo.

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
7
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.

Basicamente basta você conhecer quatro partes de uma linguagem de computador:


Sintaxe (estrutura), Semântica(significado, sentido), Verbos (ação) e Símbolos.

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."

Bem rápido responda o que é "Manga"


Errou !!! Acertou !!!	

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

Conclui-se que Thessaly é mais velha que Thamna, se as idades permanecerem as


mesmas. Caso altere-se as idades ocorrerá um erro semântico, pois o entendimento da afirmação
está errada.

Portanto, semântica estuda o significado das palavras ou frases.

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).
Nas linguagens de computador existem verbos, ou em outras palavras, ações que você
8
manda ele executar, como: Leia do disco ou teclado, Escreva na tela ou impressora ...

O que são Símbolos?


São os sinais ou figuras usadas na escrita para que possamos compreender os
verbos,obedecendo a uma sintaxe e a semântica.

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.

Assim os franceses comunicam-se através de uma linguagem natural própria, os índios


do Xingu tem a sua, nós possuímos a nossa, e cada povo tem a sua. Cada língua tem uma sintaxe,
uma semântica, seus verbos próprios e seus símbolos.

No computador não poderia ser diferente. O computador entende várias linguagens


como: Pascal, Assembler, C++, Java, Cobol, Delph, Prolog etc, e cada uma dessas linguagens tem
uma sintaxe, uma semântica, seus verbos e seus símbolos. Nós dissemos linguagem de
programação porque estas possuem sintaxe e semântica precisas, permitindo que cada
declaração/comando tenham estrutura e significados únicos.

Para nós que nos embrenharemos no mundo da lógica, primeiramente aprenderemos


lógica na nossa linguagem, isto é, em nossa linguagem natural, e depois traduziremos para uma
linguagem que o computador entenda.

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 Objeto: depois de compilado o seu Programa-Fonte, ele está em linguagem


de Máquina e recebe o nome de Programa-Objeto (linguagem de máquina propriamente
9
dita).
Linkagem: é o passo seguinte, onde é feito uma ligação de arquivos externos e o
programa objeto gerado pela compilação, gerando um programa que possa se executado
(Programa Executável).

Programa Executável: é um programa que pode ser ativado quando desejado, pelo seu
nome.exe.

Nosso objetivo é a construção de Algoritmos, para que possamos aprender a lógica


computacional. Os demais passos se aprende numa cadeira específica de Linguagem de
Programação.

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.1 Virtudes de um bom algoritmo:

 LEGIBILIDADE: É a compreensão do algoritmo por qualquer pessoa (que não o construiu),


é a clareza com que a lógica está exposta.

 PORTABILIDADE: Devido ao grande número de linguagens de programação, o algoritmo


não deve ser feito orientado a uma determinada linguagem de programação.
Sendo assim, não teremos dificuldade no momento de implementá-lo em uma linguagem
diferente da que este algoritmo foi construído originalmente.
O algoritmo deve se preocupar-se apenas com a lógica do problema e a sua resolução; sendo
escrito em português.

1.2 TIPOS DE DADOS:

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

1.3 FORMAÇÃO DE IDENTIFICADORES:

10
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:

1. A primeira letra deve ser um caractere alfabético;


2. Podem ser seguidos por caracteres alfanuméricos;
3. Caracteres especiais não são válidos.

Ex. X, DÓLAR, CUB, UFIR, A, RA91, EXAME


INVÁLIDOS --- > 5BJ, CUB%, X$, PTR#

11
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.

12
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

1.5 DECLARAÇÃO DE VARIÁVEIS: As variáveis ao serem declaradas devem indicar o seu


tipo primitivo (inteiro, real, caracter, lógico).
O nome escolhido(identificador) associado com a respectiva posição de memória que o
mesmo passa a representar. Uma vez declarada a variável, qualquer referência ao identificador
(nome escolhido) implica a referência ao conteúdo do local da memória representado.

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}

13
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;

1.7.1 OPERADORES ARITMÉTICOS:

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

1.8 FUNÇÕES MATEMÁTICAS:

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
14
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

1.10 - EXPRESSÕES LÓGICAS :


Na construção de um algoritmo surgem situações em que a execução de uma ação depende de
uma ou mais condições.
Esta condição é expressa no texto do algoritmo por meio de uma expressão lógica.

15
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:

1.11.1 - OPERADORES RELACIONAIS SÍMBOLO

IGUAL =
DIFERENTE <>
MAIOR QUE >
MENOR QUE <
MAIOR OU IGUAL >=
MENOR OU IGUAL <=
CONTIDO EM IN

Importante!! O resultado obtido será sempre um valor lógico, ou seja F ou V.


Exemplo.
a) 4*6 = 3*8
8 = 8
V

b) int(23 / 4) * 4 + 6mod5 <= 9.6 + frac(4.2)


20 + 1 <= 11.6
21 <= 11.6
F

1.11.2 - OPERADORES LÓGICOS

ALGORITMO PASCAL
E AND
OU OR
XOU XOR
NÃO NOT

16
1.12 TABELA VERDADE:
Exprime todas as combinações possíveis entre os valores de diversas variáveis lógicas.

Operador E(.) Operador OU(+) Operador XOU() Operador NÃO(~)


----------- ----------- ------------ ------------
VeV= V V ou V = V V xou V = F V=F
VeF= F V ou F = V V xou F = V F=V
FeV= F F ou V = V F xou V = V
FeF= F F ou F = F F xou F = F

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.12.1 - Prioridades entre os operadores lógicos:

1) NÃO (NOT)
2) E (AND) OU (OR)
3) XOU (XOR)

1.13 PRIORIDADE Entre todos os operadores

1) Parênteses mais internos


2) Funções matemáticas
3) Operadores aritméticos
4) Operadores relacionais
5) Operadores lógicos

17
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

1.14 COMANDO DE ATRIBUIÇÃO:


Atribui-se um valor a uma certa variável.
Este valor deve ser do mesmo tipo primitivo da variável.
ALGORITMO:
SINTAXE..: <IDENTIFICADOR> <-- EXPRESSÃO;

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;

18
2. COMANDOS DE ENTRADA E SAÍDA:
Utilizados para permitir a entrada de informações e posterior resultado do processamento
(saída)

2.1 ENTRADA DE DADOS

ALGORITMO: PASCAL:

SINTAXE..: LEIA (Variável) ; SINTAXE..: READLN(Variável);


Onde variável poderá ser de qualquer um dos tipos primitivos e deve ter sido definida
anteriormente.

Exemplo:
ALGORITMO PASCAL
NOME : Caracter; VAR
X,Y : Real; NOME : String;
X,Y : Real;
LEIA (NOME);
LEIA (X,Y); READLN (NOME);
READLN (X,Y);

2.2 SAÍDA DE DADOS

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));

19
3. ESTRUTURA DO ALGORITMO:

3.1 ESTRUTURA SEQÜENCIAL:


Num algoritmo aparecem em primeiro lugar as declarações, seguidas por comandos que, se
não houver indicação em contrário, deverão ser executados numa seqüência linear, de cima para
baixo.

3.1.1 - BLOCOS: Tem a finalidade de definir os limites 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}

20
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.

21
4. COMANDOS:

4.1 COMANDOS DE SELEÇÃO IF:


Um comando de seleção permite que diante de uma ou mais condições, uma ou outra
ação(comando) seja executada.

4.1.1 - SELEÇÃO SIMPLES:

ALGORITMO:
SINTAXE..: SE <condição> ENTÃO
comando; {comando único}
FIMSE;

SINTAXE..: SE <condição> ENTÃO


INICIO
comando; {seqüência de comandos}
comando2;
FIM;
FIMSE;

PASCAL:
SINTAXE..: IF <condição> THEN
comando; {comando único}

SINTAXE..: IF <condição> THEN


BEGIN
comando; {seqüência de comandos}
comando2;
END;

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.

22
4.1.2 - SELEÇÃO COMPOSTA:

ALGORITMO:
SINTAXE..: SE <condição> ENTÃO
comando; {comando único}
SENÃO
comando; {comando único}
FIMSE;

SINTAXE..: SE <condição> ENTÃO


INICIO
comando; {seqüência de comandos}
comando2;
FIM;
SENÃO
INICIO
comando3;
comando4;
FIM
FIMSE;

PASCAL:
SINTAXE..: IF <condição> THEN
comando {comando único}
ELSE
comando; {comando único}

SINTAXE..: IF <condição> THEN


BEGIN
comando; {seqüência de comandos}
comando2;
END
ELSE
BEGIN
comando3;
comando4;
END;
Obs.: O comando imediatamente anterior ao ELSE não tem ponto-e-vírgula (;).

23
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.

24
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.

25
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

26
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.

27
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;

SINTAXE : ESCOLHA seletor


CASO 1 : INÍCIO
comandos;
FIM;
CASO 2 : C2;
CASO CONTRÁRIO : INICIO
comandos;
FIM;
FIMESCOLHA;

PASCAL
SINTAXE : CASE seletor OF
CASO 1: C1;
CASO 2: C2;
CASO 3: C3;
ELSE
Comando;
END;

SINTAXE..: CASE seletor OF


CASO 1 : BEGIN
comandos;
END;
CASO 2 : C2;
ELSE
BEGIN
comandos;
END;
END;

Obs.: O comando CASE do Pascal só aceita variáveis do tipo Boolean, Byte, Char, Integer,
Longint, Shortint e Word.

28
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.

29
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.

4.2 COMANDOS DE REPETIÇÃO:


Utilizando o exemplo anterior (da média), com seria se fosse necessário calcular a média para 40
alunos?
Comandos de repetição são comandos que permitem a repetição de um ou mais comandos
enquanto uma determinada condição permanece válida.

4.2.1 - REPETIÇÃO COM VARIÁVEL DE CONTROLE (PARA):


Comando utilizado quando é sabido de antemão quantas vezes a repetição deverá ocorrer.

ALGORITMO:

SINTAXE..: PARA x DE vi ATÉ vf PASSO p FAÇA


comando único;
FIMPARA;

SINTAXE..: PARA x DE vi ATE vf PASSO p FAÇA


INICIO
comandos;
...
FIM;
FIMPARA;

30
PASCAL:

SINTAXE..: FOR x := vi TO vf DO
comando único;

SINTAXE..: FOR x := vi DOWNTO vf DO


comando;

SINTAXE..: FOR x := vi TO vf DO
BEGIN
...
comandos;
END;

SINTAXE..: FOR x := vi DOWNTO vf DO


BEGIN
...
comandos;
END;

Onde: x é a variável de controle


vi o valor inicial de x
vf o valor final de x
p o valor do incremento dado variável x.
PASSO é opcional.

Exemplo: Faça o algoritmo anterior (Aprovado e Reprovado) para 50 alunos.

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.

31
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.

4.2.2 - REPETIÇÃO COM TESTE NO INÍCIO (ENQUANTO):


Comando de repetição que testa a condição antes de cada execução do(s) comando(s).

ALGORITMO:

SINTAXE..: ENQUANTO <condição> FAÇA


comando único;
FIMENQUANTO;

SINTAXE..: ENQUANTO <condição> FAÇA


INICIO
comandos;
...
FIM;
FIMENQUANTO;

PASCAL:

SINTAXE..: WHILE <condição> DO


comando;

SINTAXE..: WHILE <condição> DO


BEGIN
...
comandos;
...
END;

32
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.

4.2.3 - REPETIÇÃO COM TESTE NO FINAL (REPITA):


Comando de repetição que testa a condição após cada execução do(s) comando(s).

ALGORITMO:

SINTAXE..: REPITA
...
comandos;
...
ATÉ <condição>;

PASCAL:

SINTAXE..: REPEAT
...
comandos;
...
UNTIL <condição>;

Obs.: O comando REPEAT dispensa o uso do bloco BEGIN-END;


Com relação ao comando anterior, neste caso os comandos são executados pelo menos uma vez.

33
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.

USANDO O COMANDO “PARA”


ALGORITMO PASCAL
PROGRAMA pares; PROGRAM pares;
par, acum : INTEIRO; USES CRT;
INICIO VAR
acum <-- 0; par, acum : INTEGER;
PARA par DE 2 ATÉ 30 PASSO 2 FAÇA BEGIN
INICIO acum := 0;
ESCREVA(par); FOR par := 2 TO 30 DO
acum <-- acum + par; IF (par MOD 2 = 0) THEN
FIM; BEGIN
FIMPARA; WRITELN(par);
ESCREVA("SOMA DOS PARES ",acum); acum := acum + par;
FIM. END;
WRITELN (‘SOMA DOS PARES ‘,acum);
END.

34
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.

USANDO O COMANDO “REPITA”


ALGORITMO PASCAL
PROGRAMA pares; PROGRAM pares;
par, acum : INTEIRO; USES CRT;
INICIO VAR
acum <-- 0; par, acum : INTEGER;
par <-- 2; BEGIN
REPITA acum := 0;
ESCREVA(par); par := 2;
acum <-- acum + par; REPEAT
par <-- par + 2; WRITELN(par);
ATÉ (par > 30); acum := acum + par;
ESCREVA("SOMA DOS PARES ",acum); par := par + 2;
FIM. UNTIL (par > 30);
WRITELN(‘SOMA DOS PARES ‘,acum);
END.

35
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.

36
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.

3- Faça o algoritmo para calcular o fatorial de um número. 0! = 1

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.

37
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.

38
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) FAÇA READLN(n);
SE (n MOD fator = 0) ENTÃO último := N - 1;
pr < -- FALSO; WHILE ((pr) AND ( fator <= último)) DO
SENÃO fator <-- fator + 1; IF (n MOD fator = 0) THEN
FIMSE; pr := FALSE
FIMENQUANTO; ELSE fator := fator + 1;
SE (pr) ENTÃO IF (pr) THEN
ESCREVA(" É PRIMO"); WRITELN(‘ É PRIMO’)
SENÃO ESCREVA("NÃO É PRIMO"); ELSE WRITELN(‘NÃO É PRIMO’);
FIMSE; END.
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.

39
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);

40
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.

41
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;

42
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.

43
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.

EX. Um armário com diversas gavetas, cada gaveta recebe um nome(variável).


Sendo que esta variável pode armazenar uma coisa de cada vez. Ao invés disto
com o conceito de vetores podemos nomear uma coluna de gavetas com apenas
um nome e o acesso as gavetas seria feito através de um índice.

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;

44
Onde:
IDENTIFICADOR : o novo tipo que está sendo criado.

Li : o limite inicial do vetor.

Lf : o limite final do vetor.

TIPO : qualquer um dos tipos primitivos já conhecidos.

LISTA DE VARIÁVEIS: Identifica a(s) variáveis que serão do tipo vetor.

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

MANIPULAÇÃO: vnotas[3] <--9.25;


LEIA(vnotas[1]);
ESCREVA(vnotas[4]); { ERRADO }

45
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.

46
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.

47
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.

3- Faça um algoritmo que leia um vetor de 10 elementos e o imprima em ordem inversa a de


leitura. Elementos do tipo real.

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.

48
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.

49
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.

50
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.

51
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.

52
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.

53
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.

54
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;

Obs.: No contexto do programa, os subalgoritmos devem se localizar sempre antes do


programa principal. Veja o exemplo:

55
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.

6.2 ESCOPO DE VARIÁVEIS


Na modularização do algoritmo as variáveis declaradas no início e que são utilizadas por
módulos dependentes são ditas Globais. Ou seja são passíveis de serem utilizadas por qualquer
módulo dependente.
As variáveis declaradas internamente em um módulo são ditas Locais.
O conceito de Global e Local é relativo pois uma variável Local é considerada assim em
relação ao algoritmo(módulo) principal, mas pode ser considerada Global em relação ao seus
módulos dependentes.
Exemplo:
ALGORITMO PASCAL
PROGRAMA escopo; PROGRAM escopo;
x : INTEIRO; USES CRT;
PROCEDURE um; VAR
c : INTEIRO; x : INTEGER;
INICIO PROCEDURE um;
LEIA (c); VAR
x <-- c * 2; c : INTEGER;
FIM; BEGIN
INICIO READLN (c);
um; x := c * 2;
ESCREVA (x); END;
FIM. BEGIN
um;
WRITELN (x);
END.

56
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.

6.3 MANIPULAÇÃO DE MÓDULOS


Um módulo deverá ser escrito sempre antes do módulo principal. A chamada de um módulo
ocorre através do seu identificador. Todo algoritmo que referencia um ou mais módulos é
denominado módulo principal em relação aos módulos por ele referenciados.

6.4 Subalgoritmos com parâmetros

Em algumas situações é necessário a passagem de valores (parâmetros) para o


algoritmo(procedure). Veja ex. abaixo:

6.4.1 - PASSAGEM DE PARÂMETROS POR VALOR

ALGORITMO PASCAL
PROGRAMA passagem_por_valor; PROGRAM passagem_por_valor;
x : INTEIRO; USES CRT;
{Declaração de variáveis do programa principal } VAR { Decl. de variáveis do programa 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 :2:2);
INICIO END;
ESCREVA ("Digite o valor de X:"); { Aqui inicia o programa principal }
LEIA (x); BEGIN
Cálculo(x); WRITELN (‘Digite o valor de X:’);
FIM. READLN (x);
Cálculo(x);
END.

* A variável “a” comporta-se como variável local.


* Os parâmetros devem estar na mesma ordem, número e tipo.
* Não devolve valor.
* É possível passar somente valor.
Ex. Cálculo(3);

57
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:

Até o presente momento estudamos variáveis compostas unidimensionais (VETORES) que nos
resolveram diversos problemas. Imaginem um vetor para armazenar preços de 10 produtos:

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

58
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.

EX.: preço[1,6] = 1200;


preço[2,6] = 320;

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;

59
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.

Exercícios: 1- Elabore um algoritmo que leia uma Matriz 4x4.


ALGORITMO PASCAL
PROGRAMA matriz; PROGRAM matriz;
mat = MATRIZ [1..4,1..4] DE INTEIRO; USES CRT;
a : mat; VAR
l, c : INTEIRO; a : ARRAY [1..4,1..4] OF INTEGER;
INICIO l, c : INTEGER;
PARA l DE 1 ATÉ 4 FAÇA BEGIN
PARA c DE 1 ATÉ 4 FAÇA FOR l := 1 TO 4 DO
LEIA(a[l,c]); FOR c := 1 TO 4 DO
FIMPARA; READLN (a[l,c]);
FIMPARA; END.
FIM.

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.

60
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.

61
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.

62
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.

63
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.

64
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.

65
8. LISTA DE EXERCÍCIOS:

1 - Faça um algoritmo que escreva a seguinte série 0,1,2,5,12,29...


O algoritmo deve escrever 30 termos da série.

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.

6 - Faça um algoritmo que gere a seguinte seqüência:


R = n/n! + n/n! - n/n!...
O número N é primo, o algoritmo deve encerrar no último número primo antes de 30.
Note que o operador se alterna + -+-+-+-

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).

66
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)

10 - Fornecidos os nomes e a idade de 40 alunos de uma turma do curso de matemática da


UNISC fazer o algoritmo que escreva o nome e a idade do aluno mais velho.

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.

14 - Fornecidas as temperaturas observadas em cada hora de um dia, fazer o algoritmo para


determinar a maior e a menor temperatura ocorrida até as 24 horas.

15 - Numa turma de 50 alunas foi realizado um levantamento e coletadas as seguintes


informações:
- altura
- peso
- cor do cabelo(loiro, castanho, preto, ruivo)
Faça um algoritmo que determine:
a) A cor do cabelo da moça mais alta;
b) A altura da moça mais pesada;
c) A média das alturas das loiras e ruivas;

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.

18 - Fazer um algoritmo para calcular a média de 3 valores.

67
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.

22 - Construa um algoritmo que leia o número de um funcionário, seu número de horas


trabalhadas, o valor que recebe por hora e o número de filhos com idade menor do que 14 anos e
calcula o salário deste funcionário. Sabendo que para cada filho com idade menor de 14 anos ele
recebe um adicional de 3% no salá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.

68
APÊNDICE A - Editor Pascal

MENU FILE (Alt - F)

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.

PRINT - Imprime o arquivo que estiver na janela ativa.

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.

69
MENU EDIT - (Alt - E)

UNDO (Alt - Bksp) - Desfaz o último comando.

REDO - Refaz o último comando.

CUT (Shift - Del) - Remove o texto selecionado, colocando-o na área de transferência. É


possível inseri-lo no mesmo arquivo, ou em outros.

COPY (Crtl - Ins) - Copia o texto para a área de transferência. O texto não é removido do
arquivo.

PASTE (Shift - Ins) - Copia o texto da área de transferência para o 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.

MENU SEARCH (Alt - S)

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.

70
MENU RUN ( Alt - R )

RUN (Crtl - F9) - Permite a execução do programa na janela ativa.

STEP OVER (Crtl - F8) - Executa um programa rotina por rotina.

TRACE INTO (F7) - Executa um programa linha a linha, permitindo a sua depuração. a linha
que estiver sendo executada aparecerá em reverso.

GO TO CURSOR (F4) - Possibilita a execução do programa até a posição do cursor no


programa fonte. No caso da execução do programa não passar onde estiver o cursor, o programa
terá sua execução normal.

PROGRAM RESET (Crtl - F2) - Permite a interrupção da execução de um programa e serve


para liberar a memória durante a depuração.

PARAMETERS - Permite que seja passado um parâmetro. É aberta uma caixa de diálogo onde
constam os últimos parâmetros digitados.

MENU COMPILE ( Alt - C )

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.

MAKE (F9) - Cria a versão executável (. EXE) do programa sendo editado.

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.

71
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.

ADD WATCH ( Crtl - F7) - Permite a inserção de variáveis na janela do Watch.

ADD BREAKPOINT - Inclui um ponto de parada na execução do programa. É utilizado para


ver se o programa está em “looping”.

TOOLS (Alt - T)

MESSAGES - Abre uma janela onde são exibidas as mensagens.

GO TO NEXT (Alt - F8) - Mostra a próxima mensagem na janela de mensagens.

GO TO PREVIOUS (Alt - F7) - Mostra a mensagem anterior na janela de mensagens.

GREP (Shift - F3) - O programa grep.exe permite que se procurem seqüências de caracteres em
programas no disco.

72
MENU OPTIONS (Alt - O)

COMPILER - Permite a alteração das diretivas de compilação.

MEMORY SIZES - Estabelece os tamanhos para memória.

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.

DIRECTORIES - Permite que sejam determinados quais os diretórios de trabalho do Turbo


Pascal.

TOOLS - Permite que seja feita a manutenção do menu de ferramentas.

ENVIRONMENT - Permite que se altere o ambiente de trabalho do Turbo Pascal através de um


submenu.

OPEN - Abre o arquivo de configuração do ambiente Turbo Pascal.

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.

MENU WINDOW (Alt - W)

TILE - Permite o reordenamento das janelas que estão ativas.

CASCADE - permite o reordenamento das janelas abertas. Somente a janela ativa ficará
inteiramente visível, as demais, ficarão apenas com as bordas aparentes.

CLOSE ALL - Fecha todas as janelas que estiverem abertas.

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.

NEXT (F6) - Coloca a próxima janela como ativa.

PREVIOUS (Shift - F6) - Coloca a janela anterior como ativa.

73
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.

MENU HELP (Alt - H)

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.

INDEX (Shift - F1) - Mostra o help em ordem alfabética.

TOPIC SEARCH (Crtl - F1) - Permite que uma palavra detectada no texto seja procurada no
help.

PREVIOUS TOPIC (Alt - F1) - Aciona as 20 últimas chamadas do help.

USING HELP - Explica como navegar pelo help.

FILES - Habilita outros arquivos de ajuda.

COMPILER DIRECTIVES - Lista de forma alfabética todas as diretivas de compilação.

RESERVED WORD - Exibe apenas as palavras reservadas do Turbo Pascal.

STANDARD UNITS - Exibe as Units padrão.

TURBO PASCAL LANGUAGE - Uma breve listagem sobre o Turbo Pascal.

ERROR MESSAGE - Exibe mensagens de erro.

ABOUT - considerações sobre o turbo Pascal.

74
APÊNDICE B - Comandos Básicos

PROCEDURES E FUNCTIONS PARA CONTROLE DE VÍDEO E


TECLADO

UNIT CRT:

CLRSCR - Limpa a tela.


CLREOL - Limpa uma linha a partir da posição do cursor.
GOTOXY (Coluna, Linha) - Para posicionar o cursor. Coluna e Linha devem ser valores
inteiros ou uma expressão.
INSLINE - Insere uma linha na posição do cursor.
DELLINE - Deleta uma linha na posição do cursor.
DELAY(mseg) - Tempo de espera da tela de saída.
WINDOW(x1,y1,x2,y2) - Define uma janela de vídeo, onde x1 e y1 são as coordenadas do
ponto superior esquerdo e x2 e y2 as coordenadas do ponto inferior direito.
KEYPRESSED - Retorna TRUE se uma tecla foi pressionada.
READKEY - Função que lê um caracter do teclado.
WHEREX - Retorna o valor corrente da coordenada (X) do cursor.
WHEREY - Retorna o valor da abcissa (Y) do cursor.
TEXTCOLOR - Permite selecionar a cor do texto (0 a 15).
TEXTBACKGROUND - Permite selecionar a cor do fundo da tela (0 a 15).
SOUND - Gera som. Deve estar sempre seguido do comando nosound.
NOSOUND - Interrompe o som.

PROCEDURES E FUNCTIONS PARA CONTROLE DE TEXTO

ORD - Retorna o código ASCII do caracter passado como parâmetro.


CHR - Retorna o caracter correspondente ao código ASCII.
UPCASE - Retorna a letra maiúscula.

PROCEDURES E FUNCTIONS PARA GERAR NÚMEROS ALEATÓRIOS

RANDOM - Função que gera um número aleatório entre 0 e 1 (real).


RANDOM(n) - Função que gera números aleatórios entre 0 e n. N deve ser do tipo inteiro.
RANDOMIZE - Altera a semente de geração aleatória.

INICIANDO O TURBO PASCAL

No prompt do DOS digite: C:\> CD TP


C:\TP> CD BIN
C:\TP\BIN> TURBO

75
BIBLIOGRAFIA :

FORBELLONE, ANDRÉ LUIZ VILLAR; EBERSPACHER, HENRI F.


(MAKRON BOOKS) "LÓGICA DE PROGRAMAÇÃO"

GUIMARÃES/LAGES "ALGORITMOS E ESTRUTURAS DE DADOS"


LTC - Livros Técnicos e Científicos Editora

SWAIT, JOFFRE DAN JR. "FUNDAMENTOS COMPUTACIONAIS ALGORITMOS E


ESTRUTURAS DE DADOS (MAKRON BOOKS)

RINALDI, ROBERTO. “COMANDOS E FUNÇÕES TURBO PASCAL 7.0”


EDITORA ÉRICA. 2 EDIÇÃO.

FARRER, HARRY; BECKER CHRISTIANO G.; FARIA,EDUARDO C.;


MATOS,HELTON F.; SANTOS, mARCOS A. DOS; MAIA, MIRIAM LOURENÇO;
“ALGORITMOS ESTRUTURADOS” Editora Guanabara

WIRTH, NIKLAUS; ÄLGORITMOS E ESTRUTURAS DE DADOS” PHB Prentice/hall


do Brasil

76