Lógica de Programação - Marco Guimarães
Lógica de Programação - Marco Guimarães
Lógica de Programação - Marco Guimarães
Programação
Marco Guimarães
marco.guimaraes@sistemafiepe.org.br
Algoritmo
Importância na programação.
Representar o raciocínio lógico.
Focaliza-se primeiro na resolução algorítmica do problema,
possibilitando sua codificação em qualquer linguagem de
programação.
Método para a Construção de Algoritmos
✓ Compreender o problema
✓ Definir os dados de entrada
✓ Definir o processamento
✓ Construir o algoritmo
✓ Testar o algoritmo
Algoritmo
...
Algoritmo
Tipos de Algoritmos
❑ Descrição narrativa
❑ Fluxograma
❑ Pseudocódigo ou portugol
Descrição Narrativa
Simbologia:
Fluxo de dados
Indica o sentido do fluxo de dados
Conecta os demais símbolos
Terminal
Indica o INÍCIO ou FIM de um processamento
Exemplo: Início do algoritmo
Processamento
Processamento em geral
Exemplo: Cálculo de dois números
Fluxograma
Simbologia:
Entrada
Operação de entrada de dados
Exemplo: Leitura de dados pelo teclado
Saída
Mostra informações ou resultados
Exemplo: Mostre o resultado do cálculo
Decisão
Permite elaborar processos de decisão
Escreva um algoritmo do seu cotidiano
Escreva um algoritmo do seu cotidiano
Pseudocódigo
Vantagem Desvantagem
Narrativa Fácil de escrever Más interpretações
Linguagem Natural Ambiguidade
Pseudocódigo Fácil transição para a Necessário aprender regras do
linguagem de programação pseudocódigo
Fluxograma Fácil de visualizar Aprender os Símbolos
Fluxo Lógico
Portugol
Exemplo 1
:
Etapas no Desenvolvimento de um Programa
Passo 1:
mova disco menor para terceiro eixo
Exemplo de Problemas
Passo 2:
mova disco médio para segundo eixo
Exemplo de Problemas
Passo 3:
mova disco menor para segundo eixo
Exemplo de Problemas
Passo 4:
mova disco maior para terceiro eixo
Exemplo de Problemas
Passo 5:
mova disco menor para primeiro eixo
Exemplo de Problemas
Passo 6:
mova disco médio para terceiro eixo
Exemplo de Problemas
Passo 7:
mova disco menor para terceiro eixo
Exemplo de Problemas
Como jogar:
As regras são as seguintes:
Somente o pai, a mãe e o policial sabem pilotar o barco;
A mãe não pode ficar sozinha com os filhos;
O pai não pode ficar sozinho com as filhas;
O prisioneiro não pode ficar sozinho com nenhum integrante da família;
O barco só pode transportar 2 pessoas por vez;
Você pode ir e vir com as pessoas quantas vezes precisar.
Jogo da Travessia do Rio
Programação Estruturada
Exemplos: Pascal e C
Programação Orientada a Objetos
Exemplos: C++, Python e Java
Compiladores
• Conceitos iniciais
• O que é lógica?
• O que é algoritmo?
• Tipos de algoritmo
Lógica
• O uso da palavra lógica está relacionado à coerência e à
racionalidade
• Podemos relacionar a lógica como “correção do
pensamento”, pois uma de suas preocupações é determinar
quais operações são válidas ou não
• “Arte do bem pensar”
• A lógica estuda e ensina a colocar “ordem no pensamento”
• Ex:
• Todo mamífero é um animal
• Todo cavalo é um mamífero
• Portanto, todo cavalo é um animal
Lógica
• Existe lógica no dia a dia?
• Podemos perceber a importância da lógica em nossa vida,
não só na teoria como na prática, já que quando queremos
pensar, falar, escrever ou agir corretamente, precisamos
colocar “ordem no pensamento”, ou seja, usar a lógica.
• Ex:
• A gaveta está fechada
• A caneta está dentro da gaveta
• Precisamos primeiro abrir a gaveta para depois pegar a caneta
Lógica de programação
É o uso correto do pensamento, da “ordem da razão” e de
processos de raciocínio e simbolização formais na
programação de computadores, objetivando a racionalidade
e o desenvolvimento de técnicas que cooperem para a
produção de soluções logicamente válidas e coerentes, que
resolvam com qualidade os problemas que se deseja
programar
Usando a lógica
• Lobo, carneiro e repolho
• Você tem um lobo, um carneiro e uma cesta de repolho,
e precisa levar todos eles para o outro lado do rio.
Porém, o seu barco só pode levar um de cada vez. Mas,
se você deixar o lobo e o carneiro sozinhos, o lobo
comeria o carneiro. Se deixar o carneiro e a cesta de
repolho, o carneiro comeria a cesta de repolho. Como
você os levará até o outro lado do rio?
• Para facilitar o raciocínio, você pode levar um no barco e
trazer o outro que por ventura esteja do outro lado do rio.
Usando a lógica
• A descrição narrativa
• Fluxograma
• Diagrama de Capin
• Pseudocódigo (ou português estruturado, ou portugol)
A descrição narrativa nada mais é
do que descrever, utilizando uma
Descrição linguagem natural (português) as
Narrativa ações a serem realizadas no
tratamento dos dados de entrada
para os resultados de saída na
resolução do problema proposto.
Descrição Narrativa
Exemplo 1
O fluxograma é a forma de descrever as
ações a serem realizadas no tratamento
Fluxograma dos dados de entrada para os resultados
de saída usando uma representação
simbólica preestabelecida.
Fluxograma
Fluxograma
Diagrama
de Chapin
O pseudocódigo é a forma de descrever as
ações para a resolução de um problema
proposto por meio de regras preestabelecidas.
• Ex:
inicio
Pseudocódigo inteiro n
n <- 5
se n = 5 entao
escrever "N = 5"
fimse
fim
Código – Linguagem de programação
Portugol Pascal C
inicio program N; #include <stdio.h>
inteiro n var void main()
n <- 5 n: integer; {
begin int n;
se n = 5 entao n := 5; n = 5;
escrever “N = 5”
fimse if (n = 5) then if (n == 5)
fim begin {
writeln(‘N = 5’); printf(“N = 5”);
end; }
end. }
Sempre que se codifica um algoritmo em
uma linguagem de programação, este
programa precisa ser “traduzido” para a
Programa linguagem entendida pela máquina. Este
processo chama-se interpretação ou
compilação.
Algoritmo
Tópicos preliminares
(variáveis, constantes e operadores)
Agenda
• Alguns exemplos:
• A lâmpada pode estar acesa ou apagada
Variáveis e
constantes
Utilizando os dados, definindo identificadores, etc.
Constantes
• Exemplos de uso:
• Pi, e outras constantes matemáticas.
• Valores de conversão .
• Velocidade da luz e do som (e de acordo com o material).
10 + 2 – 2 * 0 = ?
Operadores aritméticos - exercício
10 + 2 – 2 * 0 = ?
0?
12 ?
Operadores aritméticos - prioridades
Para resolver expressões aritméticas em
pseudocódigo, deve-se obedecer a uma
hierarquia de prioridades entre operadores
aritméticos que é a seguinte:
✓ Parênteses mais internos
✓ pot rad
✓ * / div mod
✓+ -
Expressões lógicas (ou relacionais)
1 – NAO
2–E
3 - OU
Prioridade entre operadores
inicio
inteiro x, y
escrever "Entre com um valor:"
ler x
y <- x * 2
escrever "O dobro do valor é", y
fim
Algoritmos
Estruturas de Controle
(sequencial e de decisão)
Agenda
• Para que este conjunto de ações se torne viável, deve existir uma perfeita
relação lógica intrínseca ao modo pelo qual essas ações são executadas,
ao modo pelo qual é regido o fluxo de execução do algoritmo.
• Por meio das estruturas básicas de controle do fluxo de execução –
sequenciação, seleção, repetição – e da combinação delas, podemos
criar algoritmos para solucionar nossos problemas
Estrutura
Sequencial
Estrutura sequencial
Corresponde ao fato de que um conjunto de ações primitivas será executado em uma
sequência linear na mesma ordem em que foram escritas
• Modelo geral:
inicio // identificação do início do bloco correspondente
ao algoritmo
// declaração das variáveis
// corpo do algoritmo
ação 1
ação 2
ação 3
(...)
ação N
fim // fim do algoritmo
Exercícios de estrutura sequencial
Exercícios de estrutura sequencial
𝐶 𝐹 −32
✓ A fórmula para conversão é: =
5 9
Estruturas de Seleção
Estrutura de seleção
verdadeiro
<condição>
falso ação
Estrutura de seleção simples
falso verdadeiro
<condição>
ação ação
Estrutura de seleção composta
Fim
Estruturas de seleção múltipla
Quando usar?
algoritmo "demo"
var
x: inteiro
inicio
para x de 0 ate 2 passo 1 faca
escreval("O valor de x é: ", x)
fimpara
fimalgoritmo
Estrutura de repetição – Para
algoritmo "Contagem regressiva "
var
i,n: inteiro
inicio
// Seção de Comandos
escreva ("DIGITE O Nº: ")
leia (n)
i <- n
para i de n ate 0 passo -1 faca
escreva (i)
fimpara
fimalgoritmo
Estrutura de repetição - Para
Estrutura de repetição – Para
► Estruturas afetadas:
► Enquanto
► Repita
► Estrutura não afetada:
► Para
Cuidado: Loop infinito
algoritmo "demo"
var
x: inteiro
inicio
x <- 0
enquanto x <= 2 faca
escreval(“O valor de x é: ”, x)
// alguém adivinha o que falta aqui?
fimenquanto
fimalgoritmo
Corrigindo: Loop infinito
algoritmo "demo“
var
x: inteiro
inicio
x <- 0
enquanto x <= 2 faca
escreval(“O valor de x é: ”, x)
// alguém adivinha o que falta aqui?
x := x+1 // A condição de parada
fimenquanto
fimalgoritmo
Cuidado: loop infinito
Exercícios
► Ex: 5! = 5 * 4 * 3 * 2 * 1
Exercícios – Resposta 1
algoritmo "fatorial"
var
n, c, fat: inteiro
inicio
escreva("Digite um valor inteiro:")
leia(n)
se (n = 0) ou (n = 1) entao
fat <- 1
senao
fat <- 1
escreva(n, "! é: ")
para c de n ate 1 passo -1 faca
fat <- fat * c
escreva(c, ".")
fimpara
fimse
escreval(" Fatorial de ", n, " =", fat)
fimalgoritmo
Exercícios – Resposta 2
Algoritmo "Calculadora de Fatorial"
Var
numero, fatorial, contador: inteiro
Inicio
Escreva("Digite um número inteiro: ")
Leia(numero)
fatorial <- 1
contador <- numero
Escreva(" 1")
Escreva(" = ")
Escreva(fatorial)
Fimalgoritmo
Exercícios
var
: inteiro //Variável contador - Inteiro
: inteiro //Variável tabuada - Inteiro
var
num, mult, res: inteiro
inicio
escreva("Digite um número: ")
leia(num)
escreval("Tabuada de ", num, ":")
escreval("===============")
mult <- 1
enquanto mult <= 10 faca
res <- num * mult
escreval(num, " x ", mult, " = ", res)
mult <- mult + 1
fimEnquanto
fimalgoritmo
Exercícios - Resposta
Escreva um programa que escreva em tela as tabuadas de 1 até 10.
algoritmo "Tabuada Completa"
var
i, num, mult, res: inteiro
inicio
para i de 0 até 9 faca
mult := 1
escreval("===============")
escreval("Tabuada de ", num+1, ":")
num := num + 1
escreval("===============")
enquanto mult <= 10 faca
res := num * mult
escreval(num, " x ", mult, " = ", res)
mult := mult + 1
fimenquanto
fimpara
fimalgoritmo
Fazendo o uso do ENQUANTO
algoritmo "tabuada"
var
n, cont: inteiro
inicio
escreva("Digite um valor (INTEIRO):")
leia(n)
cont <- 1
enquanto (cont <11) faca
escreval(n, " x ", cont, " = ", n * cont)
cont <- cont + 1
fimenquanto
fimalgoritmo
Fazendo o uso do CASO
algoritmo "exemplo3"
var
n: inteiro
inicio
escreva("Digite um numero de 1 a 12: ")
leia(n)
escolha (n)
caso 1
escreva("Janeiro")
caso 2
escreva("Fevereiro")
caso 3
escreva("Marco")
caso 4
escreva("Abril")
caso 5
escreva("Maio")
caso 6
escreva("Junho")
caso 7
escreva("Julho")
caso 8
escreva("Agosto")
caso 9
escreva("Setembro")
caso 10
escreva("Outubro")
caso 11
escreva("Novembro")
caso 12
escreva("Dezembro")
outrocaso
escreva("Numero invalido")
fimescolha
fimalgoritmo
algoritmo "exemplo_condicional"
Exemplo Condicional SE
var
a, b, operacao: inteiro
inicio
escreval("=== OPÇÕES ===")
escreval("[1] a + b * 4")
escreval("[2] (a - b)/ 2")
escreval("[3] b - a ")
escreval("[4] -1 * b / 3")
escreval("---------------")
escreva("Digite o primeiro número: ")
leia(a)
escreva("Digite o segundo número: ")
leia(b)
escreva("Digite a operação desejada: ")
leia(operacao)
se operacao = 1 entao
escreva("Resultado:", a + b * 4)
senao
se operacao = 2 entao
escreva("Resultado:", (a - b) / 2 :2:2)
senao
se operacao = 3 entao
escreva("Resultado:", b - a)
senao
se operacao = 4 entao
escreva("Resultado:", -1 * b / 3 :2:2)
senao
escreva("Operação inválida")
fimse
fimse
fimse
fimse
fimalgoritmo
Expoente
algoritmo "expoente"
var
base, expoente, cont, res: inteiro
inicio
escreva("Digite o valor da base: ")
leia(base)
escreva("Digite o valor do expoente: ")
leia(expoente)
res <- 1
enquanto cont < expoente faca
res <- res * base
cont <- cont + 1
fimenquanto
escreval(base, " ^ ", expoente, " = ", res)
fimalgoritmo
Sequência de Fibonacci
algoritmo "Sequência de Fibonacci"
var
v1, v2, v3, limite, cont: inteiro
inicio
escreva("Digite um limite:")
leia(limite)
v1 <- -1
v2 <- 1
cont <- 0
enquanto (cont < limite) faca
v3 <- v1 + v2
v1 <- v2
v2 <- v3
escreva(v3)
cont <- cont + 1
fimenquanto
fimalgoritmo
algoritmo "media"
Uso de funções
funcao media(x, y, z : real) : real
var
m : real
inicio
m := (x+y+z)/3
retorne m
fimfuncao
var
nome : caractere
n1, n2, n3, n : real
inicio
escreva("Digite o nome do aluno: ")
leia(nome)
escreva("Digite a 1º nota: ")
leia(n1)
escreva("Digite a 2º nota: ")
leia(n2)
escreva("Digite a 3º nota: ")
leia(n3)
escreval("----------------------------")
escreva("O aluno ", nome," Obteve a média: ",media(n1,n2,n3) :2:2)
fimalgoritmo
Escreva um algoritmo que solicite ao usuário a entrada de 5
números, e que exiba o somatório desses números na tela.
Após exibir a soma, o programa deve mostrar também os
números que o usuário digitou, um por linha.
Algoritmo "semnome"
Var
numeros : vetor [0..4] de inteiro
cont, soma : inteiro
Inicio
para cont de 0 ate 4 faca
escreval("Entre com",cont+1,"º número:")
leia(numeros[cont])
soma <- soma + numeros[cont])
fimpara
escreval("A soma dos números é", soma)
escreval()
escreval("Os números digitados foram:")
para cont de 0 ate 4 faca
escreval(numeros[cont])
fimpara
Fimalgoritmo
Estrutura - Vetor
algoritmo "vetores"
var
v: vetor [1..3] de real
indice: inteiro
media: real
inicio
para indice de 1 ate 3 faca
escreva("Digite a nota ", indice, ": ")
leia(v[indice])
fimpara
escreval("-------------------------")
para indice de 1 ate 3 faca
escreval("A nota ", indice, " foi: ", v[indice])
media <- media + v[indice]
fimpara
escreval("-------------------------")
escreval("A média final é: ", media/3 :2:2)
fimalgoritmo
Gerando dados de um Vetor em ordem Alfabética
algoritmo "Vetor_em_ordem_alfabetica"
var
vet: vetor[0..9] de inteiro
i, j, temp: inteiro
inicio
para i de 0 ate 9 faca
escreva("Digite um valor inteiro:")
leia(vet[i])
fimpara
para i de 0 ate 9 - 1 faca
para j de i + 1 ate 9 faca
se vet[i] > vet[j] entao
temp <- vet[i]
vet[i] <- vet[j]
vet[j] <- temp
fimse
fimpara
fimpara
para i de 0 ate 9 faca
escreval(vet[i])
fimpara
fimalgoritmo
Estrutura - Vetor
algoritmo "Exemplo de Uso de Vetor"
var
numeros: vetor[1..5] de inteiro
i: inteiro
inicio
// Leitura dos números
para i de 1 ate 5 faca
escreva("Digite o número ", i, ": ")
leia(numeros[i])
fimpara
Algoritmo "DoisVetores"
Var
nums1 : vetor [0..5] de inteiro
nums2 : vetor [0..5] de inteiro
cont : inteiro
Inicio
para cont de 0 ate 5 faca
escreval("Digite um número:")
leia(nums1[cont])
nums2[cont] <- nums1[cont] * 5
fimpara
escreval()
escreval("Resultado:")
para cont de 0 ate 5 faca
escreval(nums1[cont], " ", nums2[cont])
fimpara
escreval()
Fimalgoritmo
Crie um programa que armazene 10 números digitados pelo
usuário em dois vetores: um somente para números pares, e
outro somente para números ímpares. Após, exiba os valores
dos dois vetores na tela, em sequência. Obs.: As posições que
não receberem valores exibirão o número zero. Não se
preocupe com isso por enquanto.
Algoritmo "Vetor_Par_Impar"
Var
numPar : vetor [0..9] de inteiro
numImpar : vetor [0..9] de inteiro
num, cont : inteiro
Inicio
para cont de 0 ate 9 faca
escreval("Digite um número:")
leia(num)
se (num % 2 = 0 ) entao
numPar[cont] <- num
senao
numImpar[cont] <- num
fimse
fimpara
escreval()
escreval("Resultados:")
escreval("Array de Pares:")
para cont de 0 ate 9 faca
escreval(numPar[cont])
fimpara
escreval()
escreval("Array de Ímpares:")
para cont de 0 ate 9 faca
escreval(numImpar[cont])
fimpara
Fimalgoritmo
Modifique o programa anterior para não aceitar a entrada do número
zero, e requisitar a digitação de outro número neste caso.
Algoritmo "Vetor_Par_Impar_Sem_zero"
Var
numPar : vetor [0..9] de inteiro
numImpar : vetor [0..9] de inteiro
num, cont : inteiro
Inicio
para cont de 0 ate 9 faca
escreval("Digite um número:")
leia(num)
enquanto (num = 0) faca
escreval("Zero é número inválido. Digite outro número:")
leia(num)
fimenquanto
se (num % 2 = 0 ) entao
numPar[cont] <- num
senao
numImpar[cont] <- num
fimse
fimpara
escreval()
escreval("Resultados:")
escreval("Array de Pares:")
para cont de 0 ate 9 faca
escreval(numPar[cont])
fimpara
escreval()
escreval("Array de Ímpares:")
para cont de 0 ate 9 faca
escreval(numImpar[cont])
fimpara
Fimalgoritmo
Modifique novamente o programa anterior, de modo a não exibir na
saída os números zero que são mostrados para todas as posições que
não receberam nenhum valor durante a atribuição (e portanto estão
vazias). Algoritmo "semnome"
Var
numPar : vetor [0..5] de inteiro
numImpar : vetor [0..5] de inteiro
num, cont : inteiro
Inicio
para cont de 0 ate 5 faca
escreval("Digite um número:")
leia(num)
enquanto (num = 0) faca
escreval("Zero é número inválido. Digite outro número:")
leia(num)
fimenquanto
se (num % 2 = 0 ) entao
numPar[cont] <- num
senao
numImpar[cont] <- num
fimse
fimpara
escreval()
escreval("Resultados:")
escreval("Array de Pares:")
para cont de 0 ate 5 faca
se (numPar[cont] <> 0) entao
escreval(numPar[cont])
fimse
fimpara
escreval()
escreval("Array de Ímpares:")
para cont de 0 ate 5 faca
se (numImpar[cont] <> 0) entao
escreval(numImpar[cont])
fimse
fimpara
Fimalgoritmo
Escreva um algoritmo que solicite ao usuário a entrada de 5
nomes, e que exiba a lista desses nomes na tela. Após exibir
essa lista, o programa deve mostrar também os nomes na
ordem inversa em que o usuário os digitou, um por linha.
Algoritmo "Cadastro_de_Nomes"
Var
nomes : vetor [0..4] de caractere
cont : inteiro
Inicio
para cont de 0 ate 4 faca
escreval("Entrecom o",cont+1,"º nome:")
leia(nomes[cont])
fimpara
escreval()
escreval("Os nomes digitados foram:")
para cont de 0 ate 4 faca
escreval(nomes[cont])
fimpara
escreval()
escreval("Os nomes digitados em ordem inversa
foram:")
para cont de 4 ate 0 passo - 1 faca
escreval(nomes[cont])
fimpara
Fimalgoritmo
Procedimento
algoritmo “procedimento"
var
opc : inteiro
inicio
procedimento menu()
inicio
escreval("### MENU ### ")
escreval("(1) Cadastro ")
escreval("(2) Consulta ")
escreval("(3) Listagem ")
escreval("(4) Sair ")
escreval("-------------")
escreva ("Sua Opção: " )
leia(opc)
fimprocedimento
menu()
se opc = 4 entao
escreva("Saindo do sistema")
fimse
fimalgoritmo
algoritmo "variável_global_local"
Variáveis Locais
var
minha_global : inteiro
inicio
minha_global <- 1
escreval(minha_global)
função soma(v1, v2 : inteiro) : inteiro
var
resultado : inteiro
inicio
resultado <- v1 + v2
retorne resultado
fimfuncao
função subtracao(v1, v2 : inteiro) : inteiro
var
resultado : inteiro
inicio
resultado <- v1 - v2
retorne resultado
fimfuncao
escreval(soma(5, 3))
escreval(subtracao(5, 3))
//escreval(resultado)
fimalgoritmo