Este guia tem como objetivo ajudar o leitor a entender e desenvolver lógica de programação e criar algoritmos. Fornece formulários e passos a serem seguidos para estruturar algoritmos, variáveis, estruturas condicionais e de repetição. Não substitui fundamentos de algoritmos, devendo ser usado como material complementar.

1. GUIA PRÁTICO PARA CRIAR ALGORITMOS
1 - INTRODUÇÃO
Este guia tem por objetivo ajudá-lo a entender e desenvolver a lógica de programação e criar algoritmos,
propondo formulários, passos e dicas a serem seguidos. Este material não se propõe a ser uma apostila
ou curso completo de algoritmos e lógica de programação, visto que não inclui os fundamentos de
algoritmos, devendo ser usado apenas como material complementar às notas de aula, apostila ou livro.
2 – NOTAÇÃO UTILIZADA
Neste material, onde você encontrar algo entre < > significa que você deve substituir tudo (inclusive o < >
) pelo que que está indicado entre os sinais < >. Onde você encontrar algo entre [ ] indica que este
fragmento é opcional.
A maioria das estruturas será mostrada na forma de formulários a serem preenchidos. Após preencher
todo o formulário, você terá o seu algoritmo completo, devendo descartar apenas as mensagens
instrutivas que aparecem em letras pequenas.
3 - ESTRUTURA GERAL DE UM ALGORITMO
Todo algoritmo tem a seguinte estrutura:
Algoritmo “nome do seu algoritmo”
Variáveis
<nome da variável>,<nome da variável>,...: <tipo>
<nome da variável>,<nome da variável>,...: <tipo>
<nome da variável>,<nome da variável>,...: <tipo>
...
Inicio
<comandos>
...
...
...
FimAlgoritmo
Repare que a figura acima é um formulário que deve ser preenchido.
 Na seção variáveis você especifica o(s) nome(s) da(s) variável(is), separados por vírgula, e no
final, o tipo da(s) variáveis (vide notas de aulas). As regras para criação de nomes de variáveis
devem ser respeitadas (vide notas de aula).
 Na seção inferior, entre as palavras “Inicio” e “FimAlgoritmo”, você coloca os comandos do seu
algoritmo, um abaixo do outro. Esses comandos serão estruturas seqüenciais, condicionais ou
de repetição
4 – PASSOS BÁSICOS PARA CRIAÇÂO DE ALGORITMOS
1. Ler atentamente o problema, procurando identificar os dados (variáveis) de entrada,
processamento e saída e o tipo de dados de cada um (inteiro, real, caracter, string ou lógico).
Normalmente haverá uma variável para cada dado encontrado.
o OBS: Não se preocupe se não conseguir identificar todos os dados logo de início. À
proporção que for criando o algoritmo poderá incluir novas declarações de variáveis
2. Fazer o esboço inicial de solução do problema
o Você pode fazer esse esboço inicial usando linguagem natural, fluxograma ou diagrama
da Chapin. Caso o problema envolva cálculos, pesquise como esses cálculos são feitos.
3. Identificar as estruturas (seqüenciais, condicionais e de repetição) que serão necessárias para
resolver o problema e incluí-las no seu esboço
4. Organizar a sua solução (esboço) na forma de algoritmo. Para obter ajuda para criar as
estruturas de repetição, consulte o item 6
o Declarar as variáveis encontradas, na seção “variáveis”
o Escrever os comandos entre o “Inicio” e “FimAlgoritmo”

2. 5 - COMANDOS NORMALMENTE USADOS EM CADA SEÇÃO DO ALGORITMO
Os algoritmos (programas) são feitos para processar dados, portanto, ao criar um algoritmo, você deve
sempre lembrar das três operações básicas do processamento de dados: ENTRADA,
PROCESSAMENTO e SAÍDA. Normalmente o seu algoritmo terá uma ou mais seções de comandos
relacionados a essas três operações aparecendo uma ou mais vezes no mesmo.
A ordem mais comum dos comandos num algoritmo é a que está descrita abaixo, porém não é uma
regra geral.
Comandos de entrada de dados
Comandos de processamento de dados
Comandos de saída de dados
COMANDOS DE ENTRADA DE DADOS
A seção de entrada de dados normalmente é a primeira que aparece no seu algoritmo, logo após o
“Inicio”, mas pode aparecer em outros pontos do algoritmo também. Na seção de entrada sempre
teremos o seguinte par de comandos para cada dado (variável) de entrada:
Escreva(“<mensagem>: ”)
Leia(<variável>)
 A <mensagem> deve ser uma mensagem bem explicativa para o usuário, informando o que ele
