Algoritmos e lp parte3-pseudocódigo

Algoritmos e Linguagem
de Programação
Professor: Mauro Jansen

Parte 3 – Pseudocódigo

15/09/2010

Algoritmos e Ling.de Programação
Prof. Mauro Pseudocódigo 2

Pseudocódigo
Forma para a representação de algoritmos rica
em detalhes, como a definição dos tipos das
variáveis usadas no algoritmo.

Assemelha-se à forma como os programas são escritos.
Para traduzir o pseudocódigo para uma linguagem de
programação, basta conhecer o vocabulário e regras
sintáticas da linguagem.
Busca a rigidez sintática e semântica, porém sem o
detalhamento exigido nas linguagens de programação


Estrutura básica
Todo pseudocódigo possui a seguinte estrutura básica:

Algoritmo <nome do Algoritmo>
Variáveis
<lista de variáveis>
Início
<bloco de comandos>
Fim

As palavras em negrito são palavras reservadas:
palavras em português que indicam seções do
pseudocódigo ou ações a serem executadas pelo
computador (instruções)

Estrutura básica
Na seção Variaveis ou Var declaramos as
variáveis
Entre as palavras Inicio e Fim inserimos a
sequência de comandos do nosso algoritmo, que
pode conter também referência a variáveis e
expressões
Toda linha de comando termina com “;” (ponto e
vírgula) (há exceções para esta regra)


Exemplo de pseudocódigo
Pseudocódigo referente ao problema do
maior número:
Algoritmo Maior
Var
num1, num2, maior: inteiro:
Inicio
Leia(num1,num2);
se (num1>num2) então
maior num1;
senão
maior num2;
fimse;
escreva(maior);
Fim


Notação usada nas sintaxes
Ao definirmos a sintaxe de comandos e
instruções é usada a seguinte notação:
Palavras em negrito são palavras reservadas
Palavras entre < > são elementos do
algoritmo a serem substituídos por nomes ou
valores a serem definidos pelo programador
Elementos entre [ ] são opcionais
Textos entre { } são comentários explicativos
do algoritmo e não são executados pelo
computador


Declaração de variáveis
Declaração de Variáveis: todas as variáveis
que serão utilizadas pelo algoritmo devem ser
declaradas entre as palavras reservadas
Variaveis (ou Var) e Inicio:
Algoritmo Exemplo
Variaveis
a: Inteiro;
b: Real;
Inicio
<bloco de comandos>
Fim


