Você está na página 1de 32

PORTUGOL

Introdução
A Sintaxe
A Sintaxe do
do PORTUGOL
PORTUGOL
apresentada aqui
apresentada aqui está
está baseada
baseada
no trabalho
no trabalho G-Portugol.
G-Portugol.
Elementos básicos de um algoritmo
algoritmo <nome_do_algoritmo>;
variáveis

<declarações de vari
<declarações áveis>
variáveis>

fim-variáveis
início

<comandos>

fim
Elementos básicos de um algoritmo
Exemplo

/*
/*
Nosso primeiro
Nosso primeiro programa
programa
*/
*/
algoritmo olamundo;
algoritmo olamundo;
início
início
imprima("Olá mundo!");
imprima("Olá mundo!");
fim
fim
Elementos básicos de um algoritmo
Exemplo

algoritmo teste_variaveis;
algoritmo teste_variaveis;
variáveis
variáveis
xx :: inteiro;
inteiro;
nome :: literal;
nome literal;
fim-variáveis
fim-variáveis
início
início
....
....
fim
fim
Elementos básicos de um algoritmo
Exemplo
algoritmo perimetro_circunferência;
// declaração de variáveis
variáveis
pi, raio, perim: real;
fim-variáveis
// comandos
início
pi := 3,1415;
raio := leia();
perim = 2 * pi * raio;
imprima (perim);
fim
Elementos básicos de um algoritmo

Dados (variáveis e constantes)


Tipos de dados
Operadores
Comandos
Funções
Comentários
Elementos básicos de um algoritmo
Exemplo
algoritmo perimetro_circunferência;
// declaração de variáveis comentário
variáveis
pi, raio, perim: real; declaração variável
fim-variáveis tipo de dado
// comandos
início
pi := 3,1415;
atrib. dado constante

raio := leia(); função


perim := 2 * pi * raio; atribuição dadooperador
variável
imprima (perim); função
fim
Elementos básicos de um algoritmo
:: Dados
 Dados Variáveis
Elemento que têm a função de associar um
nome a uma porção da memória onde um dado
pode ser armazenado.
 Dados Constantes
G-Portugol não tem definição explícita de
constantes
O valor de uma constante não se altera após sua
definição.
Exemplos (usando variáveis):
N_NEPERIANO := 2,7182
UNIVERSIDADE := 'UFAM'
Elementos básicos de um algoritmo
:: Tipos de dados
Definem a natureza do dado, as
operações que podem ser realizadas com
o dado e o espaço a ser ocupado na
memória.
Elementos básicos de um algoritmo
:: Operadores
Atribuição
Aritméticos
Relacionais
Lógicos
Elementos básicos de um algoritmo
:: Operador Atribuição
Utilizado para atribuir um valor a uma
variável
nome da
Valor
variável

Notação:
x1 := 23;
temp := x2;
Elementos básicos de um algoritmo
:: Operadores Aritméticos
Dados de entrada: tipo inteiro ou real
Resultado: tipo inteiro ou real

Exemplos:
x_2 := 2 + 3;
alfa := 1 / 5;
ang := 1 / 5.0;
resto := 10 % 3;
resto := 1 % 4;
delta := 5 * 5 – 4 * 1 * 4;
Elementos básicos de um algoritmo
:: Operadores Relacionais
Dados de entrada: tipo inteiro ou real
Resultado: tipo lógico

Exemplos:
cond1 := 2 == 3;
cond2 := 1.6 ≠ 5.0;
cond3 := 1 > 5;
cond4 := (1 + 2) < 5;
cond5 := 10 ≥ 3;
cond6 := 1 ≤ (– 4 / 3);
Elementos básicos de um algoritmo
:: Operadores Lógicos
Dados de entrada: tipo lógico
Resultado: tipo lógico

Exemplos:
cond1 := verdadeiro e falso;
cond2 := falso ou falso;
cond3 := não cond1;
cond4 := (verdadeiro e falso) ou (5 > 3);
Elementos básicos de um algoritmo
:: Precedência de Operadores
1. não
2. * / %
3. + –
4. < > >=<=
5. = <>
6. e
7. ou
8. :=
Elementos básicos de um algoritmo
:: Exercícios sobre Operadores
d + y - z * a / p y=2
d / y z = 4.0
a=8
y / a
b = 6.0
b / z d = 12
r % q p=4
y % d q=3
((z / a) + b*a ) - d r = 10
Elementos básicos de um algoritmo
:: Exercícios sobre Operadores
 (B = A * C) e (LOG ou T)
 (B > A) ou (B = A)
 LOG ou (B / A >= C) e não(A >= C)
 não LOG ou T e (A + B >= C)
 não LOG ou (B * 2 - C = 0)
 LOG ou não (B *AB=<=
2 C * 10 + A * B)
B=7
C = 3.5
LOG = F
Elementos básicos de um algoritmo
:: Funções
 Pré-definidas
 Definidas pelo programador
 G-Portugol tem duas funções internas: “leia” e