deve digitar. Exemplos:
o “Digite o seu nome: “
o “Digite o número a ser calculado o fatorial: “
o “Digite a nota 1: “ (caso tenha mais de uma nota como dado de entrada)
 Os comandos de entrada podem estar dentro de uma estrutura de repetição (se algum dado de
entrada existir em quantidade maior que 1. Exemplo: dez números, notas de 30 alunos, etc.) ou
dentro de uma estrutura condicional (se houver uma condição para serem solicitados)
COMANDOS DE PROCESSAMENTO DE DADOS
Os comandos de processamento de dados normalmente aparecem APÓS a entrada de dados e usam os
dados de entrada para obter dados (variáveis) de saída. Os comandos normalmente usados para
processamento são:
 Comandos de atribuição: <variável>  <expressão de valor>
 Comandos em sequência (estrutura seqüencial)
 Estruturas de condição
 Estruturas de repetição
 Estruturas combinadas
COMANDOS DE SAÍDA DE DADOS
Os comandos de saída de dados normalmente aparecem após os de processamento, mas algumas
vezes podem estar junto com os de processamento (numa estrutura de repetição ou condicional), e
sempre estão após os e entrada de dados. O comando mais usado na saída é o comando Escreva:
Escreva(“<mensagem>: ”,<variável ou expressão >)
 A <mensagem> também deve ser uma mensagem bem explicativa para o usuário, informando o
resultado que está sendo apresentado. Exemplos:
o “O seu nome é XXXXX”“
o “O fatorial do número digitado é: XXX“
o “A média das notas digitadas é: XXX”
Esse par se repete p/
cada dado (variável) de
entrada

3. 6 – GABARITOS (FORMULÁRIOS) PARA CRIAÇÃO DE ESTRUTURAS
6.1 – ESTRUTURA CONDICIONAL
Quando usar: sempre que encontrar um ou mais comandos que só deverão ser executados caso uma
condição seja verdadeira
Condição
SE _________________________ ENTAO
Comandos a serem executados caso a condição seja verdadeira:
[ SENÃO
Comandos a serem executados caso a condição seja falsa:
]
FIMSE
 Ao lado do SE, coloque a condição a ser testada. Essa condição deve ser uma expressão lógica
que referencia alguma variável atualizada antes do comando SE
 Caso a condição seja verdadeira, o primeiro bloco de comandos será executado (comandos a
serem executados caso a condição seja verdadeira)
 O bloca SENAO (e os comandos a serem executados caso a condição seja falsa) é opcional e
só será executado caso a condição seja falsa
Exemplo: Algoritmo para verificar se um número digitado é par.
algoritmo "soma numeros"
var
num: inteiro
inicio
Escreval("Digite um número: ")
Leia(num)
Se num mod 2 = 0 entao
Escreval(“O número digitado é par”)
Senão
Escreval(“O número digitado é impar”)
FimSe
Fimalgoritmo
6.2 - ESTRUTURAS DE REPETIÇÃO
Para todas as estruturas de repetição na seguir, valem as seguintes instruções:
 Na seção “Comandos a serem executados antes da repetição”, coloque os comandos que
não precisam ser repetidos e precisam ser executados ANTES da repetição. Normalmente são
comandos de preparo para entrada na repetição, inicialização de variáveis acumuladoras,
variáveis de resultado ou contadores, etc.
 Na seção “Comandos a repetir”, coloque os comandos que devem ser repetidos. Esses
comandos podem ser estruturas seqüenciais simples ou outras estruturas (condicionais ou de
repetição).
 Na seção “Comandos a serem executados depois da repetição”, coloque os comandos que