Comando de atribuição ( )
Armazena um valor em uma variável
previamente declarada
No pseudocódigo, o comando de atribuição
é o símbolo “ ”
Sintaxe: <variável> <valor>;
Exemplos:
salario 1200; {variável salario recebe o valor 1200}
nome “Maria”; {variável nome recebe “Maria”`}
media (nota1+nota2)/2; {variável media recebe o
resultado da expressão}


Comando de entrada de dados (Leia)
Sempre que precisamos que o usuário digite
algum dado para ser processado, teremos uma
entrada de dados
O comando usado para receber essa entrada de
dados no pseudocódigo é o comando Leia
Sintaxe: Leia <variável>[,<variável>,...];
ou Leia(<variável>[,<variável>,...]);

Exemplos:
Leia salario; {obtém valor digitado e armazena
na variável salário}
Lea nome;
Leia nota1,nota2;


Comando de saída de dados (Escreva)
Usado para exibir ou retornar qualquer
valor ou mensagem ao usuário:
Mensagem de orientação
Valor constante
Valor armazenado em uma variável
Escreva <expressão>[,<expr.>,...];
Sintaxe: ou Escreva(<expressão>[,<expr.>,...]);
Exemplos: Exibe a frase “Olá Mundo!”
Escreva “Olá Mundo!”;
Exibe o valor 12345
Escreva 12345;
Escreva media; Exibe o valor da variável media


Exemplo de algoritmo 1
Algoritmo que lê duas notas, calcula a
média e mostra o resultado:
Algoritmo CalculaMedia Nome do Algoritmo
Variáveis
nota1, nota2, media: Real Declaração de
Início Variáveis
Escreva “Digite a primeira nota” Mensagem de Orientação
Leia nota1 Inserção da primeira nota
Escreva “Digite a segunda nota” Mensagem de Orientação
Leia nota2 Inserção da segunda nota
media ← (nota1 + nota2)/2 Cálculo da média e atribuição
Escreva media do resultado à variável media
Fim Exibição do resultado


Um algoritmo que lê o salário de uma pessoa,
calcula e mostra o valor do novo salário após
um aumento de 10%.
Inicialmente, devemos identificar os dados de entrada.
Neste caso, a entrada consiste no valor do salário.
Em seguida, identificamos a saída.
Para este problema, a saída é o novo salário.
O processamento necessário para transformar a entrada
na saída é dado pelo cálculo do reajuste (10% do salário)
e, em seguida, pelo acréscimo desse valor ao salário.
Reajuste = salário * 0.10
Novo salário = salário + Reajuste


Algoritmo NovoSalario
Variáveis
salario, reajuste, novosalario: Real
Início
Escreva “Digite o valor do salario”
Leia salario
reajuste ← salario * 0.10
novosalario ← salario + reajuste
Escreva novosalario
Fim

O processamento poderia ser expresso de maneira simplificada
através da fórmula:
novosalario ← salario + salario * 0.10, ou ainda
novosalario ← salario * 1.10


Teste de algoritmos
Testar ou “depurar” um programa ou
algoritmo consiste em analisar os
resultados do programa gradativamente,
linha por linha, em busca de possíveis
erros
Para isso os ambientes de desenvolvimento
oferecem uma ferramenta chamada
“debugger”
Manualmente, dispomos do teste de mesa
ou tabela de teste

Teste de mesa ou tabela de teste
É uma tabela onde temos:
Uma coluna para o número da linha do algoritmo
Uma coluna para cada variável (de entrada e saída) do
algoritmo
Uma coluna para comentários
A cada linha do algoritmo, preenchemos a tabela
com o valor das variáveis e comentário do
ocorrido
É útil para analisar o funcionamento de um
algoritmo pequeno ou fragmento de um
algoritmo maior


Teste de mesa ou tabela de teste
Tabela de teste para uma possível execução do algoritmo
da média de duas notas
Lin nota1 nota2 media Comentário
1 ? ? ? Solicita que usuário digite nota1
2 ? ? ? Aguarda usuário digitar nota1
3 8 ? ? Solicita que usuário digite nota2
4 8 ? ? Aguarda usuário digitar nota2
5 8 7 7.5 Calcula a média
6 8 7 7.5 Mostra a média


Exercícios de fixação
Qual a estrutura (formato) básica de um
pseudocódigo?
Em que parte do pseudocódigo declaramos
as variáveis?
Em que parte do pseudocódigo colocamos
os comandos?
Em que consiste o teste de algoritmos?


Exercícios de aplicação
Usando pseudocódigo, faça algoritmos
para resolver os seguintes problemas:
Calcular a área de um retângulo
Armazenar dois números em variáveis e trocar
os valores das variáveis
Calcular as raízes de uma equação do segundo
grau
Calcular o custo estimado com combustível em
uma viagem de carro


Estruturas condicionais
São estruturas que permitem a tomada de decisões
em função de condições estabelecidas e assim, o
algoritmo apresenta ações alternativas.
A classificação das estruturas de seleção é feita de
acordo com o número de condições que devem ser
testadas para que se decida qual o caminho a ser
seguido. Segundo esta classificação, têm-se dois
tipos de estruturas de decisão:
se
escolha


Estrutura SE
São estruturas de controle de fluxo, que
executam um ou vários comandos se a
condição testada for verdadeira e, em alguns
casos, executam um ou vários comandos se
for falsa.
Podem ser:
Simples
Compostas


Estrutura SE simples
Um bloco de instruções será executado
somente se uma condição for verdadeira.
Caso contrário, o fluxo de execução segue
para depois do bloco (ou após o FimSe)
Formato: Se <condição> então
<bloco de comandos>
FimSe

<condição> pode ser uma variável booleana,
uma constante (V ou F) ou uma expressão de
valor lógico

Estrutura SE simples – exemplo 1
Algoritmo para solicitar um número e verificar se
o número digitado é maior que 10

Algoritmo MaiorQue10
Variáveis
num: Real
Início
Escreva(“Digite um número”)
Leia(num)
Se num>10 então
Escreva(“O número é maior que 10.”)
FimSe
Escreva(“Fim do algoritmo”)
Fim


Estrutura SE simples – exemplo 2
Algoritmo CalculaMedia alterado para mostrar se aluno está
aprovado, sendo que a média para aprovação é 7
Algoritmo CalculaMedia
Variáveis
nota1, nota2, media: Real
Início
Escreva(“Digite a primeira nota”)
Leia(nota1)
Escreva(“Digite a segunda nota”)
Leia(nota2)
media ← (nota1 + nota2)/2
Escreva(“Sua média é: “,media)
Se media>=7 então
Escreva(“Você está aprovado”)
FimSe
Fim

Estrutura SE composta
Se a condição for verdadeira, o bloco de
comandos 1 será executado. Caso contrário, o
bloco de comandos 2 será executado.
Formato: Se <condição> então
<bloco de comandos 1>
Senão
FimSe

<condição> pode ser uma variável booleana, uma
constante (V ou F) ou uma expressão de valor lógico


Estrutura SE composta – exemplo 1
Algoritmo para solicitar um número e verificar se
o número digitado é maior que 10
Algoritmo MaiorQue10
Variáveis
num: Real
Início
Escreva(“Digite um número”)
Leia(num)
Se num>10 então
Escreva(“O número é maior que 10.”)
senão
Escreva(“O número é menor ou igual a 10”)
FimSe
Escreva(“Fim do algoritmo”)
Fim


Estrutura SE composta – exemplo 2
Algoritmo CalculaMedia alterado para mostrar se aluno está
aprovado, sendo que a média para aprovação é 7
Variáveis
Início
Leia(nota1)
Leia(nota2)
Se media>=7 então
senão
Escreva(“Você está de recuperação”)
FimSe
Fim Algoritmos e Ling.de Programação

Estruturas SE encadeadas
É quando o bloco de instruções subordinado ao
comando se/senão contém outros comandos
se/senão (quando temos mais de 2 situações):
Se <condição 1> então
Senão se <condição 2> entao
Senão se <condição 3> entao
...
Senão se <condição N> entao
<bloco de comandos N>
FimSe

Estruturas SE encadeadas - exemplo
Algoritmo CalculaMedia alterado para tratar mais uma regra: se a
média for menor que 3, o aluno já estará reprovado, sem direito à
recuperação
Variáveis
Início
Leia(nota1)
Leia(nota2)
Se media>=7 então
senão se media<3 então
Escreva(“Você está reprovado”)
senão
Escreva(“Você está de recuperação”)
FimSe
Fim

Estrutura ESCOLHA
Estrutura de decisão por igualdade, onde temos:
uma variável a ser testada (variável de escolha)
um ou mais valores constantes a serem comparados
com a variável, com um bloco de comandos associado
a cada um
Também é chamada de estrutura CASO
É similar a estruturas SE encadeadas, mas as
comparações são só por igualdade
São úteis em menus ou situações onde as
decisões estão centradas em apenas uma
variável e valores pré-fixados


Estrutura ESCOLHA
Sintaxe:
Escolha <variável>
caso <val.constante 1>:
caso <val.constante 2>:
...
caso <val.constante n>:
<bloco de comandos n>
outrocaso
<bloco de comandos alternativo>
FimEscolha

<variável> será comparada com o valor constante de cada “caso”
Será executado somente o bloco de comandos abaixo do “caso” onde
houver igualdade entre a variável e o valor constante


Estrutura ESCOLHA - exemplo
Algoritmo MenuCalculo
Variáveis
num1, num2, opcao: Real
Início
Escreva(“1-Soma”)
Escreva(“2-Subtração”)
Escreva(“3-Multiplicação”)
Escreva(“Digite a sua opção:”)
Leia(opcao)
Escreva(“Digite o primeira numero: ”)
Leia(num1)
Escreva(“Digite o segunda número: ”)
Leia(num2)
Escolha opcao
caso 1
Escreva(“Soma=“,num1+num2)
caso 2
Escreva(“Subtração=“,num1-num2)
caso 3
Escreva(“Multiplicação=“,num1*num2)
outrocaso
Escreva(“Opção inválida”)
FimEscolha
Fim Algoritmos e Ling.de Programação

Exercícios
Faça um algoritmo que leia um número inteiro
diferente de zero e diga se este é positivo ou
negativo
Altere o algoritmo anterior para dizer também se
o número é igual a zero (use se encadeados)
Faça uma algoritmo que leia três valores que
representam os três lados de um triângulo e
verifique:
se o triângulo é válido
Se é um triângulo equilátero, isósceles ou escaleno


Exercícios
Propriedades de um triângulo:
A soma de dois lados não pode ser menor que
a do terceiro lado (ou o comprimento de cada
lado deve ser menor que a soma dos outros
dois lados)
Equilátero: três lados iguais
Isósceles: dois lados iguais
Escaleno: três lados diferentes


Estruturas de repetição
Permitem a repetição de um bloco de
instruções por um número vezes pré-
determinado ou até a satisfação de uma
condição
Também são chamados de loops (laços)
Tipos de estruturas:
Repetição contada (estrutura para)
Repetição condicional
Com teste no início (estrutura enquanto)
Com teste no final (estrutura repita)

Estruturas de repetição
“Laço sem fim” ou deadLock: é quando
uma estrutura de repetição fica
executando interminavelmente
As estruturas de repetição devem sempre ter
um fim, ou seja, devem ter um limite pré-
definido de repetições ou alguma condição que
faça a repetição parar, caso contrário teremos
um loop sem fim ou deadlock
É uma das causas dos “travamentos” de
software (mensagem “Este programa não está
respondendo”)

Estrutura de repetição contada
É utilizada quando conhecemos
previamente a quantidade de vezes que
queremos executar o bloco de comandos
A quantidade de vezes pode ser um valor
constante ou informado pelo usuário
É representada pelo comando PARA


Comando Para (repetição contada)
Sintaxe:
Para <variável> de <valor inicial> até <valor final> [passo <incremento>] faça
<bloco de comandos>
FimPara

Descrição:
<variável>: nome de uma variável do tipo inteiro
<valor inicial>: é o valor inicial que será atribuído à variável
<valor final>: quando a variável for maior ou igual ao valor final,
a repetição termina
<incremento> é o valor que será incrementado à variável a cada
repetição (ao final do bloco de comandos). É opcional; se não for
informado, é assumido incremento 1.


Comando Para (exemplo 1)
Algoritmo que lista os dez primeiros
números inteiros positivos
Algoritmo DezPrimeiros A variável i fará o controle da
Variáveis repetição, seu valor inicia com
i: Inteiro 1 e para cada execução do
bloco seu valor aumenta em 1
Início unidade.
Para i de 1 até 10 faça
Escreval(i)
FimPara Para cada repetição, basta
Fim mostrar o valor de i, uma vez
que este valor variará de 1 até
10.


Comando Para (exemplo 2)
Algoritmo que lista os números inteiros pares
menores ou iguais a um número informado pelo
usuário
Algoritmo NumerosPares
Variáveis
i,limite: Inteiro
Início
Escreva(“Listar números pares até: “)
Leia(limite)
Para i de 2 ate limite passo 2 faca
Escreval(i)
FimPara
Fim


Estruturas de repetição condicional
São usadas quando não sabemos previamente a
quantidade exata de vezes que queremos
executar o bloco de comandos
A quantidade de repetições depende de uma condição
(expressão lógica) controlada internamente
Existem duas estruturas de repetição condicional:
Com teste no início (estrutura enquanto...faça)
Com teste no final (estrutura repita...até)


Características da repetição condicional
As estruturas de repetição condicional
caracterizam-se por conter dois blocos de
comandos importantes:
PREPARO: um ou mais comandos que afetam
a condição para entrar no bloco de repetição
ou que preparam variáveis que serão usadas
dentro da bloco de comandos
CONTROLE: um ou mais comandos que
afetam a condição para finalizar a repetição


Estrutura Enquanto...faça
Sintaxe:
Enquanto <expressão lógica> faca
<bloco de comandos>
FimEnquanto
Uso: repete o bloco de comandos enquanto uma
determinada condição (especificada através da expressão
lógica) for satisfeita.
A <expressão lógica> é verificada logo na entrada e a
cada repetição. Se for falsa, a execução continua logo
após o FimEnquanto
O FimEnquanto marca o final do bloco de comandos a ser
repetido e causa o retorno ao comando Enquanto


Estrutura Enquanto (exemplo 1)
Algoritmo para contar de 1 a 10, listando
os números na tela
PREPARO: A variável i fará o
algoritmo “Conta com enquanto” controle da repetição e inicia a
var i: inteiro contagem, portanto devemos
Inicio inicializá-la com o valor 1
i <- 1
enquanto i <= 10 faca
escreval(i) CONTROLE: dentro do laço
deve haver um comando que
i <- i + 1 afete a expressão lógica. Aqui
fimenquanto incrementamos a variável i, de
fimalgoritmo modo que quando ela for
maior que 10 a repetição irá
parar


Estrutura Enquanto (exemplo 2)
Algoritmo para somar números digitados pelo
usuário, enquanto não for digitado zero
algoritmo “Soma” PREPARO: Aqui inicializamos
var n,soma: real a variável com um valor maior
que zero, para entrar no laço e
Inicio
zeramos a variável soma que
n <- 0
irá guardar a soma
soma <- 0
enquanto n<>0 faca
escreva(“Digite um número (0=fim):”) CONTROLE: o próprio
leia(n) número digitado pelo usuário
soma <- soma + n será usado como controle. Se
fimenquanto for digitado zero, a condição
Escreva(“A soma dos numeros é: “,soma) ficará falsa e o laço irá parar
fimalgoritmo


Estrutura Repita...Até
Sintaxe:
Repita
<bloco de comandos>
Até <expressão lógica>

Uso: repete o bloco de comandos até que determinada
condição (especificada através da expressão lógica) seja
satisfeita
A <expressão lógica> é verificada ao final de cada
repetição. Se for verdadeira, a execução continua logo
após o Até
O Até marca o final do bloco de comandos a ser repetido
e causa o retorno ao comando repita, caso a expressão
lógica seja falsa

Estrutura Repita (exemplo 1)
Algoritmo para contar de 1 a 10, listando
os números na tela
PREPARO: A variável i fará o
algoritmo “Contar com repita” controle da repetição e inicia a
var i: inteiro contagem, portanto devemos
Inicio inicializá-la com o valor 1
i <- 1
Repita
escreval(i) CONTROLE: Aqui
incrementamos a variável i, de
i <- i + 1 modo que quando ela for maior
até i>10 que 10 a repetição irá parar
fimalgoritmo


Estrutura Repita (exemplo 2)
Algoritmo para somar números digitados pelo
usuário, até que seja digitado zero
algoritmo “Soma” PREPARO: Aqui apenas
var n,soma: real zeramos a variável soma. Não
é necessário prepararmos a
Inicio
expressão lógica, visto que a
soma <- 0
variável de controle será lida
Repita dentro do laço
escreva(“Digite um número (0=fim):”)
leia(n) CONTROLE: o próprio
soma <- soma + n número digitado pelo usuário
Ate n=0 será usado como controle. Se
Escreva(“A soma dos numeros é: “,soma) for digitado zero, a condição
fimalgoritmo será verdadeira e o laço irá
parar


Estrutura Enquanto x Repita
Estruturas tipo Enquanto:
São úteis quando precisamos de teste desde a entrada
no laço
O bloco de comandos só será executado se a condição
for verdadeira logo no início
A repetição termina quando a expressão lógica for falsa
Estruturas tipo Repita:
São úteis quando não há necessidade de teste no início
O bloco de comandos será executado sempre, pelo
menos uma vez
A repetição termina quando a expressão lógica for
verdadeira


Intervenções forçadas na repetição
Apesar de não ser uma boa prática de
programação, algumas linguagens oferecem
comandos para a intervenção forçada (retorno ao
início ou interrupção) nas estruturas de repetição
retorno
Retorno ao início (comando “volte”): faz com que
a execução volte ao início do laço (comando enquanto
ou repita)
Interrupção (comando “interrompa”): faz com
que a repetição pare (a execução continua no
comando após o comando fimenquanto ou até)
Geralmene esses comandos podem ser usados
em qualquer estrutura (para, enqunto ou repita)


Retorno ao início (comando “volte”)
Sintaxe da Enquanto com comando de
retorno ao início:
<bloco de comandos>
se <condição> então
volte
fimse
<Bloco de comandos>
FimEnquanto

O comando volte força a “próxima rodada” do laço: o fluxo
de execução volta para o início do laço (comando Enquanto)
Numa estrutura “para” a variável será incrementada

Interrupção forçada (comando “interrompa”)

Sintaxe da Enquanto com comando de
interrupção forçada:
<bloco de comandos>
se <condição> então
interrompa
fimse
<Bloco de comandos>
FimEnquanto
<comando>...

O comando interrompa faz com que a repetição termine e o fluxo de
execução continue no comando após o laço (após o FimEnquanto)

Combinando estruturas
Você pode combinar as estruturas estudadas
(sequencial, condicional e repetição), uma dentro
do bloco de comandos de outra
Condicional dentro de condicional (estruturas se
encadeadas) (já estudado)
Condicional dentro de repetição
Repetição dentro de uma condicional
Repetição dentro de outra repetição (estruturas de
repetição encadeadas)
..etc.
Vejamos alguns exemplos a seguir...


Condicional dentro de repetição
Ex: listar os números de 1 a 100, destacando os
múltiplos de 10
Algoritmo “0 a 100 destacando pares”
Estrutura PARA contando de
Variáveis
1 a 100
i: Inteiro
Início
Para i de 1 ate 100 faca
Escreva(i) Testa se o número é divisível
se i mod 10 = 0 entao por 10 (resto da divisão por 10
escreval(“ (múltiplo de 10)”) é zero)
senao
escreval(“”)
fimse
FimPara
Fim


Estruturas de repetição encadeadas
Ex: imprimir a tabuada de multiplicar de 1 até 10

Algoritmo “tabuada de multiplicar”
Laço dos multiplicandos (n1
Variáveis
varia de 1 até 10)
n1,n2: Inteiro
Início
Para n1 de 1 ate 10 faca
Escreva(“Tabuada de “,n1) Laço dos multiplicadores (n2
Para n2 de 1 ate 10 faca varia de 1 até 10)
escreval(n1,” x “,n2,” = “,n1*n2)
FimPara
escreval(“--------------”)
FimPara
Fim


Cuidados ao combinar estruturas
Ao combinar estruturas, você nunca deve
“cruzar” uma estrutura com outra:
Para i de 1 ate 100 faca
Escreva(i)
se i mod 10 = 0 entao
escreval(“ (múltiplo de 10)”)
FimPara
fimse

Enquanto i<100
Escreva(i)
se i mod 10 = 0 entao
escreval(“ (múltiplo de 10)”)
FimEnquanto
fimse


Cuidados ao combinar estruturas
Quando combinadas, elas devem sempre
estar contidas uma dentro da outra:
Para .....
Enquanto
Repita
Escreva(i)
se .... entao
<comandos>
senao
<comandos>
fimse
Ate <condição>
FimEnquanto
FimPara


Exercícios – faça algoritmos para:
Multiplicar dois números usando somas
repetidas
Solicitar uma quantidade pré-determinada
de números e calcular a soma e média
entre esses números
Calcular a soma dos números ímpares
entre um intervalo informado
Calcular o fatorial de um número


Exercício-desafio:
Solicitar os nomes e notas dos alunos de uma turma, mostrar o nome
e nota dos alunos com a maior e menor nota e calcular a média entre
as notas da turma. O fim da turma será indicado quando o usuário
digitar “FIM” para o nome do aluno
Melhorar o algoritmo acima para efetuar os mesmos cálculos para
todas as turmas de uma escola, mostrando também a maior e menor
nota da escola e a nota média da escola
Listar os números primos entre dois números informados pelo usuário.
Dicas:
Número primo é o número que só é divisível por ele mesmo e por
1.
Para saber se um número é primo você precisará usar um laço e
testar, com a função MOD, se ele é divisível por todos os números
menores que ele
Listar os números da série de Fibonacci de 1 até um número
informado pelo usuário. Dica:
A séria de Fibonacci é uma lista de números cujos dois primeiros
númereos são iguais a 1 e cada número seguinte é igual à soma
dos dois números anteriores: 1, 1, 2, 3, 5, 8, ..

Algoritmos e lp parte3-pseudocódigo

Mais conteúdo relacionado

Mais procurados

Semelhante a Algoritmos e lp parte3-pseudocódigo

Mais de Mauro Pereira

Algoritmos e lp parte3-pseudocódigo