“imprima”, que permitem entrada e saída.
 Exemplos:
seno(angulo)
pow(x,y)
sqrt(resto)
exp(tempo)
var1 := leia()
imprima()
Elementos básicos de um algoritmo
:: Comentários
Utilizados para descrever o algoritmo,
esclarecendo trechos do código

Notação igual a linguagem C:


//
/* <comentário> */
Algoritmos com qualidade

Devem ser feitos para serem lidos por


seres humanos!

Escreva os comentários no momento em


que estiver escrevendo o algoritmo.
Algoritmos com qualidade

Os comentários devem acrescentar


alguma coisa, e não frasear o comando:

//
// Multiplica ção de
Multiplicação de bb por
por h:
h:
area
area ←← bb ** h;
h;

//
// CCálculo
álculo da da áárea
rea do
do retângulo:
retângulo:
area
area ←← bb ** h;
h;
Algoritmos com qualidade

Use comentários no prólogo:

/*****************************************
/*****************************************
UNIVERSIDADE
UNIVERSIDADE FEDERAL
FEDERAL DO
DO AMAZONAS
AMAZONAS
FULANO
FULANO DA
DA SILVA
SILVA
DATA:
DATA: 25/11/2006
25/11/2006
ÚLTIMA
ÚLTIMA MODIFICAÇÃO:
MODIFICAÇÃO: 26/12/2007
26/12/2007

ALGORITMO
ALGORITMO DE
DE DEMONSTRAÇÃO
DEMONSTRAÇÃO
*****************************************/
*****************************************/
Algoritmos com qualidade

Use espaços em branco para melhorar a


legibilidade:

hip:=sqrt(cat1*cat1+cat2*cat2);
hip:=sqrt(cat1*cat1+cat2*cat2);

hip
hip :=
:= sqrt(cat1
sqrt(cat1 ** cat1
cat1 ++ cat2
cat2 ** cat2);
cat2);
Algoritmos com qualidade

Escolha nomes representativos para as


variáveis:

pp :=
:= cc ++ l;
l;

preco ← custo
preco ← custo ++ lucro;
lucro;
Algoritmos com qualidade

Utilize um comando por linha.

Utilize parênteses para melhorar a


compreensão e evitar erros.

Utilize identação (recuo de texto).


Atenção: identação ≠ endentação
Exercício

Uma fábrica de arruelas precisa calcular o


custo de envio de um conjunto de
unidades. Escreva um pseudo-código
para tal.
Exercício
:: Algoritmo inicial
1. Calcular área
2. Calcular volume (área × espessura)
3. Calcular peso (volume × densidade ×
unidades)
4. Calcular custo (peso × frete)
Exercício
:: Algoritmo inicial
1. Calcular área
2
 d_int 
Area int =π 
 2 

d_int 2
 d _ ext 
Areaext = π  
 2 

d_ext Area = Aext − Aint


Exercício
:: Algoritmo inicial
2. Calcular volume:
Volume = Area × espessura

3. Calcular peso:
Peso = Volume × densidade × unidades

4. Calcular custo (peso × frete)


Custo = Peso × frete
Exercício
:: Pseudo-código
algoritmo arruela;
// variáveis constantes
pi : real;
// Variáveis de entrada
d_ext, d_int, espes, dens, unid, frete: real;
// Variável de saída
custo : real;
// Variáveis do programa
area, area_ext, area_int, volume, peso : real;
...
Exercício
:: Pseudo-código (cont.)
...
início
pi := 3,1415;
d_ext:= leia(); d_int := leia(); espes := leia();
dens := leia(); unid := leia(); frete := leia();
area_ext := pi * (d_ext/2) * (d_ext/2);
area_int := pi * (d_int/2) * (d_int/2);
area := area_ext – area_int;
volume := area * espes;
peso := volume * dens * unid;
custo := peso * frete;
imprima (custo);
fim