não precisam ser repetidos e precisam ser executados DEPOIS da repetição. Normalmente são
apresentação de resultados (variáveis de saída) processados na repetição.

4. 6.2.1 - REPETIÇÃO CONTADA (PARA)
Quando usar: quando você notar que a repetição deverá ocorrer uma quantidade determinado de vezes
(essa quantidade pode ser fixa ou determinada por dados de entrada que o usuário irá digitar) ou quando
há claramente a necessidade de contagem numérica progressiva ou regressiva, com incremento
qualquer.
Comandos a serem executados antes da repetição:
Variável int Valor inicial Valor final incremento
Para ______ de __________ até _____ [passo ______ ] faca
Comandos a repetir:
FimPara
Comandos a serem executados depois da repetição:
Na seção “Para ... de ... até ... faca”, preencha os espaços em branco com:
 A variável tipo inteiro, que será o contador (variável auxiliar). Ela deve ter sido declarada
 O valor inicial e o valor final da contagem da repetição. Pode ser um número constante (ex: 1),
uma variável (ex: aux) ou uma expressão (aux + 1), desde que seja do tipo inteiro.
 O incremento da contagem, que é o valor que será adicionado à variável de contagem cada
vez que a execução chega no FimPara
o É OPCIONAL: Se o incremento desejado for 1 você pode retirar o “passo” do comando
e não informar o valor do incremento.
o Se o valor final for menor que o valor inicial (contagem regressiva), o passo (incremento)
deve ser um valor inteiro negativo
Exemplo: Criar algoritmo para contar de 2 a 2, sendo que o início e final da contagem será informado
pelo usuário.  Neste caso a palavra “contar” nos dá certeza que a repetição é contada
Algoritmo “contagem 2 a 2, destacando múltiplos de 5”
Var
Cont, inicio, final: inteiro
Inicio
Escreval(“Algoritmo para contar, 2 a 2”)
Escreva(“Digite o número p/ início da contagem: “)
Leia(inicio)
Escreva(“Digite o número p/ final da contagem: “)
Leia(final)
Escreval(“Iniciando contagem...”)
Para cont de inicio ate final passo 2 faca
Escreva(“Contando...”,cont)
Se cont mod 5 = 0 entao
Escreval(“ (múltiplo de 5)”)
Senão
Escreval(“ “)
FimSe
FimPara
Escreval(“Fim!”)
FimAlgoritmo

5. 6.2.2 - REPETIÇÃO CONDICIONAL COM TESTE NO INÍCIO (ENQUANTO)
Quando usar: quando a repetição não se enquadrar no caso da repetição contada e a primeira
execução dos comandos só deve ser executados se uma condição for previamente testada e verdadeira
(os comandos só serão executados pelo menos uma vez se a condição for verdadeira)
Comandos a serem executados antes da repetição:
Condição para iniciar e continuar a repetição:
ENQUANTO _________________________
Comandos a repetir:
FIMENQUANTO
Comandos a serem executados depois da repetição:
Ao lado da palavra “ENQUANTO”, coloque a condição para iniciar e continuar a repetição. Essa
condição deve ser uma expressão lógica que foi previamente preparada na seção “Comandos a serem
executados antes da repetição” e que será atualizada na seção “Comandos a repetir”, através da
alteração do valor de alguma variável que faz parte da expressão lógica.
OBS: Essa condição é testada uma vez no comando enquanto e a cada vez que a execução chega no
comando FimEnquanto. Se o resultado for falso, a execução continua no comando após o FimEnquanto.
Exemplo: Criar um algoritmo para somar números digitados pelo usuário. Ao digitar o número zero a
soma deve ser apresentada
Solução (usando os passos básicos para criação de algoritmos (item 4) )
1. Identificar dados de entrada, processamento e saída:
ENTRADA PROCESSAMENTO SAÍDA
num (inteiro) soma (inteiro) soma (inteiro)
2. Fazer esboço inicial da solução do problema:
1. Solicitar número e aguardar digitação do mesmo (variável num)
2. Acumular o número digitado na memória (variável soma)
3. Se o número digitado não for zero, voltar ao passo 1
4. Senão, mostrar o valor acumulado (variável soma)
3. Neste caso sabemos que precisaremos de uma estrutura de repetição porque o algoritmo
menciona “números digitados pelo usuário”. Como é mais de um número, precisaremos repetir
um comando de leitura de dados. Como não sabemos QUANTOS números o usuário irá digitar,
então a repetição será condicional e pode ser com teste no inicio ou no final. Podemos notar que
haverá repetição também observando que no esboço da solução há a expressão “voltar ao
passo passo 1”. Os passos do esboço inicial que serão repetidos serão os passos 1 e 2, portanto
os comandos relativos a eles ficarão na seção “Comandos a repetir”
4. Organizar a solução na forma de algoritmo:

6. algoritmo "soma numeros"
var
num,soma: real
inicio
Escreval("Algoritmo para somar números.")
num<-1
Enquanto num<>0 faca
Escreva("Numero a somar (zero encerra): ")
Leia(num)
soma<-soma+num
FimEnquanto
Escreva("A soma dos números digitados é: ",soma)
fimalgoritmo
6.2.3 - REPETIÇÃO CONDICIONAL COM TESTE NO FINAL (REPITA)
Quando usar: quando a repetição não se enquadrar no caso da repetição contada e os comandos
devam ser executados PELO MENOS UMA VEZ, MESMO QUE A CONDIÇÃO PARA REPETIÇÃO NÃO
SEJA SATISFATÓRIA.
Comandos a serem executados antes da repetição:
REPITA
Comandos a repetir:
Condição para parar a repetição:
ATÉ ___________________
Comandos a serem executados depois da repetição:
Ao lado da palavra “ATÉ”, coloque a condição para PARAR a repetição. Essa condição deve ser uma
expressão lógica que foi previamente atualizada na seção “Comandos a repetir” e que será atualizada na
seção “Comandos a repetir”, através da alteração do valor de alguma variável que faz parte da
expressão lógica.
OBS: Essa condição é testada somente APÓS os comandos a repetir. Por isso os comandos a repetir
serão executados sempre, pelo menos uma vez.
Exemplo: algoritmo anterior reescrito com a estrutura REPITA:
algoritmo "soma numeros"
var
num,soma: real
inicio
Escreval("Algoritmo para somar números.")
Repita
Escreva("Numero a somar (zero encerra): ")
Leia(num)
soma<-soma+num
Ate num=0
Escreva("A soma dos números digitados é: ",soma)
fimalgoritmo
Note que a estrutura REPITA se adequou melhor a esse problema, visto que pelo menos um número
deve ser digitado, e que, como não há mais condição para entrar na repetição, não foi mais necessário o
comando “num <- 0” para preparar a condição de repetição

8. JOGO: QUEBRA-CABEÇA DE ALGORITMOS
Regra básica: imprimir e recortar as linhas de instrução de cada algoritmo. Embaralhar as linhas. O aluno deverá colocar em ordem.
Sugestão de uso:
 Imprimir uma cópia de cada algoritmo e recortar. Os algoritmos são numerados para facilitar a identificação.
 Dividir a turma em equipes e dar um conjunto de peças de cada algoritmo (embaralhadas) para cada equipe. Cada equipe deverá montar
o seu algoritmo de acordo com a regra básica.
 Avaliar a montagem do algoritmo de cada equipe sendo que a equipe que montar o algoritmo em menor tempo ganha marca 10 pontos, a
segunda 9 pontos e assim por diante.
 A equipe que terminar, recebe outro algoritmo que ainda não tenha sido feito por ela
Algoritmo “contagem regressiva” 1
Variaveis 1
Contagem: inteiro 1
Inicio 1
Para contagem de 10 ate 1 passo -1 faca 1
Escreval(contagem) 1
FimPara 1
Escreva “Fogo!” 1
FimAlgoritmo 1
Algoritmo “maioridade” 2
Variáveis 2
Idade: real 2

9. Inicio 2
Escreva(“Digite a sua idade: “) 2
Leia(idade) 2
Se idade<18 2
Escreval(“Você é menor de idade”) 2
Senão 2
Escreval(“Você é maior de idade”) 2
FimSe 2
FimAlgoritmo 2