22 - Lógica de Programação com Portugol

1. Lógica- Exercícios

2. Rotinas
• Procedimentos
• Funções

3. Procedimentos
• Quando temos partes do algoritmo que precisam ser executadas
rotineiramente, podemos coloca-las dentro um procedimento,
evitando assim a reescrita daquele trecho do código, bastando
chamar o procedimento que deverá ser executado.
• Podemos criar um procedimento e toda vez que formos utilizá-lo
basta chama-lo pelo nome
• Vamos criar um algoritmo utilizando procedimento

4. Detector de Pesado
algoritmo “DetectorPesado”
var
I : inteiro
N, Pesado : caractere
P, Mai : real
procedimento Topo( )
inicio
LimpaTela
escreval(“-----------------------------------------------------------------”)
escreval(“ DETECTOR DE PESADO ”)
escreval(“Maior Peso até agora: ”, Mai , “Kg”)
escreval(“-----------------------------------------------------------------”)
fimprocedimento
Topo( )
para I <- 1 ate 5 faca
Escreva(“Digite o nome: ”)
Leia(N)
Escreva(“Digite o peso de ”, N, “: ”)
Leia(P)
Se (P > Mai) entao
Mai <- P
Pesado <- N
fimse
Topo( )
Fimpara
Topo( )
Escreval(“A pessoa mais pesada foi ”, Pesado, “ com ”, Mai, “ quilos.”)
fimalgoritmo

5. Passagem de Parâmetros
• Tipo 1 -> Valor
• Podemos criar um procedimento e dentro dos parêntesis passar
parâmetros do tipo valor (value)
• Criaremos um procedimento que efetua a soma de dois valores
utilizando parâmetros.
• Os parâmetros (variáveis) declarados no procedimento apenas
funcionam dentro do escopo do procedimento, portanto, não são
consideradas GLOBAIS

6. Procedimento Soma
algoritmo “SomaParametrosValor”
var
X, Y : inteiro
procedimento Soma (A, B : inteiro)
Inicio
Escreval(“Recebi o valor ”, A)
Escreval(“Recebi o valor ”, B)
Escreval(“A soma entre os dois é ”, A + B)
fimprocedimento
inicio
X <- 5
Y <- 3
Soma(X, Y)
fimalgoritmo

7. Procedimento ParOuImpar
Algoritmo “ParOuImparProcedimento”
var
N : inteiro
procedimento ParOuImpar(V: inteiro)
inicio
se (V % 2 = 0) entao
escreval(“O número ”, V, “ é PAR”)
senao
escreval(“O número ”, V, “ é ÍMPAR”)
fimse
fimprocedimento
inicio
Escreva(“Digite um número: ”)
Leia(N)
ParOuImpar(N)
fimalgoritmo

8. Passagem de Parâmetros
• Tipo 2 -> Referência
• Utilizamos a palavra var antes de declararmos os parâmetros,
indicando assim uma passagem por referência
• Vamos criar um algoritmo que efetua a soma de dois parâmetros
passados como referência

9. Procedimento SomaReferencia
algoritmo “ProcedimentoSomaReferencia”
var
X, Y : inteiro
procedimento Soma(var A, B : inteiro)
inicio
A <- A + 1
B <- B + 2
escreval(“Valor de A = ”, A)
escreval(“Valor de B = ”, B)
escreval(“Soma A + B = ”, A + B)
fimprocedimento
inicio
X <- 4
Y <- 8
Soma(X, Y)
Escreval(“Valor de X = ”, X)
Escreval(“Valor de Y = ”, Y)
fimalgoritmo

10. Funções
• São partes de um algoritmo que precisam ser executadas de forma
rotineira, sendo que a diferença em relação a procedimento é que
funções podem retornar algum valor.
• Os procedimentos não conseguem dar resposta ao programa
principal, já as funções conseguem retornar valores para a parte
principal do programa.
• Vamos criar um algoritmo que executará a função soma

11. Função Soma
algoritmo “FuncaoSoma”
var
V1, V2, S : inteiro
funcao Soma(X, Y : inteiro) : inteiro
inicio
Retorne X + Y
fimfuncao
inicio
Escreva(“Digite o primeiro valor: ”)
Leia(V1)
Escreva(“Digite o segundo valor: ”)
Leia(V2)
S <- Soma(V1, V2)
Escreval(“A soma entre ”, V1 “ e ”, V2, “ é igual a ”, S)
fimalgoritmo