Apostila Programação de Computadores

Prévia do material em texto

PROF. RICARDO LUIZ DE FREITAS 
 
2015 
 
(Adaptado da apostila “Algoritmos com VisuAlg” do Prof. Air Rabelo – 2014) 
PPrrooggrraammaaççããoo 
ddee 
CCoommppuuttaaddoorreess 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 2 
Sumário 
 
 
1 - Introdução ............................................................................................................................. 4 
1.1 - Conceitos de Algoritmo .................................................................................................. 4 
1.2 - Princípios básicos de um algoritmo ................................................................................ 4 
1.3 - Exemplo de Algoritmo “genérico” ................................................................................... 5 
1.4 - No computador, como os algoritmos são escritos? ........................................................ 5 
1.5 - Algoritmo x Programa .................................................................................................... 5 
1.6 - Linguagem de Programação .......................................................................................... 5 
1.7 - Programa Fonte ............................................................................................................. 6 
1.8 - Programa Objeto ............................................................................................................ 6 
1.9 - Compiladores ................................................................................................................. 6 
1.10 - Portugol ........................................................................................................................ 7 
1.11 - A tabela ASCII .............................................................................................................. 7 
1.12 - Síntese ......................................................................................................................... 9 
2 - O VisuAlg ............................................................................................................................ 10 
2.1 - O que é o VisuAlg? ...................................................................................................... 10 
2.2 - Instalação e Requerimentos de Hardware ................................................................... 10 
2.3 - Instalação do VisuAlg ................................................................................................... 10 
2.4 - Tela do VisuAlg: ........................................................................................................... 14 
2.5 - Barra de tarefas para edição do algoritmo: .................................................................. 15 
2.6 - Barra de tarefas para execução e controle de algoritmo: ............................................. 16 
2.7 - Visualizador de Variáveis ............................................................................................. 17 
2.8 - Janela de Saída ........................................................................................................... 17 
2.9 - Compilando e Executando um algoritmo no VisuAlg ................................................... 18 
2.10 - Síntese ....................................................................................................................... 21 
3 - O Portugol do VisuAlg: conceitos iniciais ............................................................................ 22 
3.1 - Estrutura básica de um algoritmo escrito no Portugol do VisuAlg ................................ 22 
3.2 - Linha de Comando ....................................................................................................... 22 
3.3 - Comentários no programa ........................................................................................... 22 
3.4 - Identação ..................................................................................................................... 23 
3.5 - Dados ........................................................................................................................... 23 
3.6 - Tipos de Dados ............................................................................................................ 24 
3.7- Variáveis ....................................................................................................................... 24 
3.8 - Nomes (ou identificadores) de Variáveis ...................................................................... 26 
3.9 - Declaração de Variáveis .............................................................................................. 28 
3.10 - Linha de Comando no VisuAlg ................................................................................... 29 
3.11 - Comando de Atribuição: atribuindo valores às Variáveis ........................................... 29 
3.12 - Operadores e Expressões Aritméticas ....................................................................... 30 
3.12.1 - Operadores Aritméticos ....................................................................................... 30 
3.12.2 - Expressões Aritméticas ....................................................................................... 31 
3.13 - Operadores e Expressões Lógicas (Booleanas) ........................................................ 33 
3.13.1 - Operadores Relacionais ...................................................................................... 33 
3.13.2 - Operadores Lógicos ............................................................................................ 34 
3.13.3 - Tabela Verdade para operações lógicas: ............................................................ 35 
3.13.4 - Expressões booleanas ........................................................................................ 35 
3.14 - Síntese ....................................................................................................................... 35 
4 - Comando de saída de dados: escrevendo informações na tela ......................................... 37 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 3 
4.1 - Comando ESCREVA ................................................................................................... 37 
4.2 – Exercícios Resolvidos ................................................................................................. 41 
4.3 - Síntese ......................................................................................................................... 43 
5 - Comando de entrada de dados: recebendo dados ao usuário ........................................... 44 
5.1 - Comando LEIA ............................................................................................................. 44 
5.2 - Exercícios Resolvidos .................................................................................................. 46 
5.3 - Síntese ......................................................................................................................... 48 
6 - Estrutura Condicional: o computador tomando decisões .................................................... 49 
6.1 - Comando SE ................................................................................................................ 49 
6.1.1 - Forma Simples ...................................................................................................... 49 
6.1.2 - Forma Composta ................................................................................................... 51 
6.2 - Estrutura Condicional Composta Aninhada ................................................................. 53 
6.3 - Exercícios Resolvidos .................................................................................................. 56 
6.4 - Síntese ......................................................................................................................... 59 
7 - Estruturas de repetição (laço ou loop) ................................................................................60 
7.1 - Comando PARA ........................................................................................................... 62 
7.2 - Variação da quantidade de repetições do comando PARA ......................................... 66 
7.3 - Utilização dos valores da variável auxiliar do comando PARA .................................... 67 
7.4 - Uso de CONTADORES dentro das estruturas de repetição ........................................ 70 
7.5 - Uso de SOMATÓRIOS dentro das estruturas de repetição ......................................... 73 
7.6 - Séries Matemáticas ...................................................................................................... 76 
7.7 - Exercícios Resolvidos .................................................................................................. 80 
7.8 - Síntese ......................................................................................................................... 83 
8 - Estruturas de repetição (quantidade indefinida de repetições) ........................................... 84 
8.1 - Comando ENQUANTO ................................................................................................ 84 
8.2 - Comando REPITA ........................................................................................................ 88 
8.3 - Comparação entre o PARA, ENQUANTO e REPITA ................................................... 92 
8.4 - Uso de estrutura de repetição para fazer consistência na entrada de dados .............. 93 
8.5 - Uso do comando INTERROMPA para finalizar abruptamente um loop ....................... 95 
8.6 - Exercícios Resolvidos .................................................................................................. 98 
8.7 - Síntese ....................................................................................................................... 101 
ANEXO 1 ............................................................................................................................... 102 
 
 
 
 
 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 4 
1 - Introdução 
 
1.1 - Conceitos de Algoritmo 
 
Conceito genérico: 
 
Algoritmo é a descrição de uma sequência de passos que deve ser seguida para a realização 
de uma tarefa. 
 
 
Conceito voltado para os computadores: 
 
Algoritmo é uma sequência finita de instruções ou operações cuja execução, em tempo finito, 
resolve um problema computacional. 
 
É a forma pela qual descrevemos soluções para problemas que serão implementadas 
posteriormente em uma linguagem de programação e executadas pelo computador. 
 
Pode ser escrito através de pseudo linguagens, como o Portugol, ou símbolos como em 
fluxogramas. 
 
 
1.2 - Princípios básicos de um algoritmo 
 
O algoritmo segue os mesmos princípios básicos de operações em um computador: 
 
Entrada de Dados: é processo pelo qual os dados são inseridos no computador. 
 
Processamento dos Dados: é o conjunto de operações / cálculos que são executados com os 
dados inseridos na Entrada de Dados. 
 
Saída de Dados: é o resultado do processamento dos dados. 
 
 
 
 
 
Entrada 
de dados 
Saída de 
dados 
Processamento 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 5 
Exemplo: 
 
 
 
 
1.3 - Exemplo de Algoritmo “genérico” 
 
 
 
Preparar um sanduíche: 
 
 
Passo 1 – Pegar o pão 
Passo 2 – Pegar a alface e o tomate 
Passo 3 – Pegar a maionese 
Passo 4 – Pegar o hambúrguer 
 
Entrada de dados 
Passo 5 – Cortar o pão ao meio 
Passo 6 – Passar a maionese no pão 
Passo 7 – Cortar o tomate 
Passo 8 – Colocar a alface e o tomate no pão 
Passo 9 – Fritar o hamburguer 
Passo 10 – Colocar o hambúrguer no pão 
 
Processamento 
Etapa 11 – Entregar o sanduíche pronto para o cliente Saída de dados 
 
 
1.4 - No computador, como os algoritmos são escritos? 
 
Os algoritmos são escritos utilizando uma linguagem de programação como o Pascal, 
linguagem C, Java, e outras, e são chamados de programas. 
 
 
1.5 - Algoritmo x Programa 
 
Um programa é a conversão, ou tradução, de um algoritmo para uma determinada linguagem 
de programação, seguindo suas regras de sintaxe de forma a permitir que o computador 
possa interpretar e executar a sequência de comandos pretendidos. 
 
 
1.6 - Linguagem de Programação 
 
Uma linguagem de programação é um conjunto de símbolos (comandos, identificadores, 
caracteres, etc.) e regras de sintaxe que permitem a construção de sentenças que descrevem 
de forma precisa ações compreensíveis e executáveis para o computador. 
 
Exemplos de linguagens de programação: Basic, Pascal, Algol, Fortran, Cobol, C++, .Net, 
Java, etc. 
 
5 , 2 , 7 6 7 + 5 ÷ 2 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 6 
 
1.7 - Programa Fonte 
 
Programa fonte é composto por uma sequência de comandos escritos em uma linguagem de 
programação. As linguagens de programação permitem que os programas sejam escritos e 
interpretados pelo homem, mas não podem ser interpretados pelo computador. 
 
Exemplo (programa fonte escrito em Pascal): 
 
program CalculaFatorial; 
{ Função: calcular o fatorial de um número informado pelo usuário } 
var Numero, Fatorial, Contador : integer; 
begin 
 write('Informe um número: '); 
 readln(Numero); 
 Fatorial := 1; 
 for Contador := 2 to Numero do 
 begin 
 Fatorial := Fatorial * Contador; 
 end; 
 write('Fatorial = ',Fatorial); 
end. 
 
Exemplo (programa fonte escrito em Java): 
 
public class CalculaFatorial { 
public static void main(String[] args) throws IOException { 
System.out.print("Informe um número: "); 
Scanner scanner = new Scanner(System.in); 
long numero = scanner.nextLong(); 
long fatorial = 1L; 
for(long contador = 2; contador <= numero; contador++){ 
fatorial = fatorial * contador; 
} 
System.out.println("Fatorial = " + fatorial); 
} 
} 
 
 
1.8 - Programa Objeto 
 
Programa objeto é aquele composto por uma sequência de comandos escritos em linguagem 
de máquina. A linguagem de máquina é composta de símbolos binários que é interpretada 
pelo computador, mas não pode ser interpretada pelo homem. 
 
 
1.9 - Compiladores 
 
Compiladores são programas utilizados para se criar outros programas baseado em uma 
linguagem de programação. 
 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 7 
Ele permite ao programador a digitação e edição do programa fonte, e o converte para o 
programa objeto a ser interpretado pelo computador. Ou seja, é um editor e tradutor de 
programa fonte em programa objeto. 
 
Uma mesma linguagem de programação pode ser utilizada no programa fonte de diversos 
compiladores, mas um mesmo compilador só aceita uma única linguagem de programação no 
seu programa fonte. 
 
Etapas na criação de um programa: 
 
Edição: digitação e alteração do programa; 
Compilação: verificação de erros de sintaxe do programa (depuração); 
Execução (teste): executar (rodar) o programa, entrando com os dados e obtendo os 
resultados. 
 
Erros que podem aparecer durante a criação: 
 
Sintaxe: identificado pelo compilador na etapa de compilação; 
Lógica: identificado pelo usuário na etapa de execução. 
 
Exemplos de compiladores x linguagem de programação que ele utiliza: 
 
VisuAlg/ G-Portugol = Portugol 
PascalZIM / Delphi = Pascal 
JBuilder / Eclipse / JDK = Java 
 
 
1.10 - Portugol 
 
Portugol é uma pseudo linguagem de programação criada a partir da antiga linguagem de 
programação Algol traduzida para a língua portuguesa. Seu objetivo é facilitar a escrita de 
algoritmos por iniciantes em programação cuja língua nativa seja a língua portuguesa, já que 
as linguagens de programação utilizam apenas palavras-chave escritas na língua inglesa. 
 
O Portugol, além de utilizar apenas palavras-chave da língua portuguesa, também possui um 
conjunto de regras bem mais simples do que as linguagens de programação, isto facilita muito 
a escrita de algoritmos por programadores aprendizes. 
 
Existe um compilador para o Portugol? 
 
Oficialmente não, masse procurarmos na internet acharemos algumas opções de 
compiladores freeware (gratuitos) extra oficiais como o VisuAlg, o G-Portugol, e outros. 
 
Neste material utilizaremos o VisuAlg para compilarmos e executarmos nossos algoritmos 
escritos em Portugol. 
 
 
1.11 - A tabela ASCII 
 
Para escrever um programa fonte devemos utilizar um editor de programa que utilizará 
somente os caracteres da tabela ASCII, ou seja, não se utiliza em programas fonte 
formatações do tipo negrito, itálico, tamanho de fonte, e outra. 
 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 8 
ASCII (American Standard Code for Information Interchange), em português: "Código Padrão 
Americano para o Intercâmbio de Informação". É uma codificação de caracteres de sete bits 
(27 = 128 códigos) ou 8 bits - ASCII estendida (28 = 256 códigos) baseada no alfabeto inglês. 
Cada sequência de códigos na tabela ASCII corresponde a um caractere, comumente 
representados pelos 8 bits (equivalente a um byte). Os códigos ASCII representam texto em 
computadores. Desenvolvida a partir de 1960, grande parte das codificações de caracteres 
modernas a herdaram como base. 
 
O quadro a seguir mostra uma parte da tabela ASCII com os caracteres mais utilizados: 
 
http://pt.wikipedia.org/wiki/Codifica%C3%A7%C3%A3o_de_caracteres
http://pt.wikipedia.org/wiki/Bit
http://pt.wikipedia.org/wiki/Alfabeto_ingl%C3%AAs
http://pt.wikipedia.org/wiki/Byte
http://pt.wikipedia.org/wiki/1960
Programação de Computadores–Prof. Ricardo Luiz de Freitas 9 
 
 
 
1.12 - Síntese 
 
Neste capítulo você aprendeu conceitos básicos de algoritmos e de programação de 
computadores. 
 
No próximo capítulo vamos conhecer o VisuAlg e aprender a trabalhar com ele. 
 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 10 
2 - O VisuAlg 
 
2.1 - O que é o VisuAlg? 
 
O VisuAlg é um aplicativo freeware que permite escrever, compilar, executar, depurar erros, 
executar passo a passo, entre outras funcionalidades, em algoritmos escritos em Portugol. 
Sem o uso de uma ferramenta como o VisuAlg, você ficaria impossibilitado de executar seus 
algoritmos, podendo apenas escrevê-los em papel e imaginando os resultados que seriam 
alcançados quando o mesmo for reescrito utilizando uma linguagem de programação. 
 
 
2.2 - Instalação e Requerimentos de Hardware 
 
O VisuAlg é um programa simples, que não depende de DLLs, OCXs ou outros componentes. 
Sua instalação não copia arquivos para nenhuma outra pasta a não ser aquela em que for 
instalado, e exige cerca de 1 MB de espaço em disco. Pode ser executado sob Windows 95 
ou posterior, e tem melhor aparência com resolução de vídeo de 800x600 ou maior. 
 
 
2.3 - Instalação do VisuAlg 
Primeiramente devemos baixar o programa utilizando o link a seguir, ou em outro disponível 
na Internet. Escolha sempre a versão mais nova. 
http://www.apoioinformatica.inf.br/produtos/VisuAlg 
Após baixar o arquivo execute-o e siga os passos demonstrados a seguir: 
 
 
Figura 1: Tela de apresentação - clique em “Avançar” 
 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 11 
 
 
 
Figura 2: Caminho da instalação - clique em “Avançar” 
 
 
 
 
 
Figura 3: Instalação de Componentes - clique em “Avançar” 
 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 12 
 
 
 
Figura 4: Nome do grupo: pode editar ou deixar padrão - clique em “Avançar” 
 
 
 
 
 
 
Figura 5: Tarefas Adicionais - clique em “Avançar” 
 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 13 
 
 
 
Figura 6: Confirmação das configurações - clique em “Instalar” 
 
 
 
 
 
Figura 7: Conclusão da Instalação - clique em “Concluir” 
 
 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 14 
2.4 - Tela do VisuAlg: 
 
 
 
Menu→ 
→ 
Barras de 
tarefas 
 
 
→ 
Janela de 
digitação 
e edição 
do 
algoritmo 
 
 
 
 
→ 
Janela de 
visualiza-
ção das 
variáveis 
e seus 
valores 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
← 
Janela de 
visualiza-
ção da 
telade 
execução 
do 
algoritmo 
 
 
 
Ao criar um novo programa o VisuAlg já mostra no editor texto um "esqueleto" de algoritmo, 
cuja intenção é, além de poupar trabalho ao usuário, mostrar a estrutura básica de um 
algoritmo com suas 4 palavras chave obrigatórias (algoritmo...var...inicio...fimalgoritmo), bem 
como os seus comentários iniciais antecedidos pelos caracteres //. 
 
Cabeçalho do algoritmo (deve ser alterado antes de se iniciar a criação do algoritmo): 
 
 “semnome” → o texto deve ser substituído pelo nome interno do algoritmo (uma única 
palavra, e deve ser igual ao nome do arquivo, ao se salvar no disco o 
algoritmo; 
 Função → breve descrição do que faz o algoritmo em uma frase curta, de uma 
linha que não pode ultrapassar a demarcação da tela; 
 Autor → digitar seu nome (obrigatório); 
 Data → colocada automaticamente pelo VisuAlg no momento da criação do 
algoritmo. 
 
 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 15 
2.5 - Barra de tarefas para edição do algoritmo: 
 
Contém os comandos mais utilizados. É possível acessá-los também pelo menu ou pelos 
atalhos do teclado. 
 
 
Novo (Ctrl+N) - Cria um novo "esqueleto" de algoritmo, substituindo o texto existente no editor. 
Se este tiver sido modificado, o VisuAlg pedirá sua confirmação para salvá-lo antes que seja 
sobreposto. 
 
Abrir (Ctrl+A) - Abre um algoritmo anteriormente gravado, substituindo o texto existente no 
editor. Se este tiver sido modificado, o VisuAlg pedirá sua confirmação para salvá-lo antes que 
seja sobreposto. 
 
Salvar (Ctrl+S) - Salva imediatamente o texto do editor. Caso seja a primeira vez que um novo 
texto é gravado, o VisuAlg pedirá o seu nome e localização. 
 
Imprimir (Ctrl+P) - Imprime imediatamente o texto existente no editor. Para configurar a 
impressão, use o comando Imprimir... do menu Arquivo. 
 
Recortar (Ctrl+X) - Move um texto selecionado para a memória. 
 
 
Copiar (Ctrl+C) - Copia um texto selecionado para a memória. 
 
 
Colar (Ctrl+V) - Retira conteúdo da memória e coloca no local do cursor. 
 
 
Gravar Bloco - Abre uma janela para salvar o bloco selecionado. Objetivo é criar uma espécie de 
biblioteca de funções. 
 
 
Inserir um bloco - Insere um bloco arquivado no local do cursor. 
 
 
Desfazer e refazer - Desfaz e refaz ação criada no editor de texto. 
 
 
Localizar - Abre uma janela para você digitar a palavra que deseja localizar no Editor de textos. 
 
Substituir - Abre uma janela para você poder digitar a palavra que deseja localizar e substituir no 
Editor de textos. 
 
 
Corrigir Identação (Ctrl+G) - Corrige automaticamente a identação do "código-fonte", colocando 
os comandos dentro de uma estrutura de 3 colunas à direita da coluna inicial da estrutura 
conforme a configuração padrão. 
 
Numerar Linhas - Liga/desliga a exibição dos números das linhas na área à esquerda do editor. 
A linha e coluna do editor em que o cursor está em um determinado momento também são 
mostradas na primeira parte da barra de status, situada na parte inferior da tela. Os números de 
linhas, caso ligados, são desligados durante a execução do algoritmo por motivos técnicos, mas 
são ligados de volta ao fim do "programa". 
 
Mostra Variáveis Modificadas - Liga/desliga a exibição da variável que está sendo modificada. 
Como o número de variáveis pode ser grande, muitas podem estar fora da janela de visualização; 
quando esta característica está ligada, o programa rola a grade de variáveis de modo que aquela 
que está sendo modificada no momento fique visível. Útil quando se está executando o algoritmo 
passo a passo. Por questões de performance, o valor padrão desta característica é desligada 
quando o algoritmo está sendo executado automaticamente, mas se você clicar este botão pode 
executar o algoritmo automaticamente com a exibição ligada. O valor volta automaticamente para 
desligada ao fim da execução. 
 
Restaura a tela inicial do VisuAlg - Retorna a tela originaldo programa. 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 16 
2.6 - Barra de tarefas para execução e controle de algoritmo: 
 
 
 
 
Executar (F9) - Inicia (ou continua) a execução automática do 
algoritmo. 
 
Executar com Timer (Shift+F9) - Executa o algoritmo linha por linha 
automaticamente determinado por um tempo escolhido pelo o 
usuário. 
 
Passo (F8) - Inicia (ou continua) a execução do algoritmo linha por 
linha, dando ao usuário oportunidade de acompanhar o fluxo do 
programa, examinar variáveis, etc. 
 
Parar (Ctrl+F2) - Termina imediatamente a execução do algoritmo. 
Este botão fica desabilitado quando o algoritmo não está sendo 
executado. 
 
Liga / Desliga Breakpoints (F5) - Cria pontos de parada. Selecione 
a linha que deseja criar um ponto de parada na hora de execução do 
algoritmo e pressione o BreakPoints surgirá uma linha marrom e um 
marcador do lado esquerdo para indicar o ponto de parada. Para 
desmarcar o ponto de parada basta selecionar a linha que possui o 
breakpoint e clicar no mesmo. O breakpoints não funciona no modo 
passo a passo e para continuar o algoritmo depois de uma parada 
pressione novamente o F9 ou o botão Executar. 
 
Desmarca todos os BreakPoints (Ctrl+F5) 
 
Executa algoritmo em Modo DOS - Quando ativado durante a 
execução do algoritmo ele executa o algoritmo em uma janela em 
modo DOS. 
 
Gerador valores - Substitui digitação do usuário por um sistema de 
geração aleatória de valores numéricos e caractere (este comando 
não afeta a leitura de variáveis do tipo lógico - com certeza uma 
coisa pouco usual). Gera números e caracteres aleatoriamente, 
muito útil para não perder tempo pensando o que digitar, você 
escolhe o início e o fim dos valores e se for valores com casas 
decimais é só escolher quantas casas decimal você quer. 
 
Perfil (F7) - Mostra, após a execução de um algoritmo, quantas 
vezes cada linha foi executada. Útil para a análise de eficiência de 
um algoritmo, como por exemplo, nos métodos de classificação. 
 
Mostra a pilha de Ativação dos procedimentos e Funções 
(Ctrl+F3) - Mostra a pilha de ativação do programa com o nome dos 
procedimentos e funções chamados, nome, tipo e valor dos 
parâmetros. 
 
Ajuda on-line (F1) - Help do VisuAlg. 
 
 
 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 17 
2.7 - Visualizador de Variáveis 
 
Contém uma grade onde são exibidos: 
 
 Escopo: indica se é uma variável: 
o GLOBAL (válida em todo o algoritmo) ou 
o LOCAL de um procedimento ou função; 
 Nome: exibe o nome da variável, com índice ou índices, caso seja um elemento de um 
vetor; 
 Tipo: exibe tipo da variável: "R" para Real, “I” para Inteiro, "C" para literal e "L" para 
lógico; 
 Valor: exibe o valor atual armazenado na variável. 
 
 
 
 
2.8 - Janela de Saída 
 
Exibe as Entradas e Saídas de dados do algoritmo. Se o algoritmo estiver sendo executado 
em modo DOS, as Entradas e Saídas de dados serão exibidas na janela DOS e nesta janela 
também. 
 
 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 18 
 
 
2.9 - Compilando e Executando um algoritmo no VisuAlg 
 
Ao abrir o VisuAlg, a partir do “esqueleto”, digite o algoritmo na janela principal (veja exemplo 
na Figura 8). Não se preocupe com a formatação do texto, o próprio editor se incumbirá disto. 
Após a digitação (ou mesmo durante) pressione as teclas Ctrl e G juntas para que o editor 
faça a identação automática do algoritmo de acordo com a precedência dos comandos (a 
Figura 9 mostra o algoritmo já identado). 
 
 
Figura 8: Tela do VisuAlg após a digitação do algoritmo 
 
 
 
Figura 9: Tela do VisuAlg após a identação (Ctrl+G) do algoritmo 
 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 19 
Após a digitação e identação do algoritmo, passa-se para a fase de compilação e execução 
do mesmo. Você deve pressionar a tecla de função F9 ou clicar no ícone . O VisuAlg 
começa a compilar e executar o algoritmo, linha a linha. A medida que ele vai compilando as 
linhas, ele as executa. Quando o VisuAlg “passa” pela Seção de Declarações das variáveis, 
as mesmas vão sendo alocadas na memória do computador e passam a figurar na janela de 
visualização de variáveis (janela inferior esquerda), com valores zerados (variáveis 
numéricas) ou em branco (variáveis alfanuméricas). Quando ele “passa” para a Seção de 
Comandos, abra-se uma janela de fundo preto na tela, e as linhas de comando vão sendo 
compiladas (a sintaxe do comando é verificada) e elas vão sendo executadas. Se o VisuAlg 
não encontrar nenhum erro de compilação o algoritmo é executado até o fim de seus 
comandos e encerrado, conforme Figura 10. 
 
 
 
Figura 9: Tela do VisuAlg após a compilação e execução do algoritmo 
 
 
Para fechar a tela preta pressiona-se a tecla ESC do teclado, com o VisuAlg retornando para a 
tela de edição. 
 
Dicas Importantes: 
 
1) Se durante ou depois da execução do seu algoritmo o VisuAlg travar, ou seja, não aceitar a 
digitação de nenhuma tecla, clique na opção “Parar” no menu “Algoritmo”, que ele 
destravará. 
 
2) Se aparecerem linhas vermelhas durante a edição de seu algoritmo no VisuAlg, fazendo-o 
ser interrompido durante a execução, clique na opção “Desmarcar todos os 
breakpoints” no menu “Algoritmo”, que as linhas desaparecerão e seu algoritmo rodará 
livremente. 
 
3) Se durante a execução de seu algoritmo no VisuAlg aparecer a mensagem de erro “Access 
Violation”, salve o seu programa, feche o VisuAlg, abra-o novamente, abra o seu programa e 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 20 
continue a trabalhar nele normalmente descobrindo o erro de sintaxe que gerou a mensagem 
de erro anterior. 
 
E se foram encontrados erros de compilação? 
 
Se, quando da compilação de uma linha do algoritmo, o VisuAlg encontrar algum erro de 
sintaxe, seja na Seção de Declarações ou na Seção de Comandos, após a abertura da janela 
de fundo preto, uma outra janela é aberta mostrando a linha onde foi encontrado o erro e 
sugerindo qual erro pode ser (nem sempre as sugestões do VisuAlg devem ser seguidas). 
Você pode consertar o erro nesta própria janela e clicar em “Continuar”, ou clicar em 
“Terminar” e voltar para a tela de edição, para aí sim consertar o erro na própria tela de 
edição do algoritmo. 
 
 
 
Figura 10: Tela do VisuAlg após a compilação e execução do algoritmo 
 
 
Depois de acertados todos os erros de compilação, ou fazemos novas alterações no 
programa original e o compilamos/executamos de novo, ou partimos para a criação de um 
outro algoritmo clicando-se na tecla , ou encerramos o VisuAlg, fechando a sua janela. 
Porém, antes de uma destas duas últimas ações, que causará o abandono do algoritmo atual, 
o VisuAlg abre uma outra janela e pergunta se você quer o salvar o algoritmo no computador 
(Figura 11). 
 
 
Figura 11: Janela do VisuAlg perguntando se quer salvar o algoritmo 
 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 21 
Se for quiser salvar o algoritmo, clique em “Sim” e uma outra janela será aberta (Figura 12). 
Selecione o local e a pasta onde o arquivo será gravado, digite o nome do arquivo 
(substituindo Semnome.alg), e clique em “Salvar”. 
 
 
Figura 12: Janela do VisuAlg solicitando informações para gravação do algoritmo 
 
 
Pronto! Seu algoritmo está criado, testado e salvo no computador! 
 
 
2.10 - Síntese 
 
Neste capítulo você conheceu o VisuAlg, como baixá-lo da internet e instalá-lo em seu 
computador. Além disso aprendeu a utilizá-lo: criar, compilar, editar, e executar programas no 
mesmo. 
 
Nos próximos capítulos vamos aprender as técnicas básicas de criação de algoritmos no 
VisuAlg utilizando a linguagem Portugol. 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 22 
3 - O Portugol do VisuAlg: conceitos iniciais 
 
 
3.1 - Estrutura básica de um algoritmo escrito no Portugol do VisuAlg 
 
Algoritmo "semnome" 
// Função : 
// Autor : 
// Data : 
// Seção de Declarações 
varinicio 
// Seção de Comandos 
 
fimalgoritmo 
 
 
Obs.: O Portugol do VisuAlg não faz distinção entre letras minúsculas e letras maiúsculas, 
sendo assim, comandos, tipos, nomes de variáveis e outros, escritos em letras minúsculas 
são exatamente iguais aos escritos em letras maiúsculas. 
 
Entretanto, nesta disciplina vamos adotar como regra as boas práticas de programação 
genéricas (descritas ao longo desta apostila) que indicam onde devem ser utilizadas letras 
maiúsculas ou minúsculas. A adoção destas boas práticas desde o princípio do aprendizado 
em programação de computadores ajudará o aluno a criar códigos bem escritos e de 
qualidade, facilitará também o uso delas futuramente quando os alunos estiverem criando 
programas utilizando linguagens de programação. 
 
 
3.2 - Linha de Comando 
 
O Portugol utilizado no VisuAlg permite apenas um comando por linha, desse modo, não há 
necessidade de utilização de símbolos indicando o final de uma linha de comando, como o 
ponto e vírgula utilizado em Pascal e Java. 
 
Importante: Para facilitar a digitação e aproximar das linguagens de programação, todas as 
palavras-chave, nomes de variáveis, vetores e outros, não utilizam acentuação, nem cedilha, 
etc. Por exemplo o tipo de dados lógico será escrito logico, o comando se...então...senão 
será escrito se...entao...senao, e assim por diante. 
 
 
3.3 - Comentários no programa 
 
Comentários são textos inseridos no programa fonte com o objetivo de explicar ou 
documentar uma lógica, uma variável ou outro objeto qualquer. Os comentários são ignorados 
pelo compilador, portanto não são levados para o programa objeto. 
 
Os comentários podem ocupar uma ou mais linhas no programa, e para inseri-los se utiliza os 
símbolos//no princípio de cada linha ou logo a frente de uma linha de comando. 
 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 23 
No editor de programas do VisuAlg, sempre que um comentário for inserido, o mesmo será 
exibido na cor verde para destacar das demais linhas de comandos. 
 
Exemplo: 
 
Algoritmo "CalcularIdade" 
// Função : Calcular a idade de uma pessoa 
// Autor : Air Rabelo 
// Data : 16/05/2014 
// Seção de Declarações 
var 
 diaNasc, // dia da data de nascimento 
 mesNasc: inteiro // mês da data de nascimento 
inicio 
// Seção de Comandos 
 escreva("Digite o dia de nascimento: ") 
 leia(diaNasc) 
 escreva("Digite o mês de nascimento: ") 
 leia(mesNasc) 
 ... 
fimalgoritmo 
 
 
3.4 - Identação 
 
Identação é o recuo de um texto em relação a sua margem. Em programação de 
computadores, ou na construção de algoritmos em Portugol, utilizamos a identação para 
ressaltar a estrutura do algoritmo, organizar o código e indicar grupos e subgrupos de 
comandos, o que facilita a interpretação do código escrito pelo programador. A identação irá 
indicar com clareza que um conjunto de comandos pertence a uma certa estrutura de código. 
Isto engrandece a qualidade do algoritmo e apesar da identação não ser obrigatória, um 
código escrito sem identação ficará confuso e de difícil interpretação. 
 
Neste material utilizaremos as técnicas de identação indicadas pelas boas práticas de 
programação especificamente para a construção de algoritmos em Portugol. 
 
Um código de qualidade escrito por um programador experiente deixará de ser bom se não 
tiver seguido as boas práticas de programação e/ou não tiver utilizado corretamente as regras 
de identação. 
 
Nas sintaxes das estruturas condicionais e de repetição serão indicadas as identações 
utilizadas para ilustrar e exemplificar este conceito. 
 
 
3.5 - Dados 
 
O dado é a própria essência de um algoritmo ou programa de computador. 
 
Existem dados de diversas formas: caracteres, imagem, som, temperatura, luz, movimento, 
etc. 
 
Ele pode ser informado pelo usuário, gerado pelo programa, processado pelo computador, e 
impresso para o usuário como uma informação. 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 24 
 
 
3.6 - Tipos de Dados 
 
Tipos de dados são maneiras pelas quais os dados são tratados: 
 
 Constantes: são aqueles dados cujos valores não se alteram durante a execução do 
algoritmo; 
 Variáveis: são aqueles dados cujos valores podem ser alterados durante a execução 
do algoritmo. 
 
Eles se classificam em: 
 
 Simples: 
 
o Numéricos: utilizam somente dígitos e possuem valor de grandeza numérica: 
 INTEIRO: 
 São os valores numéricos inteiros (sem casas decimais); 
 Podem ser valores positivos ou negativos; 
 Variando entre -999999999 e 999999999; 
 Ex.: 0, -2, 47, 58, 123220, -34235 
 REAL: 
 São os valores numéricos que possuem casas decimais; 
 Podem ser valores positivos ou negativos; 
 Ex.: 0.12, -45.17, 3.14159, 0.000001 
 
o Não Numéricos: 
 CARACTERE: 
 Utilizam qualquer caractere da tabela ASCII e são interpretados como um 
texto; 
 Geralmente são delimitadas por aspas (“ ”); 
 Ex.: “Rua”, “Computação”, “20/10/1998” 
 LOGICO: 
 Assumem apenas dois valores: verdadeiro ou falso; 
 
 Estruturados: 
 
o Arquivos; 
o Vetores; 
o Matrizes. 
 
Obs.: No sistema de numeração da nossa língua portuguesa utilizamos no conjunto de 
números reais a vírgula (,) como o símbolo que separa os valores inteiros dos decimais. 
Entretanto, assim como nas linguagens de programação, o símbolo utilizado para separar os 
valores inteiros dos decimais no VisuAlg é o ponto (.). 
 
 
3.7- Variáveis 
 
Passaremos a chamar somente de variável os tipos de dados variáveis. Mas o que é uma 
variável? 
 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 25 
Em termos lógicos é o registro formal, dentro do algoritmo, dos dados a serem utilizados pelo 
próprio algoritmo. 
 
Em termos físicos é uma posição na memória do computador reservada pelo algoritmo, 
durante a sua execução, para armazenar dados a serem utilizados pelo próprio algoritmo. 
 
Estes dados podem ter sido gerados pelo próprio algoritmo (comandos de repetição, comando 
de atribuição, etc.) ou inseridos pelo usuário quando da execução de um comando de 
entrada/leitura de dados. 
 
Quando precisarmos armazenar um dado na memória, atribuímos este dado ao nome de uma 
variável. Exemplo: 
 
→ comando para guardar a camisa na 
Gaveta1: 
gaveta1 <- "camisa" 
 
→ comando para guardar a meia na 
Gaveta2: 
gaveta2 <- "meia" 
 
→ comando para guardar a bermuda na 
Gaveta3: 
gaveta3<- "bermuda" 
 
 
 
 
Toda vez que precisarmos buscar um dado armazenado na memória utilizamos o nome da 
variável para identificar o dado. Exemplo: 
 
→ comando para mostrar o que tem na Gaveta1: 
 escreva(gaveta1) 
 
→ comando para mostrar o que tem na Gaveta2: 
 escreva(gaveta2) 
 
→ comando para mostrar o que tem na Gaveta3: 
 escreva(gaveta3) 
 
Importante: 
 
1) Toda variável de memória deve ter um nome e deve estar associada a um tipo de dado 
(inteiro, real, caractere ou lógico). 
 
2) Toda variável armazena apenas um valor por vez. 
 
3) Toda vez que um valor é atribuído a uma variável, o seu valor anterior será sobreposto. 
Portanto as variáveis armazenam apenas o último valor atribuído a elas. 
 
Exemplo: 
 
idade <- 30 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 26 
idade <- 50 
escreva(idade) 
 
Na primeira linha do exemplo anterior a variável idade recebe o valor 30. Neste momento o 
único valor armazenado na variável é 30. 
 
Na segunda linha a mesma variável idade recebe o valor 50. Desta forma, o antigo valor 30 
foi sobreposto pelo novo valor 50. Após a execução desta segunda linha, o único valor que a 
variável idade estará armazenando será o último que ela recebeu, ou seja, 50. 
 
Na terceira linha, o comando escreva irá exibir na tela o conteúdo da variável idade. O 
valor que será exibido na tela será 50, que é o último valor recebido pela variável idade, e 
por isto é o único valor que estará armazenado nela. 
 
 
3.8 - Nomes (ou identificadores) de Variáveis 
 
Os nomes de variáveis devem seguir as seguintesregras: 
 
→ o primeiro caractere do nome de uma variável deve ser sempre uma letra ou o caractere 
sublinhado ( _ ); 
 
→ o segundo e demais caracteres do nome de uma variável podem ser somente letras, 
números ou sublinhado ( _ ), ou seja, não podem conter ESPAÇOS ou caracteres especiais 
(@, ?, !, -, etc.); 
 
→ não podem ser utilizados c cedilha (ç) e nem letras acentuadas; 
 
→ podem ter no máximo 127 caracteres de tamanho; 
 
→ não podem ser utilizadas as palavras reservas do VisuAlg (ver anexo 1). 
 
 
Obs.: O VisuAlg não diferencia letras maiúsculas de minúsculas, mas a maioria das 
linguagens de programação faz esta diferenciação. Neste material utilizaremos nomes de 
variáveis escritos somente com letras minúsculas, e quando forem nomes compostos, a 
primeira letra a partir da segunda palavra será maiúscula. Isto, apesar de não ser uma 
exigência do VisuAlg, é uma boa prática de programação que é adotada pela maioria das 
linguagens de programação modernas. 
 
Exemplos de nomes válidos para variáveis: 
 
nomeAluno cidadeNatal 
dataNascimento somaSalarios 
endereco_1 percentualAprovados 
endereco_2 mediaNotas 
 
Exemplos de nomes inválidos para variáveis: 
 
médiaIdades 5Jose 
data-nascimento façanhas 
A$1 Percentual de Aprovados 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 27 
 
Os nomes das variáveis devem passar ao programador (ou quem está lendo o 
programa/algoritmo) a origem do dado que a variável vai armazenar, ou seja, não devemos 
criar nomes que não tenham nada a ver com o conteúdo da variável ou constante: 
 
Exemplos de nomes apropriados para variáveis: 
 
idade salario 
nomefruta soma_Custos 
contador enderecoCorrespondencia 
 
Exemplos de nomes inapropriados para variáveis: 
 
I i23er21 
xyz xibobo 
abcd ricardo 
 
Exemplo de algoritmo utilizando nomes de variáveis inapropriadas e sem qualquer tipo de 
documentação: 
 
Algoritmo "X" 
var 
 a, b, c : inteiro 
inicio 
 leia(a) 
 b <- 1 
 para c de 2 ate a faca 
 b <- b * c 
 fimpara 
 escreval(b) 
fimalgoritmo 
 
O mesmo algoritmo utilizando nomes de variáveis apropriadas, comentários e mensagens 
elucidativas: 
 
Algoritmo "CalculaFatorial" 
// Função : Calcular o fatorial de um número 
// Autor : Ricardo Freitas 
// Data : 17/11/2014 
// Seção de Declarações 
var 
 Numero, Fatorial, Contador : inteiro 
inicio 
// Seção de Comandos 
 escreva("Informe um número: ") 
 leia(Numero) 
 Fatorial <- 1 
 para Contador de 2 ate Numero faca 
 Fatorial <- Fatorial * Contador 
 fimpara 
 escreval("Fatorial = ",Fatorial) 
fimalgoritmo 
 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 28 
 
3.9 - Declaração de Variáveis 
 
Como vimos no início deste capítulo, a estrutura de um algoritmo em VisuAlg segue o 
seguinte formato: 
 
 
algoritmo "semnome" 
var 
 
 
inicio 
 
 
fimalgoritmo 
 
 
 
Toda variável precisa ser declarada antes de ser utilizada. A declaração de uma variável 
consiste em criar o seu nome e atribuir a ela um tipo de dado, que pode ser inteiro, real, 
caractere ou lógico. 
 
No Portugol do VisuAlg as variáveis devem sempre ser declaradas no início do algoritmo, logo 
após a palavra-chave var. 
 
Exemplo 1: 
 
Variáveis declaradas uma em cada linha seguidas do seu tipo de dado: 
 
Algoritmo "PrimeiroAlgoritmo" 
// Seção de Declarações 
var 
 idade : inteiro 
 numero : inteiro 
 altura : real 
 peso : real 
 salario : real 
 nomePai : caractere 
 rua : caractere 
 bairro : caractere 
 dtNasc : caractere 
inicio 
// Seção de Comandos 
 ... 
fimalgoritmo 
 
Exemplo 2: 
 
Variáveis declaradas, se forem do mesmo tipo, uma em cada linha, separadas por vírgula, e 
na última linha o tipo delas: 
 
Algoritmo "PrimeiroAlgoritmo" 
// Seção de Declarações 
Nome interno do algoritmo e deve estar entre aspas. 
Neste espaço deve vir a relação de variáveis que o 
algoritmo irá utilizar, associadas ao seu respectivo 
tipo de dados (inteiro, real, caractere ou lógico). 
Neste espaço deve vir a relação dos comandos que 
o algoritmo irá executar. 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 29 
var 
 idade, 
 numero : inteiro 
 altura, 
 peso, 
 salario : real 
 nomePai, 
 rua, 
 bairro, 
 dtNasc : caractere 
inicio 
// Seção de Comandos 
 ... 
fimalgoritmo 
 
Exemplo 3: 
 
Variáveis declaradas, se forem do mesmo tipo, na mesma linha, separadas por vírgula, 
seguida do tipo delas: 
 
Algoritmo "PrimeiroAlgoritmo" 
// Seção de Declarações 
var 
 idade, numero : inteiro 
 altura, peso, salario : real 
 nomePai, rua, bairro, dtNasc : caractere 
inicio 
// Seção de Comandos 
 ... 
fimalgoritmo 
 
 
3.10 - Linha de Comando no VisuAlg 
 
No VisuAlg cada linha de comando deve ocupar apenas uma linha no programa fonte. Desta 
forma, o que indica o final de uma linha de comando é a mudança de linha no editor de texto. 
 
Exemplos: 
 
Salário <- 2786.5 
leia(sexo) 
nomeAluno <- "Marcelo dos Santos" 
categoria <- "A" 
escreva("O nome do aluno é: ",nomeAluno) 
aprovado <- falso 
salario <- salario + tempoCasa – descontoValeTransp + 2786.5 
texto <- "O VisuAlg permite escrever algoritmos em Portugol" 
 
 
3.11 - Comando de Atribuição: atribuindo valores às Variáveis 
 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 30 
Para se atribuir (ou armazenar) um valor qualquer a uma variável utiliza-se o comando de 
atribuição do VisuAlg (<-), que é representado pelo sinal de menor seguido pelo sinal de 
subtração. 
 
Para atribuir um valor a uma variável do tipo caracter utiliza-se as aspas (" ") para delimitar 
o valor. 
 
Quando um valor é atribuído a uma variável o valor armazenado anteriormente na mesma é 
perdido, pois, como já foi dito, uma variável só armazena um valor ao mesmo tempo. 
 
Na linha de comando para atribuição de valores a uma variável, a variável sempre deverá ser 
escrita à esquerda do comando de atribuição (<-) e o valor a ser atribuído escrito à direita. 
 
O uso destes dois sinais como comando de atribuição (<-) se justifica por visualmente 
representarem uma seta em sentido para esquerda, o que indica que o valor escrito à direta 
do comando será inserido na variável escrita à esquerda do comando. 
 
Obs.: Para digitar o comando de atribuição não pode haver espaço entre o sinal menor e o 
sinal de subtração, ou seja, os dois sinais devem ser digitados em sequência sem espaço 
entre eles. Entretanto, por questões de clareza do código, é recomendado utilizar espaço 
antes e depois do comando de atribuição, como nos exemplos seguintes. 
 
Exemplos: 
 
Idade <- 25 // tipo inteiro 
nota1 <- 3 // tipo inteiro 
nota2 <- 4 // tipo inteiro 
salário <- 2786.5 // tipo real 
nomeAluno <- "Marcelo dos Santos" // tipo caracter 
sexo <- "F" // tipo caracter 
alunoFoiAprovado <- verdadeiro // tipo logico 
notaFinal <- nota1 + nota2 // tipo inteiro 
inss <- salario * 8 / 100 // tipo real 
 
 
Obs.: Na quarta linha dos exemplos anteriores, a variável notaFinal recebe nota1+nota2. 
Quando o comando de atribuição é utilizado em conjunto com uma expressão aritmética ou 
operação (neste caso o operador aritmético soma) o valor que será atribuído a variável será o 
resultado da operação. Desta forma, como nota1 recebeu o valor 3 e nota2 recebeu o valor 
4, notaFinal receberá o resultado da soma de 3 + 4, ou seja, o valor 7 será atribuído a 
variável notaFinal. 
 
 
3.12 - Operadores e Expressões Aritméticas 
 
3.12.1 - Operadores Aritméticos 
 
Os operadores aritméticos são utilizados para efetuar operações aritméticas com números 
inteiros e reais. São eles: 
 
Operador Operação Exemplos de uso 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 31 
+ Soma soma <- numero + 4 
- Subtração resultado <- 100 - soma 
* Multiplicação inss <- salario * 0.08 
/ Divisão media <- soma / 7 
^ Potência quadrado <- valor ^ 2 
\ 
Resultadode uma 
divisão inteira 
metade <- numero \ 2 
% 
Resto de uma divisão 
inteira 
sobra <- numero % 3 
 
 
Exemplos de resultados de expressões utilizando os operadores mostrados: 
 
 
 
 
 
 
 
 
 
 
 
 
 
3.12.2 - Expressões Aritméticas 
 
É a tradução de uma equação matemática (fórmula) para a linguagem algorítmica, utilizando 
os operadores aritméticos, variáveis e constantes numéricas para compor as expressões. 
 
Em uma operação matemática ou expressão aritmética, composta de vários operadores, a 
ordem de execução dos operadores é: 
 
1° → o que está entre parênteses 
2° → operações de potência (^) 
3° → operações de multiplicação (*), divisão comum (/) e divisão inteira (\ e %) 
4° → operações de soma (+) e subtração (-) 
 
Obs.: Para mudarmos a ordem de execução dos operadores utilizamos os parênteses, em 
quantos níveis precisarmos. 
 
Exemplo: 
 
9 + 4 = 13 
9 - 4 = 5 
9 * 4 = 36 
9 / 4 = 2.25 
9 ^ 4 = 6561 
9 \ 4 = 2 
9 % 4 = 1 
 
9 4 
8 2 → Resto da divisão inteira ( \ ) 
1 → Resto da divisão inteira ( % ) 
 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 32 
 
 
 
Exemplos de fórmulas matemáticas traduzidas para a linguagem algorítmica: 
 
Exemplos 1: 
 
 
 
→ y <-x^ 2 
 
→ y <-x^ (1 /2) ou y <-x^ 0.5 
 
→ y <-x^ (1 /3) 
 
→ y <-x^ (4 /5) 
 
 
Exemplos2: 
 
 
→ area <- 3.1416 *r^2 
 
→ fx <- 4 *x^2 + 7 *x– 2 
 
→ valor <- (n1 + n2 + n3) / 3 - 5 
 
Exemplo 3: 
Percentual = 10% de Valor 
→ percentual <- 10 % valor (INCORRETO!!!) 
→ percentual <- valor * 10 / 100 
→ percentual <- valor * 0.1 
 
 
Exemplos de decomposição numérica de variáveis inteiras utilizando os operadores \ 
(resultado da divisão inteira) e % (resto da divisão inteira): 
 
 
 
 
5 4
3
2
xy
xy
xy
xy




2RArea 
274)( 2  xxxf
5
3
321



nnn
Valor
Programação de Computadores–Prof. Ricardo Luiz de Freitas 33 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
A variável inteira N, que no exemplo anterior contém o valor 98765, poderá ser decomposta 
conforme os casos mostrados, e um ou mais dígitos dela (a esquerda, a direita ou no meio) 
poderão ser extraídos. Para isto deverão ser utilizados os operadores de divisão inteira (\ e %) 
conforme demonstrados, em conjunto com valores múltiplos de 10. Para extrair dígitos a 
esquerda utiliza-se o operador de resultado da divisão inteira (\) e para extrair dígitos a direita 
utiliza-se o operador de resto da divisão inteira (\). Para extrair dígitos do meio da variável, 
deve-se utilizar os dois operadores em uma operação composta. 
 
Obs.: Quanto se utiliza os operadores de divisão inteira numa expressão ou em um comando, 
todas as variáveis do comando têm que ser declaradas como inteiro, sob pena de resultar 
em erro de sintaxe naquela linha durante a compilação, ou cálculos incorretos quando da 
execução da linha. 
 
 
3.13 - Operadores e Expressões Lógicas (Booleanas) 
 
3.13.1 - Operadores Relacionais 
 
Os operadores relacionais são utilizados para efetuar a comparação entre dados (variáveis ou 
constantes) de mesmo tipo. São eles: 
 
Operador Operação Exemplos de uso 
= Igual a notaA = notaB 
<> Diferente de notaA <> notaB 
> Maior que notaA > notaB 
< Menor que notaA < notaB 
>= Maior ou igual a notaA >= notaB 
<= Menor ou igual a notaA <= notaB 
 
 
O resultado de uma operação relacional é sempre um valor lógico, ou seja, verdadeiro ou 
falso. 
 
N \ 10000 = 9 
N \ 1000 = 98 
N \ 100 = 987 
N \ 10 = 9876 
N % 10 = 5 
N % 100 = 65 
N % 1000 = 765 
N % 10000 = 8765 
10000 1000 100 10 
N \ 1000 % 10 = N % 10000 \ 1000 = 8 
N \ 100 % 10 = N % 1000 \ 100 = 7 
N \ 10 % 10 = N % 100 \ 10 = 6 
\ % 
N = 98765 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 34 
Exemplos: 
 
Considere a = 1, b = 3, c = 5 
 
a = c // falso 
a > b // falso 
b <= c // verdadeiro 
a <> b // verdadeiro 
 
 
3.13.2 - Operadores Lógicos 
 
Os operadores lógicos são utilizados para se conectar duas ou mais operações relacionais ou 
inverter o seu valor. São eles: 
 
Operador O que representa 
e união 
ou escolha 
nao negação ou inversão 
 
 
Para os exemplos a seguir considere notaA = 50, notaB = 70, notaC = 85 
 
 
Exemplo 1: 
 
 
 
Neste exemplo, o resultado final será verdadeiro porque os dois valores comparados com o 
operador e são verdadeiros, ou seja, V e V = V. 
 
 
Exemplo 2: 
 
 
 
Neste segundo exemplo, o resultado é verdadeiro porque com o operador ou basta um dos 
valores serem verdadeiros que o resultado é verdadeiro, ou seja, V ou F = V. 
 
 
Exemplo 3: 
 
 
 
Neste terceiro exemplo, o resultado é falso porque o operador nao inverte um valor lógico, ou 
seja, nao V = F. 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 35 
 
 
Obs.: No VisuAlg, em todas os testes condicionais que utilizam operadores lógicos é 
obrigatório o uso de parênteses. Os parênteses são obrigatórios somente nos valores que 
estão a esquerda e a direita dos operadores e/ ou, e no valor que está à direita do operador 
nao (como no exemplo 3). Qualquer outro uso de parênteses em operações compostas é 
opcional e a critério do usuário. As boas práticas de programação recomendam o uso de 
parênteses em operações muito complexas para enfatizar as prioridades para resolução da 
operação. 
 
 
3.13.3 - Tabela Verdade para operações lógicas: 
 
A seguir, são mostradas duas tabelas, chamadas tabela verdade, contendo o resultado do 
uso dos operadores lógicos sobre dois operandos. 
 
 
 
 
 
 
 
 
 
Apesar destas tabelas mostrarem apenas duas condições (V ou F), com um dos operadores 
e/ou entre elas, as conectando, o conceito se estende para expressões com duas ou mais 
condições, ou seja, quando utilizamos o operador lógico e, para se obter o resultado 
verdadeiro, todas as condições precisam ser verdadeiras. Em relação ao operador ou, para 
se obter o resultado verdadeiro, apenas uma das condições precisa ser verdadeira. 
 
 
3.13.4 - Expressões booleanas 
 
É a expressão formada pelos operadores relacionais, conectados ou não pelos operadores 
lógicos, variáveis e constantes numéricas. Elas são muito utilizadas nas estruturas 
condicionais e de repetição, que veremos nos capítulos seguintes. 
 
Em uma expressão booleana, composta de vários operadores lógicos, a ordem de execução 
dos operadores é: 
 
1° → escolha (e) 
2° → união (ou) 
 
 
3.14 - Síntese 
 
Neste capítulo você aprendeu os conceitos básicos de um algoritmo baseado na linguagem 
Portugol do VisuAlg, e o primeiro comando: atribuição de variáveis, aliado às expressões 
aritméticas. Também viu o que são expressões booleanas e seus operadores relacionais e 
lógicos. 
 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 36 
Nos próximos capítulos você aprenderá os comandos básicos de um algoritmo, começando 
no próximo capítulo com o comando de saída de dados, que permitirá ao algoritmo expor 
informações ao usuário. Com este e outros comandos você conseguirá construir algoritmos 
aplicáveis no seu dia a dia. 
 
 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 37 
4 - Comando de saída de dados: escrevendo informações na tela 
 
O comando de saída de dados é utilizado pelo algoritmo para se escrever (imprimir) 
informações na tela do computador ou em qualquer dispositivo de saída de dados 
(impressora, fax, modem, etc.). 
 
No VisuAlg só é utilizada a tela do computador como dispositivo de saída de dados. 
 
 
4.1 - Comando ESCREVA 
 
O comando de saída de dados implementado no VisuAlg é o escreva e sua variação 
escreval. 
 
Sintaxe: 
 
escreva(mensagem1, variável1, variável2, expressão1, expressão2, …) 
escreval(mensagem1, variável1, variável2, expressão1, expressão2, …) 
 
Dentro do escreva ou do escreval, as mensagens são colocadas entre aspas e o VisuAlg 
as imprime na tela exatamente como estão dentro das aspas. No caso das variáveis, ainformação que vai para a tela é o conteúdo que a variável contém naquele momento do 
programa. Já no caso das expressões, o VisuAlg calcula a mesma, e informa na tela o seu 
resultado. 
 
A diferença entre escreva e escreval é que no primeiro, o cursor se posiciona na tela logo 
a frente do último valor exibido (exemplo 1). Já no caso do escreval, o cursor se posiciona 
na primeira coluna da próxima linha (exemplo 2). 
 
Para os exemplos que se seguem a janela com borda grossa representa a tela do 
computador. 
 
 
Exemplo1: 
 
escreva("TESTE DE TELA") 
 
TESTE DE TELA_ 
 
 
Neste exemplo que utiliza o escreva, o cursor (traço sublinhado), após o VisuAlg imprimir a 
mensagem que está entre aspas, fica posicionado na mesma linha após a mensagem. 
 
 
Exemplo2: 
 
escreval("TESTE DE TELA") 
 
TESTE DE TELA 
_ 
 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 38 
Neste outro exemplo que utiliza o escreval, o cursor, após o VisuAlg imprimir a mensagem 
que está entre aspas, fica posicionado na linha abaixo da mensagem, na primeira coluna. 
 
 
Exemplo 3: 
 
No próximo exemplo, vamos executar o algoritmo passo a passo para entender o que cada 
comando resulta na tela. Para isto devemos executar o algoritmo pressionando-se a tecla de 
função F8 a cada linha ou comando a ser executado no algoritmo. A linha que estará sendo 
executada está sombreada e o resultado de sua execução está na janela seguinte. 
 
Vamos começar a mostrar o algoritmo a partir da execução da linha sombreada. Neste 
momento, o algoritmo imprimiu o conteúdo da variável nomeAluno e o cursor ficou 
posicionado logo após o texto impresso, devido ao uso do comando escreva, que mantém 
o cursor na mesma linha. 
 
Algoritmo "ExemploDeSaidaDeDados" 
var 
 nomeAluno : caractere 
 endereco : caractere 
 idade : inteiro 
 valorMensalidade : real 
inicio 
 nomeAluno <- "Marcelo da Silva Dias" 
 endereco <- "Rua Cobre, 200" 
 idade <- 30 
 valorMensalidade <- 500.45 
 escreva(nomeAluno) 
 escreval 
 escreval("O endereço do aluno é ",endereco) 
 escreval(valorMensalidade," é o que o aluno ",nomeAluno," paga") 
 escreval("O aluno tem ",valorMensalidade * 0.1," de desconto") 
fimalgoritmo 
 
Marcelo da Silva Dias_ 
 
 
 
Na sequência, o algoritmo simplesmente fez o curso pular para a primeira coluna da linha 
seguinte, devido ao uso do comando escreval, que faz um saldo de linha na tela. 
 
Algoritmo "ExemploDeSaidaDeDados" 
var 
 nomeAluno : caractere 
 endereco : caractere 
 idade : inteiro 
 valorMensalidade : real 
inicio 
 nomeAluno <- "Marcelo da Silva Dias" 
 endereco <- "Rua Cobre, 200" 
 idade <- 30 
 valorMensalidade <- 500.45 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 39 
 escreva(nomeAluno) 
 escreval 
 escreval("O endereço do aluno é ",endereco) 
 escreval(valorMensalidade," é o que o aluno ",nomeAluno," paga") 
 escreval("O aluno tem ",valorMensalidade * 0.1," de desconto") 
fimalgoritmo 
 
Marcelo da Silva Dias 
_ 
 
 
Na sequência, o algoritmo imprimiu o texto entre aspas (O endereço do aluno é ) e o 
conteúdo da variável endereço (Rua Cobre, 200). Depois o cursor pulou para a primeira 
coluna da linha seguinte, devido ao uso do comando escreval. 
 
Algoritmo "ExemploDeSaidaDeDados" 
var 
 nomeAluno : caractere 
 endereco : caractere 
 idade : inteiro 
 valorMensalidade : real 
inicio 
 nomeAluno <- "Marcelo da Silva Dias" 
 endereco <- "Rua Cobre, 200" 
 idade <- 30 
 valorMensalidade <- 500.45 
 escreva(nomeAluno) 
 escreval 
 escreval("O endereço do aluno é ",endereco) 
 escreval(valorMensalidade," é o que o aluno ",nomeAluno," paga") 
 escreval("O aluno tem ",valorMensalidade * 0.1," de desconto") 
fimalgoritmo 
 
Marcelo da Silva Dias 
O endereço do aluno é Rua Cobre, 200 
_ 
 
 
Na sequência, o algoritmo imprimiu o conteúdo da variável valorMensalidade (500.45), o 
texto entre aspas ( é o que o aluno ), o conteúdo da variável nomeAluno (Marcelo da 
Silva Dias) e o texto entre aspas ( paga). Depois o cursor pulou para a primeira coluna da 
linha seguinte, devido ao uso do comando escreval. 
 
Algoritmo "ExemploDeSaidaDeDados" 
var 
 nomeAluno : caractere 
 endereco : caractere 
 idade : inteiro 
 valorMensalidade : real 
inicio 
 nomeAluno <- "Marcelo da Silva Dias" 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 40 
 endereco <- "Rua Cobre, 200" 
 idade <- 30 
 valorMensalidade <- 500.45 
 escreva(nomeAluno) 
 escreval 
 escreval("O endereço do aluno é ",endereco) 
 escreval(valorMensalidade," é o que o aluno ",nomeAluno," paga") 
 escreval("O aluno tem ",valorMensalidade * 0.1," de desconto") 
fimalgoritmo 
 
Marcelo da Silva Dias 
O endereço do aluno é Rua Cobre, 200 
500.45 é o que o aluno Marcelo da Silva Dias paga 
_ 
 
Obs.: Na saída de dados anterior, na terceira linha de impressão, um espaço em braço 
apareceu antes do 500.45 pois o VisuAlg, ao imprimir uma variável numérica (inteiro ou 
real), reserva um espaço para o sinal negativo. 
 
Na sequência, o algoritmo imprimiu o texto entre aspas (O aluno tem ), o resultado da 
operação (expressão aritmética) valorMensalidade * 0.1 (500.45 x 0.1 = 50.045) 
e o texto entre aspas (de desconto). Depois o cursor pulou para a primeira coluna da linha 
seguinte, devido ao uso do comando escreval. 
 
Algoritmo "ExemploDeSaidaDeDados" 
var 
 nomeAluno : caractere 
 endereco : caractere 
 idade : inteiro 
 valorMensalidade : real 
inicio 
 nomeAluno <- "Marcelo da Silva Dias" 
 endereco <- "Rua Cobre, 200" 
 idade <- 30 
 valorMensalidade <- 500.45 
 escreva(nomeAluno) 
 escreval 
 escreval("O endereço do aluno é ",endereco) 
 escreval(valorMensalidade," é o que o aluno ",nomeAluno," paga") 
 escreval("O aluno tem ",valorMensalidade * 0.1," de desconto") 
fimalgoritmo 
 
 
Marcelo da Silva Dias 
O endereço do aluno é Rua Cobre, 200 
500.45 é o que o aluno Marcelo da Silva Dias paga 
O aluno tem 50.045 de desconto 
_ 
 
 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 41 
Obs.: Quando se utiliza os comandos de saída de dados com variáreis do tipo real, para 
evitar a exibição de um número excessivo de casas decimais, pode-se fazer a formatação dos 
dados de saída em relação ao número de casas decimais. Para formatar decimais no VisuAlg 
deve-se utilizar o argumento :num1:num2 logo à frente da variável, do valor, ou da expressão 
a serem formatados. Este argumento indica o tamanho total do conteúdo da variável a ser 
exibida (num1), se igual a 1(um) ocupará o que for necessário na tela, e o número de casas 
decimais a ser exibida (num2). Se o número de casas decimais originais do conteúdo da 
variável for maior do quenum2, o VisuAlg arredondará o valor original até o número de casas 
determinada por num2. 
 
 
Exemplo 4: 
 
No próximo exemplo, o algoritmo imprimiu o texto entre aspas (O Dólar vale hoje US$) e 
o conteúdo da variável valorDolar (2.3561), arredondado para 2 casas decimais 
conforme o segundo parâmetro (2) do argumento para definição de tamanho do campo e 
casas decimais (:1:2). Depois o cursor pulou para a primeira coluna da linha seguinte, 
devido ao uso do comando escreval. 
 
Algoritmo "ExemploDeParametrizaçãoDeCasasDecimais" 
var 
 valorDolar : real 
inicio 
 valorDolar <- 2.3561 
 escreval("Dólar vale hoje US$",valorDolar:1:2) 
fimalgoritmo 
 
 
Dólar valor hoje US$2.36 
_ 
 
 
4.2 – Exercícios Resolvidos 
 
Exercício 1: 
 
Faça um algoritmo que imprima o nome completo e o número de filhos de um usuário na tela 
do computador. 
 
Solução no VisuAlg: 
 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 42 
 
 
 
Exercício 2: 
 
Faça um algoritmo que imprima uma etiqueta de endereçamento da Fumec na tela do 
computador. 
 
Solução no VisuAlg: 
 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 43 
 
 
 
4.3 - Síntese 
 
Neste capítulovocê aprendeu a utilizar os comandos de saída ESCREVA/ESCREVAL, que 
têm como objetivo permitir ao programa enviar para a tela do computador mensagens e 
resultados obtidos em suas expressões. 
 
No próximo capítulo você aprenderá o comando de entrada de dados que permitirá ao usuário 
repassar dados ao programa, a fim de que eles sejam processados. 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 44 
5 - Comando de entrada de dados: recebendo dados ao usuário 
 
O comando de entrada de dados é utilizado pelo algoritmo para receber dados via teclado do 
computador ou de qualquer dispositivo de entrada de dados (scanner, câmera de vídeo, fax, 
modem, etc.). 
 
No VisuAlg só é utilizado o teclado do computador como dispositivo de entrada de dados. 
 
 
5.1 - Comando LEIA 
 
O comando de entrada de dados implementado no VisuAlg é o leia. 
 
Sintaxe: 
 
leia(variável) 
 
Os dados recebidos via teclado por meio do comando leia são armazenados em uma 
variável, que é especificada dentro do parêntesis do leia. 
 
O cursor fica “piscando” na tela de execução do VisuAlg (tela preta) aguardando que o 
usuário digite o dado via teclado e aperte a tecla ENTER. O dado é armazenado na variável 
(aparecendo na tela de Visualização de Variáveis do VisuAlg) e o cursor se posiciona na 
primeira coluna da próxima linha. 
 
O tipo de dado a ser digitado pelo usuário depende do tipo da variável utilizada no comando, 
se a variável tiver sido declarada como inteiro não podemos digitar um texto (caractere) 
ou um valor numérico com casas decimais (real), pois abortará a execução do algoritmo. 
 
Como o comando leia não permite a inserção de mensagens elucidativas sobre o dado a 
ser digitado pelo usuário, é recomendado que sempre antes de um comando leia, venha um 
comando escreva que conterá dentro dele uma mensagem orientando qual o dado a ser 
digitado pelo usuário. 
 
 
Exemplo 1: 
 
leia(nomeAluno) 
 
_ 
 
 
Neste exemplo que utiliza somente o leia, o cursor (traço sublinhado) fica “piscando” e o 
VisuAlg fica aguardando o usuário digitar algum dado e teclar ENTER. 
 
 
Exemplo 2: 
 
escreva("Digite o nome do aluno: ") 
leia(nomeAluno) 
 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 45 
Digite o nome do aluno: _ 
 
 
Neste outro exemplo que utiliza o escreva e o leia, o cursor (traço sublinhado) fica 
“piscando” logo depois da mensagem (uso do escreva em vez do escreval) e o VisuAlg 
fica aguardando o usuário digitar algum dado e teclar ENTER. 
 
Obs.: O uso de espaços dentro das aspas das mensagens do comando escreva ou 
escreval são importantes pois fazem com que as mensagens, conteúdos de variáveis e 
dados informados pelo usuário fiquem zerados. 
 
Exemplo de um algoritmo utilizando declaração de variáveis, entrada de dados e saída de 
dados: 
 
 
Exemplo 3: 
 
Algoritmo "ExemploDeEntradaDeDados" 
var 
 nomeAluno : caractere 
 endereco : caractere Declaração de 
 valorMensalidade : real variáveis 
inicio 
 escreva("Informe o nome do aluno: ") 
 leia(nomeAluno) 
 escreva("Informe o seu endereço: ") Entrada de 
 leia(endereco) dados 
 escreva("Informe valor de sua mensalidade: ") 
 leia(valorMensalidade) 
 escreval("Aluno: ",nomeAluno) 
 escreval("O endereço do aluno é ",endereco) Saída de 
 escreval("R$",valorMensalidade," é sua mensalidade") dados 
fimalgoritmo 
 
Outro exemplo de um algoritmo agora utilizando as 4 partes básicas que um algoritmo deve 
ter: declaração de variáveis, entrada de dados, cálculos (processamento) e saída de dados: 
 
Algoritmo "ExemploDeEntradaSaídaDeDados" 
var 
 nomeAluno : caractere 
 percentual, Declaração de 
 valorMensalidade, variáveis 
 valorComDesconto : real 
inicio 
 escreva("Informe o nome do aluno: ") 
 leia(nomeAluno) 
 escreva("Informe valor de sua mensalidade: ") Entrada de 
 leia(valorMensalidade) dados 
 escreva("Informe o seu percentual de desconto: ") 
 leia(percentual) 
 desconto <- valorMensalidade * percentual / 100 Cálculos 
 valorComDesconto <- valorMensalidade - desconto 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 46 
 escreval("Aluno: ",nomeAluno) Saída de 
 escreval("R$",valorComDesconto," é sua mensalidade") dados 
fimalgoritmo 
 
 
5.2 - Exercícios Resolvidos 
 
Siga as etapas descritas a seguir para criar algoritmos no VisuAlg: 
 
 1º – Declarar as variáveis necessárias ao algoritmo, informando que tipo de dado (inteiro, 
real ou caractere) que ela trabalhará; 
 2º – Criar comandos de entrada de dados para receber os dados a serem informados 
(digitados) pelo usuário via teclado do computador; 
 3º – Criar comandos necessários para fazer os cálculos solicitados (processamento dos 
dados de entrada e geração dos resultados); 
 4º – Criar comandos para exibir os resultados (dados de saída) na tela do computador. 
 
 
Exercício 1: 
 
Fazer um algoritmo que calcule e imprima o valor da função f(x), sendo o valor de x 
informado pelo usuário. 
 
104)( 3  xxxf
 
 
Solução no VisuAlg: 
 
 
 
 
Exercício 2: 
 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 47 
A área da superfície esférica e o volume de uma esfera são calculados a partir das fórmulas 
dadas. Faça um algoritmo que leia o raio R de uma esfera e calcule e imprima a sua área e 
volume. Utilizar o valor de = 3.1416. 
 
3
2
3
4
4
RVolume
RÁrea




 
 
Solução no VisuAlg: 
 
 
 
 
Exercício 3: 
 
A distância entre um ponto P e uma reta R é dada pela função Distância. Faça um 
algoritmo que solicite ao usuário os valores de A, B e C da reta R e as coordenadas Xo e Yo do 
ponto P e calcule e imprima o valor da distância deste ponto a reta. 
 
22
00
),(
BA
CByAx
Distância
yxP
CByAxR
oo




 
 
Solução no VisuAlg: 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 48 
 
 
 
5.3 - Síntese 
 
Neste capítulo você aprendeu a utilizar o comando de entrada de dados LEIA, que têm como 
objetivo permitir ao usuário enviar dados para o programa para que eles sejam processados e 
gerem resultados, os quais são mostrados ao usuário na tela do computador. 
 
Os comandos de entrada junto com os comandos de saída compõem os comandos de I/O 
(input/output) ou E/S (entrada/saída) de dados de um algoritmo. 
 
No próximo capítulo você conhecerá um dos comandos que implementam as estruturas 
condicionais em um algoritmo, e que, de certa forma, dão “inteligência” ao algoritmo e ao 
computador. 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 49 
6 - Estrutura Condicional: o computador tomando decisões 
 
Situações condicionais fazem parte do cotidiano de todas as pessoas. Frequentemente nos 
vemos em situações onde devemos tomar uma decisão ou executar uma ação se uma 
condição ocorrer, por exemplo: 
 
se vai chover então vou pegar um guarda-chuva 
 
Neste exemplo a condição é vai chover, e caso esta condição seja VERDADEIRA, ou seja, 
a chuva venha a acontecer, a ação a ser tomada é vou pegar um guarda-chuva. Caso 
esta condição seja FALSA, ou seja, a chuva não venha a acontecer, nenhuma ação é tomada. 
 
se vai chover então vou ficar em casa senão vou fazer uma corrida 
 
Neste outro exemplo, utilizando a mesma condição vai chover, caso ela seja 
VERDADEIRA, ou seja, a chuva venha a acontecer, a ação a ser tomada é vou ficar em 
casa. Caso esta condição seja FALSA, ou seja, a chuva não venha a acontecer, a ação a 
ser tomada é vou fazer uma corrida. 
 
Em um algoritmo, uma estrutura condicional deve ser utilizada quando a execução de uma 
(ou mais) linha de código (ou comando) depende do estado de uma condição. 
 
 
6.1 - Comando SE 
 
Nos algoritmos, uma das estruturas condicionais que podemos utilizar é representada pelo 
comando se...fimse.O comando se pode ser utilizado de duas formas, dependendo de sua estrutura condicional. 
São elas: 
 
→ Forma Simples 
→ Forma Composta 
 
 
6.1.1 - Forma Simples 
 
Sintaxe: 
 
se condição entao 
 comando1 
 comando2 
 ... 
 comandon 
fimse 
 
Na forma simples, se condição for VERDADEIRA, os comandos que estão dentro do entao 
serão executados, mas se condição for FALSA, os comandos não serão executados. 
 
Fluxo: 
comando 
comando 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 50 
se condição entao 
 comando1 
 comando2 
 ... 
 comandon 
fimse 
comando 
comando 
 
 
comando 
comando 
se condição entao 
 comando1 
 comando2 
 .... 
 comandon 
fimse 
comando 
comando 
 
 
Identação: Nesta sintaxe a identação está presente no recuo utilizado em cada linha de 
comando existente entre o se e o fimse. No editor de textos do VisuAlg, utilizaremos dois 
espaços como recuo de identação. Estes dois espaços são suficientes para indicar 
visualmente o recuo e indicar que os comandos escritos com estes espaços a esquerda estão 
embutidos dentro da estrutura condicional. Outra opção para o recuo é utilizar a tecla TAB, a 
diferença é que cada vez que você pressionar a tecla TAB no editor de texto do VisuAlg, o 
número de espaços que serão inseridos na horizontal vai variar entre 3 e 5 espaços, 
dependendo do tipo de estrutura de comandos. 
 
A outra regra de identação presente nesta estrutura é a colocação do fimse na mesma 
coluna em que foi digitado o se, ou seja, estas duas palavras estão alinhadas verticalmente 
no código do programa. O mesmo acontece com os comandos dispostos entre o se e o 
fimse, todos estão alinhados e com a digitação iniciando na mesma coluna do editor de 
texto. 
 
 
Exemplo1: 
 
leia(numero) 
se numero > 10 entao 
 escreval("Número é MAIOR que 10") 
fimse 
 
Neste exemplo o texto Número é MAIOR que 10 só será exibido na tela caso a condição 
numero > 10 seja VERDADEIRA. Suponha que o usuário digite 25, através do comando 
leia. Este valor será armazenado na variável numero. Neste caso a condição será 
VERDADEIRA e a mensagem será exibida na tela. Caso ele digite 8, a condição será FALSA 
e a mensagem não será exibida. 
 
Condição VERDADEIRA: 
os comandos dentro do SE 
serão executados 
Condição FALSA: 
os comandos dentro do SE 
não serão executados 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 51 
 
Exemplo 2: 
 
notaFinal <- nota1 + nota2 + nota3 
se notaFinal >= 60 entao 
 escreval(″O aluno está aprovado!″) 
 mediaFinal <- notaFinal / 3 
fimse 
 
Neste exemplo os dois comandos escritos entre o se e o fimse só serão executados se a 
notaFinal calculada antes do se for maior ou igual a 60. Caso contrário, nenhum dos dois 
comandos serão executados. 
 
 
6.1.2 - Forma Composta 
 
Sintaxe: 
 
se condição entao 
 comando11 
 comando12 
 ... 
 comando1n 
senao 
 comando21 
 comando22 
 ... 
 comando2n 
fimse 
 
Na condição composta, se condição for VERDADEIRA, serão executados somente os 
comandos que estão dentro do entao, mas se condição for FALSA, serão executados 
somente os comandos que estão dentro do senao. 
 
Fluxo: 
comando 
comando 
se condição entao 
 comando11 
 comando12 
 ... 
 comando1n 
senao 
 comando21 
 comando22 
 ... 
 comando2n 
fimse 
comando 
comando 
 
 
Condição VERDADEIRA: 
somente os comandos 
dentro do ENTAO serão 
executados 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 52 
comando 
comando 
se condição entao 
 comando11 
 comando12 
 ... 
 comando1n 
senao 
 comando21 
 comando22 
 ... 
 comando2n 
fimse 
comando 
comando 
 
 
 
Identação: Nesta sintaxe a identação está presente no recuo utilizado em cada linha de 
comando existente entre o se e o entao e entre o senao e o fimse. Quando a cláusula 
senao é utilizada na estrutura condicional o alinhamento a esquerda deverá ocorrer entre o 
se, o senao e o fimse, ou seja, a digitação deles deve iniciar na mesma coluna do editor de 
texto. 
 
 
Exemplo 1: 
 
leia(numero) 
se numero > 10 entao 
 escreval("Número é MAIOR que 10") 
senao 
 escreval("Número é MENOR ou IGUAL a 10") 
fimse 
 
Neste exemplo, se o valor digitado, que ficará armazenado na variável numero, for maior que 
10, será executado somente o comando escrito entre o se e o entao, ou seja, a mensagem 
Número é MAIOR que 10 será exibida na tela. Mas se a nota digitada for menor ou igual a 
10, será executado somente o comando escrito entre o senao e o fimse, ou seja, a 
mensagem Número é MENOR ou IGUAL A 10 será exibida na tela. 
 
 
Exemplo 2: 
 
Algoritmo "CalculaINSS" 
var 
 salario : real 
 inss : real 
inicio 
 escreva("Digite o valor do seu salário: ") 
 leia(salario) 
 se salario <= 300 entao 
 inss <- salario * 0.08 
Condição FALSA: 
somente os comandos 
dentro do SENAO serão 
executados 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 53 
 escreval("Funcionário caiu na alíquota de 8%") 
 senao 
 inss <- salario * 0.10 
 escreval("Funcionário caiu na alíquota de 10%") 
 fimse 
 escreval("Valor do INSS = ",inss) 
fimalgoritmo 
 
Neste exemplo, se o valor digitado, que ficará armazenado na variável salario, for menor 
ou igual a 300, serão executados somente os comandos escritos entre o se e o entao, ou 
seja, a mensagem Funcionário caiu na alíquota de 8% será exibida na tela e o 
cálculo do inss com 8% será feito. Mas se o salário digitado for maior que 300, serão 
executados somente os comandos escritos entre o senao e o fimse, ou seja, a mensagem 
Funcionáriocaiu na alíquota de 10% será exibida na telae o cálculo do inss com 
10% será feito. Após ambas as condições, a mensagem Valor do INSS = , seguido do 
conteúdo da variável inss, serão exibidos na tela 
 
 
6.2 - Estrutura Condicional Composta Aninhada 
 
A estrutura condicional composta aninhada é útil para situações onde o número de 
alternativas é maior que duas. 
 
Sintaxe: 
 
se condição1 entao 
 comando1 
 comando2 
 ... 
 comandon 
senao 
 se condição2 entao 
 comando1 
 comando2 
 ... 
 comandon 
 senao 
 se condição2 entao 
 comando1 
 comando2 
 ... 
 comandon 
 senao 
 comando1 
 comando2 
 ... 
 comandon 
 fimse 
 fimse 
fimse 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 54 
 
Nesta forma, após o senao, ao invés de vir uma lista de comandos, vem um novo teste 
condicional (se...entao...fimse), ou seja, um comando se dentro do senao do comando 
se anterior. 
 
Importante: Para cada comando se inserido no programa deve existir um entao e um 
fimse correspondentes. O senao é opcional. 
 
Identação: Nesta sintaxe a identação está presente no recuo utilizado em cada linha de 
comando existente entre o primeiro se e o senao e entre o senao e o fimse, e também 
entre o segundo se...senao...fimse. Perceba que para cada se iniciado dentro de um 
senao ou de um entao, deverá ser inserido um novo recuo de mais 2 espaços. 
 
 
Exemplo 1: 
 
Criar uma lógica condicional para a tabela a seguir: 
 
Faixa Salarial Alíquota 
Até R$300,00 8% 
Acima de R$300,00 até R$1.000,00 9% 
Acima de R$1.000,00 10% 
 
Algoritmo "CalculaINSS" 
var 
 salario : real 
 inss : real 
inicio 
 escreva("Digite o valor do seu salário: ") 
 leia(salario) 
 se salario <= 300 entao 
 inss <- salario * 0.08 
 fimse 
 se (salario > 300) e (salario <= 1000) entao 
 inss <- salario * 0.09 
 fimse 
 se salario > 1000 entao 
 inss <- salario * 0.10 
 fimse 
 escreval("Valor do INSS = ",inss) 
fimalgoritmo 
 
Neste exemplo utilizamos três comandos se seguidos, um depois do outro, um para cada 
alíquota (8%, 9% e 10%), ou seja, o primeiro se, para cálculo do INSS com alíquota de 8%, é 
aberto, tem-se o entao dele, e dentro o comando para o cálculo (inss<- salario * 
0.08) e logo depois este comando se é fechado com um fimse. Logo após abre-se um outro 
comando se para a próxima alíquota da tabela (9%), e assim por diante. Depois dos 
comandos se, vêm o escreval para imprimir na tela o valor do INSS calculado em um dos 
se. 
 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 55 
A forma utilizada no exemplo anterior (comandos se seguidos) pode ser utilizada 
normalmente quando se tem mais de duas alternativas, mas o ideal é utilizar os comandos se 
de forma aninhada, como no exemplo a seguir: 
 
Algoritmo "CalculaINSS" 
var 
 salario : real 
 inss : real 
inicio 
 escreva("Digite o valor do seu salário: ") 
 leia(salario) 
 se salario <= 300 entao 
 inss <- salario * 0.08 
 senao 
 se salario <= 1000 entao 
 inss <- salario * 0.09 
 senao 
 inss <- salario * 0.10 
 fimse 
 fimse 
 escreval("Valor do INSS = ",inss) 
fimalgoritmo 
 
Na forma mostrada no exemplo (comandos se aninhados, ou, um se dentro de outro se), se 
o salário digitado for menor ou igual a 300, será executado somente o comando escrito entre 
o primeiro se e o entao, com o algoritmo “pulando” para a impressão do INSS calculado. 
 
inss <- salario * 0.08 
 
Mas se o salário for maior que 300, aí é iniciada uma nova estrutura condicional, pois 
precisaremos verificar, antes dos cálculos, se o salário é maior ou menor do que 1000. Nesta 
nova estrutura condicional, se o salário for menor ou igual a 1000 (lembre-se que o algoritmo 
chegou até aqui porque o salário é maior que 300, então não há necessidade de testar 
novamente se o salário é maior que 300, ou seja, neste caso, testar se salario <= 1000 é 
o mesmo que testar se (salario > 300) e (salario <= 1000), será executado 
somente o comando escrito entre o segundo se e o segundo senao, com o algoritmo 
“pulando” para a impressão do INSS calculado. 
 
inss <- salario * 0.09 
 
Mas se o salário digitado for maior que 1000, será executado somente o comando escrito 
entre o segundo senao e o fimse escrito logo em seguida, com o algoritmo “pulando” para a 
impressão do INSS calculado. 
 
inss <- salario * 0.10 
 
 
Exemplo 2: 
 
Faça um algoritmo que receba o valor de x, e calcule e imprima o valor de f(x) conforme a 
seguinte função. 
 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 56 
















4,
16
35
4,0
4,
16
35
)(
2
2
xse
x
x
xse
xse
x
x
xf 
 
Solução utilizando um comando se depois do outro: 
 
Algoritmo "FunçãoMúltipla" 
var 
 x : real 
 fx : real 
inicio 
 escreva("Escreva o valor de X: ") 
 leia(x) 
 se x < 4 entao 
 fx <- (5*x + 3)/(16 - x^2)^(1/2) 
 fimse 
 se x = 4 entao 
 fx <- 0 
 fimse 
 se x > 4 entao 
 fx <- (5*x + 3)/(x^2 - 16)^(1/2) 
 fimse 
 escreval("Valor da função = ",fx) 
fimalgoritmo 
 
Solução utilizando um comando se dentro do outro (aninhados): 
 
Algoritmo "FunçãoMúltipla" 
var 
 x : real 
 fx : real 
inicio 
 escreva("Escreva o valor de X: ") 
 leia(x) 
 se x < 4 entao 
 fx <- (5*x + 3)/(16 - x^2)^(1/2) 
 senao 
 se x = 4 entao 
 fx <- 0 
 senao 
 fx <- (5*x + 3)/(x^2 - 16)^(1/2) 
 fimse 
 fimse 
 escreval("Valor da função = ",fx) 
fimalgoritmo 
 
 
6.3 - Exercícios Resolvidos 
 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 57 
Exercício 1: 
 
A Secretaria do Meio Ambiente mediu a quantidade de poluentes atmosféricos emitidos por 
uma empresa. Dependendo do valor obtido, a empresa foi multada conforme a tabela dada. 
Faça um algoritmo que leia a quantidade de poluentes emitidos por uma empresa e calcule e 
imprima a multa aplicada, se for o caso. 
 
Quantidade de Poluente 
emitido [mg/(t*m2)] 
Valor da Multa [R$] 
Até 1500 Isento 
Acima de 1500 até 3000 R$3.000,00 
Acima de 3000 R$5.000,00 x Quantidade de Poluentes 
 
 
Solução no VisuAlg (utilizando um comando se depois do outro): 
 
 
 
Exercício 2: 
 
Uma loteria esportiva paga prêmios proporcionais a quantidade de acertos de cada apostador. 
Ela tem 13 jogos. Se o apostador acertar até 5 jogos ele não ganha nada, se acertar de 6 a 10 
jogos ele ganha um outro cartão para apostar, se acertar 11 jogos ganha R$100, 12 jogos 
R$1000 e 13 jogos R$50000. Faça um algoritmo que leia o nome do apostador e a 
quantidade de jogos que ele acertou, e calcule e imprima o prêmio que ele ganhou. 
 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 58 
Acertos Prêmio 
Até 5 Nenhum 
De 6 até 10 Outro cartão 
11 R$100,00 
12 R$1.000,00 
13 R$50.000,00 
 
Solução no VisuAlg (utilizando um comando se dentro do outro): 
 
 
 
 
Exercício 3: 
 
Faça um algoritmo que leia as 3 notas parciais de um aluno (valores inteiros), calcule a nota 
final (soma das notas parciais) e imprima o conceito do aluno conforme a seguinte tabela: 
 
Nota Final Conceito 
Abaixo de 60 D 
De60 até69 C 
De 70 até 89 B 
De 90 até 100 A 
 
Solução no VisuAlg (utilizando um comando se dentro do outro): 
 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 59 
 
 
 
6.4 - Síntese 
 
Neste capítulo você aprendeu o comando SE e suas duas formas de utilização. A partir de 
agora seus algoritmos serão capazes de tomar decisões, e executar ou não um grupo de 
comandos. 
 
No próximo capítulo você terá contato e aprenderá a utilizar comandos que representam as 
estruturas de repetição de um algoritmo, permitindo que seu algoritmo ganhe em 
escalabilidade e processe uma grande quantidade de dados. 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 60 
7 - Estruturas de repetição (laço ou loop) 
 
 
As estruturas de repetição são utilizadas quando um conjunto de comandos dentro de um 
algoritmo precisa ser executado repetidas vezes. Sendo assim, ao invés de se escrever várias 
vezes o mesmo conjunto de comandos, este deverá ser escrito somente uma vez dentro de 
uma estrutura de repetição. A estrutura de repetição é que ficará encarregada de executar o 
conjunto de comandos várias vezes. 
 
Exemplo: 
 
Imagine que você vai solicitar a um usuário que digite o nome de 3 alunos. A forma não 
recomendada para este algoritmo seria escrever 3 vezes o comando de entrada de dados: 
 
escreva("Digite o nome do aluno 1: ") 
leia(nomeAluno) 
escreva("Digite o nome do aluno 2: ") 
leia(nomeAluno) 
escreva("Digite o nome do aluno 3: ") 
leia(nomeAluno) 
 
Por outro lado, a forma recomendada seria escrever uma única vez o comando de entrada de 
dados dentro de uma estrutura de repetição que fará com que ele seja executado 3 vezes: 
 
Exemplo 1 (utilizando o comando PARA): 
 
para numAluno de 1 ate 3 faca 
 escreva("Digite o nome do aluno ",numAluno,":") 
 leia(nomeAluno) 
fimpara 
 
Exemplo 2 (utilizando o comando REPITA): 
 
numAluno <- 0 
repita 
 numAluno <- numAluno + 1 
 escreva("Digite o nome do aluno ",numAluno,":") 
 leia(nomeAluno) 
ate numAluno = 3 
 
Exemplo 3 (utilizando o comando ENQUANTO): 
 
numAluno <- 0 
enquanto numAluno < 3 faca 
 numAluno <- numAluno + 1 
 escreva("Digite o nome do aluno ",numAluno,":") 
 leia(nomeAluno) 
fimenquanto 
 
Nos dois exemplos anteriores, os comandos leia e escreva serão executados 3 vezes na 
sequência mas foram escritos somente 1 vez. Para controlar o número de repetições, a 
variável numAluno, dos comandos para e enquanto, será incrementada a partir de 1 até 
3 para cada execução dos comandos escreva e leia. 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 61 
 
As estruturas de repetição também são conhecidas nas linguagens de programação como 
laço ou loop. 
 
Existem comandos apropriados para efetuar a repetição de outros comandos tantas vezes 
forem necessárias. A principal vantagem em se utilizar os comandos de repetição é que o 
algoritmo passa a ter um tamanho (número de comandos) muito menor. 
 
Existem 2 tipos de repetições: 
 
 Definidas e Garantidas, ou seja, um conjunto decomandos será executado um 
número pré-determinado de vezes; 
 Indefinidas e sem Garantia, ou seja, um conjunto de comandos será executado 
indefinidamente, não havendo garantia do término da execução do algoritmo. 
 
Os comandos que iremos estudar neste material, que implementam as estruturas de 
repetição, são os comandos PARA, REPITA e ENQUANTO, que são mostrados a seguir: 
 
 
Comando PARA (repetição baseada em contagem automática): 
 
para variável de valorInicial ate valorFinal faca 
 comando1 
 comando2 Conjunto de comandos que serão 
 ... executados várias vezes 
 comandon 
fimpara 
 
algoritmo "RaizQuadrada" 
var 
 numero, 
 contador : inteiro 
 raiz : real 
inicio 
 para contador de 1 ate 5 faca 
 escreva("Informe um número inteiro: ") 
 leia(numero) 
 raiz <- numero ^ (1/2) 
 escreval("A raiz quadrada de ",numero," = ",raiz) 
 escreval 
 fimpara 
fimalgoritmo 
 
 
Comando REPITA (repetição baseada em condição): 
 
repita 
 comando1 
 comando2 Conjunto de comandos que serão 
 ... executados várias vezes 
 comandon 
ate condição 
 
algoritmo "RaizQuadrada" 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 62 
var 
 numero : inteiro 
 raiz : real 
inicio 
 repita 
 escreva("Informe um número inteiro: ") 
 leia(numero) 
 raiz <- numero ^ (1/2) 
 escreval("A raiz quadrada de ",numero," = ",raiz) 
 escreval 
 ate numero = 0 
fimalgoritmo 
 
 
Comando ENQUANTO (repetição baseada em condição): 
 
enquanto condição faca 
 comando1 
 comando2 Conjunto de comandos que serão 
 ... executados várias vezes 
 comandon 
fimenquanto 
 
algoritmo "RaizQuadrada" 
var 
 numero : inteiro 
 raiz : real 
inicio 
 escreva("Informe um número inteiro: ") 
 leia(numero) 
 enquanto numero <> 0 faca 
 raiz <- numero ^ (1/2) 
 escreval("A raiz quadrada de ",numero," = ",raiz) 
 escreval 
 escreva("Informe um número inteiro: ") 
 leia(numero) 
 fimenquanto 
fimalgoritmo 
 
Daqui para frente iremos estudar cada um destes comandos em detalhes, começando pelo 
comando PARA. 
 
 
7.1 - Comando PARA 
 
Caracteriza-se por repetir um conjunto de comandos uma quantidade de vezes pré-definida. 
O loop é encerrado quando o número de repetições se igualar a quantidade pré-determinada, 
em termos de algoritmo, quando a sua variável auxiliar atingir o valor final. 
 
Sintaxe: 
 
para variável de valorInicial ate valorFinal [passo valor] faca 
 comando1 
 comando2 
 comandon 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 63 
fimpara 
 
Legenda: 
 A variável deverá ser uma variável do tipo inteiro que será utilizada para 
controlar o número de repetições; 
 O valorInicial é o valor inicial que a variável assumirá antes da primeira 
execução dos comandos. Deve ser sempre inteiro; 
 O valorFinal é o valor limite que a variável assumirá, e quando ele ocorrer será o 
fim das repetições. Deve ser sempre inteiro. 
 O [passo valor] é opcional e indica o valor o qual a variável será 
incrementada ou decrementada após cada execução dos comandos (comando1, 
comando2, ...). Deve ser sempre inteiro. 
 
Se desde o início da primeira repetição o valorInicial for maior que o valorFinal (ou 
menor quando o passo for negativo) os comandos não serão executados nenhuma vez. Se 
passo valor for positivo a variável será incrementada, se for negativo a variável será 
decrementada. Se passo valor não for utilizado, a variável será incrementada em 1 
após cada execução dos comandos (comando1, comando2,...). 
 
O número de repetições do comando PARA obedece a seguinte fórmula: 
 
Repetições = valorFinal – valorInicial + 1 
 
Exemplos: 
 
para aux de 1 ate 50 faca >>> Repetições = 50 – 1 + 1 = 50 
 ... 
fimpara 
 
para aux de 20 ate 69 faca >>> Repetições = 69 – 20 + 1 = 50 
 ... 
fimpara 
 
Portanto, se fixarmos o valorInicial em 1, o valorFinal indicará quantas repetições 
serão executadas no comando PARA. 
 
Exemplo 1: 
 
Faça um algoritmo que calcule as massas corporais de 5 pessoas, com os pesos individuais 
de cada uma sendo informados pelo usuário. A cada peso informado deverá ser calculada e 
impressa a massa. 
 
Massa Corporal = Peso / 9.8 
 
Para uma única pessoa o algoritmo ficaria da seguinte forma: 
 
Algoritmo "CalculaMassaCorporal" 
var 
 peso, 
 massa : real 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 64 
inicio 
 escreva("Entre com o peso: ") 
 leia(peso) 
 massa <- peso / 9.8 
 escreval("Massa corporal = ",massa) 
fimalgoritmo 
 
De forma não recomendada, poderíamos criar o algoritmo repetindo o conjunto de comandos 
5 vezes (Crtl+C/Crtl+V), conforme mostrado a seguir: 
 
Algoritmo "CalculaMassaCorporal" 
var 
 peso, 
 massa : real 
inicio 
 escreva("Entre com o peso: ") 
 leia(peso) 
 massa <- peso / 9.8 
 escreval("Massa corporal = ",massa) 
 
 escreva("Entre com o peso: ") 
 leia(peso) 
 massa <- peso / 9.8 
 escreval("Massa corporal = ",massa) 
 
 escreva("Entre com o peso: ") 
 leia(peso) 
 massa <- peso / 9.8 
 escreval("Massa corporal = ",massa) 
 
 escreva("Entre com o peso: ") 
 leia(peso) 
 massa <- peso / 9.8 
 escreval("Massa corporal = ",massa) 
 
 escreva("Entre com o peso: ") 
 leia(peso) 
 massa <- peso / 9.8 
 escreval("Massa corporal = ",massa) 
fimalgoritmo 
 
Imagine como ficaria o algoritmo anterior se fossemos calcular a massa corporal de 1000 
pessoas? Inviável de se criar! 
 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 65 
A forma recomendada e correta de fazer este algoritmo é utilizar o comando PARA conforme 
mostrado a seguir: 
 
Algoritmo "CalculaMassaCorporal" 
var 
 aux : inteiro 
 peso, 
 massa : real 
inicio 
 para aux de 1 ate 5 faca 
 escreva("Entre com o peso: ") 
 leia(peso) 
 massa <- peso / 9.8 
 escreval("Massa corporal = ",massa) 
 fimpara 
fimalgoritmo 
 
Neste exemplor, a variável aux começa pelo valor inicial 1, e vai até o valor final 5, totalizando 
5 repetições. Os comandos dentro do PARA serão executados repetidas vezes e de forma 
sequencial. 
 
Exemplo 2: 
 
Faça um algoritmo que calcule e imprima os valores da função f(x) = x2 - 1, para 10 
valores de x informados pelo usuário. A cada valor informado o algoritmo deverá imprimir este 
valor e o da função, da seguinte forma: 
x=1 f(x)=0 
x=2 f(x)=3 
x=3 f(x)=8 
... 
 x=10 f(x)=99 
 
Para um único valor de x o algoritmo ficaria da seguinte forma: 
 
Algoritmo "FunçãoManual" 
var 
 x : inteiro 
 fx : real 
inicio 
 escreva("Informe o valor de X: ") 
 leia(x) 
 fx <- x^2 - 1 
 escreval("x=",x," f(x)=",fx) 
fimalgoritmo 
 
Como são 10 valores de x o algoritmo completo seria: 
 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 66 
Algoritmo "FunçãoManual" 
var 
 x, 
 aux : inteiro 
 fx : real 
inicio 
 para aux de 1 ate 10 faca 
 escreva("Informe o valor de X: ") 
 leia(x) 
 fx <- x^2 - 1 
 escreval("x=",x," f(x)=",fx) 
 fimpara 
fimalgoritmo 
 
 
Lembre-se: O nome (identificador) de uma variável tem regras rígidas, por isso o nome 
utilizado para a variável que armazenará o valor da função não pode ser f(x), pois os 
parêntesis não podem estar no nome de uma variável. Também não podemos utilizar o nome 
da variável como função pois o c cedilha (ç) também não pode ser utilizado. Por fim, a palavra 
funcao também não pode ser utilizada pois é uma palavra reserva do VisuAlg (ver anexo 1). 
 
 
7.2 - Variação da quantidade de repetições do comando PARA 
 
A quantidade de repetições do comando PARA pode variar de acordo com a necessidade do 
usuário. 
 
Fixando-se o valorInicial em 1, pode-se utilizar uma variável inteira no lugar do 
valorFinal do comando PARA, com isso o valor que valorFinal contiver no momento da 
execução do comando PARA será o número de repetições que serão executadas. 
 
O conteúdo da variável que substituir o valorFinal, naprática, a quantidade de repetições, 
deve ser lida (solicitada ao usuário) antes do comando PARA a fim de que, quando o 
comando PARA for executado, ela tenha um valor diferente de zero. 
 
A sintaxe deve ser: 
 
var 
 aux, rep : inteiro 
... 
leia(rep) 
para aux de 1 ate rep faca 
 ... 
fimpara 
 
Utilizando o mesmo problema mostrado no Exemplo 1 do item anterior, podemos solicitar ao 
usuário, no início do programa, quantas pessoas deverão ter sua massa corporal calculada: 
 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 67 
Algoritmo "CalculaMassaCorporal" 
var 
 aux, 
 npessoas : inteiro 
 peso, 
 massa : real 
inicio 
 escreva("Quantas pessoas terão suas massas calculada? ") 
 leia(npessoas) 
 para aux de 1 ate npessoas faca 
 escreva("Entre com o peso: ") 
 leia(peso) 
 massa <- peso / 9.8 
 escreval("Massa corporal = ",massa) 
 fimpara 
fimalgoritmo 
 
No exemplo, a variável npessoas substituiu a constante 5, e o conteúdo dela, ou seja, o 
número de repetições do comando PARA, será informado pelo usuário antes do ciclo de 
repetições. 
 
 
7.3 - Utilização dos valores da variável auxiliar do comando PARA 
 
Como já foi dito anteriormente, a variável auxiliar do comando PARA varia de valorInicial 
a valorFinal, sendo incrementada, ou decrementada, de acordo com o valor do 
parâmetro passo. Se este parâmetro não for especificado (ele é opcional), a variável auxiliar 
é incrementada de 1 em 1. 
 
No exemplo seguinte, a variável aux, na primeira repetição vale 1, depois assume os valores 
2, 3, 4, 5, 6, 7, 8, 9 e 10, ou seja, 10 valores diferentes = 10 repetições. 
 
para aux de 1 ate 10 faca 
 ... 
fimpara 
 
No próximo exemplo, a variável aux, na primeira repetição vale 10, depois assume os valores 
11, 12, 13, 14, 15 e 16, ou seja, 7 valores diferentes = 7 repetições. 
 
paraaux de 10 ate 16 faca 
 ... 
fimpara 
 
Os valores que a variável auxiliar vai assumindo ao longo das repetições podem ser utilizados 
dentro do comando PARA em função de alguma necessidade do algoritmo. 
 
Exemplo 1: 
 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 68 
Faça um algoritmo que calcule e imprima os valores da função f(x) = x2 - 1, com o x 
variando no intervalo entre 1 e 10. A cada valor informado o algoritmo deverá imprimir este 
valor e o da função, da seguinte forma: 
x=1 f(x)=0 
x=2 f(x)=3 
x=3 f(x)=8 
... 
x=10 f(x)=99 
 
No exemplo 2 do item 7.1, os valores de x eram informados pelo usuário. Desta vez eles não 
precisam ser informados, pois podem ser utilizados os valores que variável auxiliar do PARA 
vai assumindo ao longo das repetições. Veja como fica o algoritmo: 
 
Algoritmo "FunçãoAutomático" 
var 
 x : inteiro 
 fx : real 
inicio 
 para x de 1 ate 10 faca 
 fx <- x^2 - 1 
 escreval("x=",x," f(x)= ",fx) 
 fimpara 
fimalgoritmo 
 
A variável auxiliar do comando PARA anterior é o próprio x, ou seja, o usuário não informará 
nada ao algoritmo, pois os valores da variável auxiliar do PARA serão utilizados para calcular 
os valores da função f(x). 
 
Exemplo 2: 
 
Faça um algoritmo que calcule e imprima todos os números divisíveis por 13 no intervalo 
entre 100 e 500. 
 
Dica: Para verificarmos se um número é divisível por outro é só testarmos se o resto da 
divisão inteira entre um número e outro é igual a 0(zero), ou seja A % B = 0, onde A e B 
devem ser do tipo inteiro. 
 
Veja como fica o algoritmo: 
 
Algoritmo "DivisívelPor13Entre100e500" 
var 
 numero : inteiro 
inicio 
 para numero de 100 ate 500 faca 
 se numero % 13 = 0 entao 
 escreval("O número ",numero," é divisível por 13") 
 fimse 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 69 
 fimpara 
fimalgoritmo 
 
No exemplo, a variável auxiliar numero assumirá, ao longo das 401 repetições (500 – 100 + 
1), os valores de 100 a 500, e a cada repetição o comando SE testará se o conteúdo da 
variável auxiliar numero, quando dividido (de forma inteira) por 13, tem resto igual a 0(zero). 
Se tiver, ou seja, a condição do SE for verdadeira, o comando ESCREVAL é executado e o 
conteúdo da variável numero é impresso na tela do computador, entre as mensagens 
associadas. 
 
Exemplo 3: 
 
O algoritmo a seguir implementa a função matemática fatorial. O fatorial de um número é o 
resultado da multiplicação do próprio número pelos seus antecessores inteiros até 1, ou seja, 
fatorial de 5 (escrito da forma 5!) = 5 x 4 x 3 x 2 x 1 ou 1 x 2 x 3 x 4 x 5 = 120. 
 
Algoritmo "CalculaFatorial" 
var 
 aux, 
 numero, 
 fatorial : inteiro 
inicio 
 fatorial <- 1 (1) 
 escreva("Informe um número inteiro: ") 
 leia(numero) (2) 
 para aux de 1 ate numero faca (3) 
 fatorial <- fatorial * aux (4) 
 fimpara 
 escreval("Fatorial de ",numero," = ",fatorial) (5) 
fimalgoritmo 
 
Vamos analisar este algoritmo, passo a passo, seguindo as linhas da tabela de valores a 
seguir: 
 
LINHA COMANDOS REPETIÇÃO aux numero fatorial 
1 1 e 2 - - 5 1 
2 3 e 4 1 1 5 1 
3 3 e 4 2 2 5 2 
4 3 e 4 3 3 5 6 
5 3 e 4 4 4 5 24 
6 3 e 4 5 5 5 120 
7 5 - - 5 120 
 
Linha 1: execução dos comandos iniciais do algoritmo, antes do comando PARA: 
- atribuição do valor 1 a variável fatorial; 
- leitura do valor 5, informado pelo usuário, que será armazenado na variável numero. 
 
Linha 2: primeira repetição do comando PARA: 
-a variável auxiliar aux recebe o valor 1; 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 70 
-a expressão aritmética fatorial * aux é executada (1 x 1), e seu resultado (1) é 
atribuído a variável fatorial (que perde seu valor anterior). 
 
Linha 3: segunda repetição do comando PARA: 
-a variável auxiliar aux é incrementada em 1 e passa a valer 2; 
-a expressão aritmética fatorial * aux é executada (1 x 2), e seu resultado (2) é 
atribuído a variável fatorial (que perde seu valor anterior). 
 
Linha 4: terceira repetição do comando PARA: 
-a variável auxiliar aux é incrementada em 1 e passa a valer 3; 
-a expressão aritmética fatorial * aux é executada (2 x 3), e seu resultado (6) é 
atribuído a variável fatorial (que perde seu valor anterior). 
 
Linha 5: quarta repetição do comando PARA: 
-a variável auxiliar aux é incrementada em 1 e passa a valer 4; 
-a expressão aritmética fatorial * aux é executada (6 x 4), e seu resultado (24) é 
atribuído a variável fatorial (que perde seu valor anterior). 
 
Linha 6: quinta (e última) repetição do comando PARA: 
-a variável auxiliar aux é incrementada em 1 e passa a valer 5; 
-a expressão aritmética fatorial * aux é executada (24 x 5), e seu resultado (120) é 
atribuído a variável fatorial (que perde seu valor anterior). 
 
Linha 7: execução dos comandos finais do algoritmo, depois do PARA: 
-impressão da mensagem Fatorial de 5 = 120 pelo comando ESCREVAL. 
 
 
7.4 - Uso de CONTADORES dentro das estruturas de repetição 
 
Uma das aplicações mais implementadas na informática são as que envolvem dados e 
resultados estatísticos, quando uma grande massa de dados, pesquisadas em cima de uma 
população qualquer, deve ser processada e várias informações precisam ser obtidas. 
 
Em muitas situações precisamos saber a quantidade de ocorrências de determinadas 
características específicas em uma série de dados pesquisados. Para isto o uso de 
programas de computador se torna uma forma rápida e eficiente forma de se obter estas 
informações. 
 
Os contadores são variáveis, do tipo INTEIRO, criadas dentro do algoritmo com o objetivo de 
contar a ocorrência de alguma situação especial durante a repetição de um processo de 
leitura de dados. 
 
Em uma estrutura de repetição, sempre que a situação especial pesquisada aparecer, a 
variável criada para contar é incrementada em 1. Para incrementar o valor de uma variável de 
utiliza-se o seguinte comando: 
 
contador <- contador + 1 
 
Quando este comando é executado, o computador resolve a expressão aritmética contador+ 1 (soma do conteúdo da variável contador e 1) e o resultado é atribuído a própria 
variável contador, ou seja, a variável contador é incrementada de 1. 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 71 
 
Nos exemplos a seguir, as linhas de comando sombreadas de cinza são os momentos dentro 
do algoritmo onde o contador é referenciado, de acordo com a seguinte legenda: 
 
1) Toda variável que faz contagem (contador) é do tipo inteiro; 
2) Todo contador deve ser inicializado (normalmente zerado) antes da estrutura de 
repetição; 
3) Todo contador é incrementado em 1 dentro da estrutura de repetição (contador <- 
contador + 1), e normalmente dentro de uma estrutura condicional; 
4) Se o algoritmo for imprimir na tela o valor do contador, o comando de impressão deve vir 
depois da estrutura de repetição. 
 
Exemplo 1: 
 
Faça um algoritmo que calcule e imprima a quantidade de números pares informados pelo 
usuário, em cima de uma sequência de 5 números informados por ele. 
 
Algoritmo "NúmerosPares" 
var 
 aux, 
 CONT, (1) 
 numero : inteiro 
inicio 
 CONT <- 0 (2) 
 para aux de 1 ate 5 faca 
 escreva("Digite um número inteiro: ") 
 leia(numero) 
 se numero % 2 = 0 entao 
 CONT <- CONT + 1 (3) 
 fimse 
 fimpara 
 escreval("A quantidade de números pares é ",CONT) (4) 
fimalgoritmo 
 
No exemplo, teremos 5 repetições e em cada repetição o usuário digitará um número inteiro. 
Logo após a digitação do número, ainda dentro da mesma repetição, o programa irá verificar, 
no comando SE, se o valor digitado, quando dividido de forma inteira por 2, dá resto zero 
(numero % 2 = 0). Se a condição do SE for VERDADEIRA, ou seja, número é divisível por 
2 (um número é par quando ele é divisível por 2) o conteúdo da variável cont é 
incrementado em 1. Ao término das repetições, depois do fimpara, a variável cont é 
impressa, sendo impresso na tela do computador quantos números, dos 5 informados pelo 
usuário, são pares (divisíveis por 2). 
 
Importante: Todas as variáveis que sofrem incrementos de valores, nelas mesmas, dentro de 
estruturas de repetição, tem que ser inicializadas (por exemplo: zeradas) antes da estrutura 
de repetição, para que no primeiro incremento, primeira repetição, ela tenha um valor inicial. 
 
Exemplo 2: 
 
Faça um algoritmo que leia o nome e sexo (M para masculino e F para feminino) de um grupo 
de 100 pessoas e ao final imprima a quantidade de mulheres deste grupo. 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 72 
 
Algoritmo "CalcQtdeMulheres" 
var 
 aux, 
 CONTADOR : inteiro (1) 
 nome, 
 sexo : caracter 
inicio 
 CONTADOR <- 0 (2) 
 para aux de 1 ate 100 faca 
 escreva("Nome : ") 
 leia(nome) 
 escreva("Sexo (M ou F) : ") 
 leia(sexo) 
 se sexo = "F" entao 
 CONTADOR <- CONTADOR + 1 (3) 
 fimse 
 fimpara 
 escreval("Quantidade de mulheres = ",CONTADOR) (4) 
fimalgoritmo 
 
No exemplo, a variável contador será incrementada em 1 em todas as repetições que o 
usuário digitar a letra F quando for solicitado a informar o sexo da pessoa. 
 
Importante: Reforçando o que já foi informado anteriormente, em um algoritmo, quando de 
uma expressão booleana, quando um valor fixo é comparado a uma variável do tipo caracter, 
ele tem que estar entre parêntesis (exemplo: sexo = “F”). 
 
Exemplo 3: 
 
Faça um algoritmo que calcule, entre 5 números informados pelo usuário, a quantidade de 
números que estejam compreendidos entre 10 e 100 e a quantidade de números 
negativos. 
 
Algoritmo "ContagemNúmeros" 
var 
 aux, 
 numero, 
 CONT1, (1) 
 CONT2 : inteiro (1) 
inicio 
 CONT1 <- 0 (2) 
 CONT2 <- 0 (2) 
 para aux de 1 ate 5 faca 
 escreva("Informe um número: ") 
 leia(numero) 
 se (numero >= 10) e (numero <= 100) entao 
 CONT1 <- CONT1 + 1 (3) 
 fimse 
 se numero < 0 entao 
 CONT2 <- CONT2 + 1 (3) 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 73 
 fimse 
 fimpara 
 escreval("A quantidade de números entre 10 e 100 = ",CONT1) (4) 
 escreval("A quantidade de números NEGATIVOS = ",CONT2) (4) 
fimalgoritmo 
 
No exemplo, são utilizados dois contadores, um, a variável cont1, para contar quantos 
números, dos informados pelo usuário, estão dentro do intervalo de 10 a 100, e outro, a 
variável cont2, para contar quantos números informados pelo usuário são negativos. 
 
 
7.5 - Uso de SOMATÓRIOS dentro das estruturas de repetição 
 
Em muitas situações do cotidiano enfrentamos situações onde há necessidade de se fazer 
soma (ou somatórios) de determinado conjunto de valores numéricos. Por exemplo, quando 
vamos ao supermercado, ao passarmos as mercadorias de nosso carrinho de compras no 
caixa, o preço de cada mercadoria é somado ao valor final que pagaremos pelas compras 
(somatório dos preços unitários de cada mercadoria). Outro exemplo: você quer saber a 
média das idades dos funcionários de uma determinada empresa, para isso, é necessário 
você fazer a soma (ou somatório) das idades de todas as pessoas, para depois calcular a 
média. 
 
Na programação utilizamos uma variável (INTEIRO ou REAL) criada com este objetivo: 
calcular o somatório de alguma variável numérica. Estas são chamadas de somatórios. Elas 
são incrementadas por uma outra variável (INTEIRO ou REAL), que representa o valor 
numérico que precisamos somar. Geralmente é utilizada uma variável lida dentro do processo 
de repetição. 
 
Importante: O tipo a ser declarado da variável de somatório é baseado no tipo da variável a 
ser somada. Se esta for inteiro, a variável de somatório será inteiro, se esta for real, a variável 
somatório será real. 
 
Para fazer o somatório do valor de uma variável utiliza-se o seguinte comando: 
 
soma <- soma + variável 
 
Quando este comando é executado, o computador resolve a expressão aritmética soma + 
variável (soma do conteúdo da variável soma e conteúdo de variável) e o resultado é 
atribuído a própria variável soma. 
 
Nos exemplos a seguir, as linhas de comando sombreadas de cinza são os momentos dentro 
do algoritmo onde o somatório é referenciado, de acordo com a seguinte legenda: 
 
1) Uma variável que faz soma (somatório) pode ser do tipo inteiro ou real, depende do tipo 
da variável que irá somar; 
2) Todo somatório deve ser inicializado (normalmente zerado) antes da estrutura de 
repetição; 
3) O somatório sempre acontece dentro da estrutura de repetição (somatório <- somatório + 
variável); 
4) Se o algoritmo for imprimir na tela o valor do somatório, o comando de impressão deve vir 
depois da estrutura de repetição. 
 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 74 
Exemplo 1: 
 
Fazer um algoritmo que calcule e imprima o somatório de 5 números inteiros informados pelo 
usuário. 
 
Algoritmo "SomaNúmeros" 
var 
 aux : inteiro 
 numero, 
 soma : real (1) 
inicio 
 soma <- 0 (2) 
 para aux de 1 ate 5 faca 
 escreva("Digite um número: ") 
 leia(numero) 
 soma <- soma + numero (3) 
 fimpara 
 escreval("A soma foi de ",soma) (4) 
fimalgoritmo 
 
No exemplo, teremos 5 repetições e em cada repetição o usuário digitará um número. Logo 
após, ainda dentro da mesma repetição, a expressão aritmética soma + numero é 
executada, e seu resultado é atribuído a variável soma (que perde seu valor anterior). Ao 
término das repetições, depois do fimpara, a variável soma é impressa na tela do 
computador, ou seja, a soma de todos os 5 números digitados pelo usuário é informada ao 
usuário. 
 
Exemplo 2: 
 
Fazer um algoritmo para ler as idades de 55 alunos de uma turma, e calcular e imprimir a 
média das idades do grupo. 
 
Algoritmo "MédiaIdades" 
var 
 aux, 
 idade, 
 soma : inteiro (1) 
 media : real 
inicio 
 soma <- 0 (2) 
 para aux de 1 ate 55faca 
 escreva("Informe a idade do aluno: ") 
 leia(idade) 
 soma <- soma +idade (3) 
 fimpara 
 media <- soma / 55 (4) 
 escreval("A média das idades é ",media) 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 75 
fimalgoritmo 
 
No exemplo, depois do somatório feito dentro do comando PARA, após o fimpara, é 
calculada a média das idades, que se obtém dividindo-se a soma das idades pela quantidade 
de alunos (55). 
 
Importante: Cálculo de média sempre deve acontecer após a estrutura de repetição, e não 
dentro dela, pois o somatório precisa ser finalizado para o cálculo da média ser feito 
corretamente. 
 
Exemplo 3: 
 
Fazer um algoritmo para ler o sexo (M para masculino e F para feminino) e o salário de todos 
os 1500 funcionários de uma empresa, e calcular e imprimir a média salarial dos homens e 
das mulheres. 
 
Algoritmo "MédiaSalarial" 
var 
 aux, 
 contM, 
 contF : inteiro 
 sexo : caracter 
 salario, 
 somaM, 
 somaF, 
 mediaM, 
 mediaF : real 
inicio 
 somaM <- 0 
 contM <- 0 
 somaF <- 0 
 contF <- 0 
 para aux de 1 ate 1500 faca 
 escreva("Informe o sexo (M ou F) do funcionário: ") 
 leia(sexo) 
 escreva("Informe o salário do funcionário: ") 
 leia(salario) 
 se sexo = "M" entao 
 somam <- somaM + salario 
 contM <- contM + 1 
 fimse 
 se sexo = "F" entao 
 somaF <- somaF + salario 
 contF <- contF + 1 
 fimse 
 fimpara 
 mediam <- somam / contM 
 escreval("A média salarial dos homens é ",mediaM) 
 mediaF <- soma / contF 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 76 
 escreval("A média salarial das mulheres é ",mediaF) 
fimalgoritmo 
 
Neste último exemplo, foi necessário criar duas variáveis contadoras (cont1 e cont2) pois, 
apesar da empresa ter 1500 funcionários, foi necessário contar quantos homens e quantas 
mulheres haviam, para se calcular a média salarial de cada sexo separadamente. Também foi 
necessário criar duas variáveis de somatório (soma1 e soma2) para fazer o somatório dos 
salários de cada sexo em variáveis diferentes. As duas variáveis de média (media1 e 
media2) também foram necessárias em virtude das médias separadas que necessitavam ser 
calculadas. Por fim, tanto os somatórios, quanto os contadores, foram colocados dentro do 
comando SE, pois precisavam ser executados condicionalmente, dependendo do sexo do 
funcionário. 
 
 
7.6 - Séries Matemáticas 
 
Uma outra aplicação muito utilizada na informática, ligada a área das ciências exatas, é o 
cálculo computadorizado de séries matemáticas, que resultam em constantes matemáticas 
utilizadas em fórmulas, como o valor de  . 
 
Uma série matemática é uma fórmula utilizada para se obter o valor de alguma constante na 
matemática através da operação (soma, multiplicação, etc.) de vários termos finitos ou não. 
 
Serie = Termo 1 + Termo 2 + Termo 3 + Termo 4 + ... 
Serie = Termo 1 x Termo 2 x Termo 3 x Termo 4 x ... 
 
Uma fórmula só pode ser considerada série quando os termos evoluem de uma forma lógica, 
ou seja, o termo 3 será obtido analisando-se a lógica de variação do termo 1 para o termo 2. 
Descoberta esta lógica, ela deverá ser aplicada aos demais termos da série. 
 
Exemplos de série: 
 
Serie1 = 1/2 + 3/4 + 5/6 + 7/8 + ... 
Serie2 = 1 + 1 + 2 + 3 + 5 + 8 + 13 + 21 + ... 
 
A Série1 tem o primeiro termo igual a 1/2, o segundo termo igual a 3/4, o terceiro termo igual 
a 5/6, e o quarto termo igual a 7/8. Já o quinto termo, que não está explícito na fórmula (uso 
de reticências no fim da fórmula), será igual a 9/10, ou seja, os numeradores dos termos são 
os números ímpares na sequência iniciando em 1, e os denominadores são os números pares 
na sequência iniciando em 2. Variação totalmente lógica. 
 
A Serie2 é bastante famosa, utilizada inclusive na agricultura, de nome Fibonacci. A lógica de 
variação dos termos é: o valor do termo é a soma dos valores dos dois termos anteriores, ou 
seja, o termo 3 = 1 + 1 = 2, o termo 4 = 1 + 2 = 3, o termo 5 = 2 + 3 = 5, o termo 6 = 3 + 5 = 8, 
o termo 7 = 5 + 8 = 13, o termo 8 = 8 + 13 = 21, e o próximo termo, termo 9, que está implícito 
na fórmula (uso de reticências no fim), é 34 (13 + 21). Variação totalmente lógica. 
 
Podemos fazer algoritmos para determinar o valor exato (série finita) ou aproximado (série 
infinita) de uma série, através da geração automática dos seus vários termos. Quando de uma 
série infinita, quanto mais termos gerados, mais preciso é o valor da série calculado pelo 
algoritmo. 
 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 77 
Nos algoritmos utiliza-se uma estrutura de repetição para ir gerando os termos da série. A 
variável auxiliar da estrutura de repetição normalmente é utilizada para compor os termos da 
série. A série vai recebendo os seus valores como num somatório: 
 
Serie = Serie + Termo N 
 
 
Exemplos (séries finitas): 
 
 
 
 
 
 
 
 
 
 
A SerieA tem 50 termos. O uso de reticências no meio da fórmula informa que vários termos 
estão implícitos na série, e, apesar de não serem mostrados todos os termos, o numerador 
dos termos da série começa com o valor 1, varia de 1 em 1, até o valor 50, ou seja, 50 valores 
diferentes = 50 termos. O quinto termo, implícito na fórmula, vale 5/46, o próximo 6/45, e 
assim por diante. 
 
O mesmo raciocínio lógico deve ser utilizado na SerieB, em relação ao denominador, para 
determinarmos que ela tem 37 termos. O quarto termo, implícito na fórmula, vale 34x35/4, o 
próximo 33x34/5, e assim por diante. 
 
As fórmulas utilizadas nas SerieA e SerieB utilizam o somatório dos termos para calcular o 
valor final das séries. 
 
Já a série que calcula o fatorial de 5 é muito simples, pois começa com o valor 1, e vai, de 1 
em 1, até o valor 5, e utiliza a multiplicação entre os termos para calcular o valor final da série. 
 
 
Exemplos (séries finitas): 
 
 
 
 
 
 
 
 
 
 
 
Como as reticências das séries listadas estão no final da fórmula, as mesmas são 
consideradas infinitas. 
 
O próximo termo da SerieC é 58/16. A lógica de variação do numerador do termo é o 
quadrado dos números inteiros, começando-se de 1: 12=1, 22=4, 32=9, 42=16, 52=25, 62=36, 
72=49, 82=56 e assim por diante. O denominador são os números pares começando-se de 2, 
1
50
2
49
3
48
...
47
4
48
3
49
2
50
1
SerieA
37
21
36
32
...
3
3635
2
3736
1
3837 xxxxx
SerieB 
54321)5( xxxxFatorial 
...
14
49
12
36
10
25
8
16
6
9
4
4
2
1
SerieC
...
425
5
316
4
29
3
14
2
01
1










SerieD
...)
13
1
11
1
9
1
7
1
5
1
3
1
1(4 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 78 
ou a multiplicação dos números inteiros, começando-se de 1, por 2: 1x2=2, 2x2=4, 3x2=6, 
4x2=8, 5x2=10, 6x2=12, 7x2=14, 8x2=16 e assim por diante. 
 
O próximo termo da SerieD é 6/36+5 com variação lógica muito parecida com a SerieC. 
 
As fórmulas utilizadas nas SerieC e SerieD utilizam o somatório dos termos para calcular o 
valor final das séries. 
 
A fórmula utilizada na série para se calcular o valor de  difere um pouco das fórmulas das 
séries comentadas até o momento, pois utiliza os operadores de soma e subtração, de forma 
alternada, para calcular o valor da série, e também multiplica por 4 o valor final calculado dos 
termos da série. O próximo termo da serie, que está implícito, é 1/15. 
 
 
Calculando uma série 
 
Para se calcular uma série, utilizando um algoritmo, devem ser criados comandos que 
implementem a seguinte lógica (utilizando como exemplo a SerieA): 
 
 
 
 
 
SerieA = 0 (Inicialização) 
SerieA = SerieA + 1/50 (1a. repetição) 
SerieA = SerieA + 2/49 (2a. repetição) 
SerieA = SerieA + 3/48 (3a. repetição) 
SerieA = SerieA + 4/47 (4a. repetição) 
... 
SerieA = SerieA + 48/3 (48a. repetição) 
SerieA = SerieA + 49/2 (49a. repetição) 
SerieA = SerieA + 50/1 (50a. repetição) 
 
O modelo de algoritmo a seguir implementa esta sequêncialógica: 
 
Algoritmo "ModeloSerie" 
var 
 aux : inteiro 
 num, 
 den, 
 serie : real 
inicio 
 serie <- 0 
 para aux de 1 ate ? faca 
 num <-? 
 den <-? 
 serie <- serie + num / den 
 fimpara 
 [serie <- ?] //Opcional 
 escreval("Valor da série = ",serie) 
fimalgoritmo 
 
1
50
2
49
3
48
...
47
4
48
3
49
2
50
1
SerieA
Programação de Computadores–Prof. Ricardo Luiz de Freitas 79 
No modelo, as interrogações deverão ser substituídas por valores numéricos ou expressões 
aritméticas de acordo com o contexto da fórmula que implementa a série. A primeira 
interrogação, no cabeçalho do comando PARA, deverá ser substituída pelo número de termos 
da série. As duas interrogações dentro do comando PARA serão substituídas por valores 
numéricos ou expressões aritméticas que implementem a lógica de variação dos termos, 
podendo utilizar a variável auxiliar aux do comando PARA em sua composição. A 
interrogação depois do comando PARA será substituída, opcionalmente, por uma expressão 
aritmética, para aplicar um cálculo sobre a própria variável serie, como a multiplicação por 4 
no final da serie  . 
 
No algoritmo seguinte é utilizado o modelo para se implementar a SerieA: 
 
Algoritmo "SerieA" 
var 
 aux : inteiro 
 num, 
 den, 
 serie : real 
inicio 
 serie <- 0 
 para aux de 1 ate 50 faca 
 num <- aux 
 den <- 51 - aux 
 serie <- serie + num / den 
 fimpara 
 escreval("Valor da série = ",serie) 
fimalgoritmo 
 
A serie a seguir tem seu algoritmo mostrado na sequência: 
 
 
 
 
 
Para testar (1000 termos): Valor da Série = 100.001049593097 
 
Algoritmo "SerieExemplo" 
var 
 aux, 
 termos : inteiro 
 num, 
 den, 
 serie : real 
inicio 
 serie <- 0 
 escreva("Informe quantidade de termos da série: ") 
 leia(termos) 
 para aux de 1 ate termos faca 
 num <-1 
 den <-aux ^ 2 + 10 ^ aux 
 serie <- serie + num / den 
 fimpara 
 serie <- 100 + serie ^ 3 
3...)
1000016
1
10009
1
1004
1
101
1
(100 







loSerieExemp
Programação de Computadores–Prof. Ricardo Luiz de Freitas 80 
 escreval("Valor da série = ",serie) 
fimalgoritmo 
 
Observe neste exemplo que o numerador da série é fixo em 1, e o denominador são os 
valores da variável auxiliar aux do comando PARA elevador ao quadrado somado ao valor 10 
elevado aos valores da variável auxiliar. Como é uma série infinita (reticências ao fim da 
sequência de termos) devemos solicitar ao usuário, antes do comando PARA, a quantidade 
de termos que deverão ser calculados. Depois do comando PARA, ainda temos que elevar a 
3 o somatório da série obtido aos longo das repetições e o resultado somar a 100. 
 
Como todas as séries, quando resolvidas, chegam a um resultado numérico, dependendo da 
quantidade de termos gerados, podemos testar facilmente nosso algoritmo, comparando o 
seu resultado final com o valor real da série. Para a SerieExemplo o algoritmo tem que dar 
como resultado 100.001049593097, para 100 termos. 
 
 
7.7 - Exercícios Resolvidos 
 
Exercício 1: 
 
Faça um algoritmo que solicite ao usuário um número inteiro de 1 a 9, e calcule e imprima a 
tabuada deste número, conforme mostrado a seguir: 
 
Exemplo (número informado = 3): 
 1 x 3 = 3 
 2 x 3 = 6 
 3 x 3 = 9 
 4 x 3 = 12 
 5 x 3 = 15 
 6 x 3 = 18 
 7 x 3 = 21 
 8 x 3 = 24 
 9 x 3 = 27 
 
Solução no VisuAlg: 
 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 81 
 
 
 
Exercício 2: 
 
Fazer um algoritmo para ler o nome e a idade de todos os 50 alunos de uma turma e calcular 
e imprimir: 
 
a) Quantos alunos têm até 12 anos; 
b) Quantos alunos têm acima de 30 anos; 
c) A média das idades informadas; 
d) O nome do aluno de maior idade. 
 
Para testar (5 alunos): 
 Pedro/24 Ana/9 Rui/12 Maria/51 João/28 
 Alunos até 12 anos = 2 Média das idades = 24.8 
 Alunos acima de 30 anos = 1 Aluno de maior idade = Maria 
 
Solução no VisuAlg: 
 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 82 
 
 
 
Exercício 3: 
 
Faça um algoritmo para calcular e imprimir o valor da série a seguir. A quantidade de termos a 
ser gerada será informada pelo usuário no início do algoritmo. 
 
 
 
 
Para testar (10 termos): 
Valor da Série = 35.2925715158306 
 
Solução no VisuAlg: 
 
...)
25
126
19
94
13
62
7
30
(5 







Serie
Programação de Computadores–Prof. Ricardo Luiz de Freitas 83 
 
 
 
7.8 - Síntese 
 
Neste capítulo você aprendeu o que são as estruturas de repetição, conheceu três comandos 
que implementam estas estruturas (PARA, REPITA e ENQUANTO), aprendeu em detalhes o 
comando PARA, a utilizar contadores e somatórios dentro de uma estrutura de repetição, e 
uma aplicação importante ao implementarmos cálculos de séries matemáticas utilizando 
algoritmos. Seus algoritmos agora poderão ler e processar grandes massas de dados, 
gerando resultados importantíssimos do dia a dia. 
 
No próximo capítulo você terá contato e aprenderá a utilizar os outros comandos de repetição 
(REPITA e ENQUANTO), permitindo que seus algoritmos passem a trabalhar com repetições 
indefinidas, onde não se conhece previamente a quantidade de repetições. 
 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 84 
8 - Estruturas de repetição (quantidade indefinida de repetições) 
 
No capítulo anterior, foi ensinado detalhadamente o uso do comando PARA, que tem como 
objetivo principal executar repetidas vezes um conjunto de comandos dentro de um algoritmo, 
porém este comando só deve ser utilizado quando se sabe previamente a quantidade de 
repetições, conforme as situações a seguir: 
 
Situação 1 (50 repetições): 
Fornecido a idade de cada um dos 50 alunos de uma sala de aula, calcular a média das 
idades dos alunos da sala. 
 
Situação 2 (858 repetições): 
Fornecidas as populações feminina e masculina, de cada um dos 858 municípios mineiros, 
pesquisar quais aqueles em que a população feminina ultrapassa a população masculina. 
 
Situação 3 (12 repetições): 
Fornecidas as maiores temperaturas de cada mês do ano de 2014, verificar o mês que teve a 
maior temperatura. 
 
Em muitas situações, esta quantidade de repetições é indefinida, conforme as situações a 
seguir: 
 
Situação 1: 
Apurar, na porta de entrada de uma escola, durante toda a manhã, quantos alunos residem 
fora da cidade. 
 
Situação 2: 
Colher e apurar os votos para prefeito e vereador de todos os eleitores de uma determinada 
seção eleitoral. 
 
Situação 3: 
Pesquisar os nomes e as idades de todos os juízes que atuam em um fórum, e determinar a 
média das idades dos mesmos, e os nomes do mais velho e do mais novo. 
 
Nestes casos, deve-se utilizar dentro do algoritmo os comandos ENQUANTO ou REPITA, que 
têm os mesmos objetivos de utilização do PARA, repetir diversas vezes um conjunto de 
comandos, porém devem ser utilizados quando NÃO se sabe quantas repetições deverão ser 
feitas. 
 
 
8.1 - Comando ENQUANTO 
 
O comando enquanto...faca caracteriza-se por utilizar uma condição (expressão 
booleana) contida no início (cabeçalho) do comando, que deve ser verificada antes de se 
iniciar, ou continuar, a repetição. 
 
Se a condição for VERDADEIRA, os comandos contidos dentro da estrutura do loop serão 
executados repetidamente enquanto a condição permanecer VERDADEIRA. Quando a 
condição se tornar FALSA os comandos que estão dentro do loop não serão mais 
executados, a repetição é encerrada, e o programa segue executando os comandos listados 
após a repetição, ou seja, fora do loop. 
 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 85 
Importante: Se a condição for FALSA desde a primeira verificação, os comandos não serão 
executados nenhuma vez. Fique atento a isto! 
 
Sintaxe: 
 
enquanto condição faca 
 comando1 
 comando2 
 comandon 
fimenquanto 
 
Fluxo: 
comando 
comando 
enquanto condição faca 
 comando1 
 comando2 
 ... 
 comandon 
fimenquanto 
comando 
comando 
 
 
 
comandocomando 
enquanto condição faca 
 comando1 
 comando2 
 ... 
 comandon 
fimenquanto 
comando 
comando 
 
 
Exemplo 1: 
 
O algoritmo a seguir imprime na tela do computador os números inteiros de 1 a 5. 
 
Algoritmo "ExemploRepeticaoEnquanto1" 
var 
 contador: inteiro 
inicio 
 contador <- 0 (1) 
 enquanto contador < 5 faca (2) 
 contador <- contador + 1 (3) 
 escreval(contador) (4) 
 fimenquanto 
fimalgoritmo 
Condição VERDADEIRA: 
os comandos dentro do 
ENQUANTO serão 
executados 
Condição FALSA: 
os comandos dentro do 
ENQUANTO NÃO serão 
executados 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 86 
 
Vamos analisar este algoritmo, passo a passo, seguindo as linhas da tabela de valores a 
seguir: 
 
LINHA COMANDOS REPETIÇÃO contador Impressão 
1 1 - 0 - 
2 2, 3 e 4 1 1 1 
3 2, 3 e 4 2 2 2 
4 2, 3 e 4 3 3 3 
5 2, 3 e 4 4 4 4 
6 2, 3 e 4 5 5 5 
 
Linha 1: execução dos comandos iniciais do algoritmo, antes do comando ENQUANTO: 
- atribuição do valor 0 a variável contador; 
 
Linha 2: primeira repetição do comando ENQUANTO: 
- a condição contador < 5 é VERDADEIRA pois a variável contador tem o valor 0, com 
isso a primeira repetição acontece; 
- a variável contador é incrementada em 1 e passa a valer 1; 
- impressão do conteúdo da variável contador pelo comando ESCREVAL. 
 
Linha 3: segunda repetição do comando ENQUANTO: 
- a condição contador < 5 é VERDADEIRA pois a variável contador tem o valor 1, com 
isso uma nova repetição acontece; 
- a variável contador é incrementada em 1 e passa a valer 2; 
- impressão do conteúdo da variável contador pelo comando ESCREVAL. 
 
Linha 4: terceira repetição do comando ENQUANTO: 
- a condição contador < 5 é VERDADEIRA pois a variável contador tem o valor 2, com 
isso uma nova repetição acontece; 
- a variável contador é incrementada em 1 e passa a valer 3; 
- impressão do conteúdo da variável contador pelo comando ESCREVAL. 
 
Linha 5: quarta repetição do comando ENQUANTO: 
- a condição contador < 5 é VERDADEIRA pois a variável contador tem o valor 3, com 
isso uma nova repetição acontece; 
- a variável contador é incrementada em 1 e passa a valer 4; 
- impressão do conteúdo da variável contador pelo comando ESCREVAL. 
 
Linha 6: quinta (e última) repetição do comando ENQUANTO: 
- a condição contador < 5 é VERDADEIRA pois a variável contador tem o valor 4, com 
isso uma nova repetição acontece; 
- a variável contador é incrementada em 1 e passa a valer 5; 
- impressão do conteúdo da variável contador pelo comando ESCREVAL. 
 
Linha 6: fim da repetição do comando ENQUANTO: 
- a condição contador < 5 é FALSA pois a variável contador tem o valor 5, com isso as 
repetições são interrompidas e o algoritmo continua sendo executado com os comandos 
listados após o fimenquanto; 
 
 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 87 
Exemplo 2: 
 
Faça um algoritmo que solicite a altura e a largura de um retângulo, depois calcule e imprima 
a sua área. Em seguida, por 5 vezes, incrementar o valor 2 na altura e decrementar o valor 1 
na largura, e em cada uma das vezes calcular e imprimir novamente a área do retângulo. 
 
Algoritmo "ExemploRepeticaoEnquanto2" 
var 
 cont, 
 area, 
 altura, 
 largura: inteiro 
inicio 
 escreval("Informe altura: ") 
 leia(altura) 
 escreval("Informe largura: ") 
 leia(largura) 
 cont <- 0 
 enquanto cont <= 5 faca 
 area <- altura * largura 
 escreval("A área é: ",area) 
 cont <- cont + 1 
 altura <- altura + 2 
 largura <- largura - 1 
 fimenquanto 
fimalgoritmo 
 
Veja que no exemplo os valores iniciais da altura e da largura são solicitados uma única 
vez, pois estão antes (fora) do comando ENQUANTO. As repetições do ENQUANTO estão 
sendo utilizadas para calcular e imprimir a área do retângulo original, e, depois, dos 5 
retângulos seguintes cujas altura e largura estão sendo geradas novamente. Quando 
cont atingir o valor 6, apesar de novas altura e largura terem sido geradas, a repetição 
(ou loop) é interrompida e não é mais calculada e impressa nova area. 
 
 
Exemplo 3: 
 
Faça um algoritmo que solicite ao usuário uma série de números inteiros, e imprima as 
mensagens “NUMERO PAR” ou “NÚMERO ÍMPAR” dependendo da condição do número lido. 
A repetição deverá ser encerrada quando o usuário digitar o valor 0(zero). Ao fim do algoritmo 
deverá ser impressa na tela a quantidade de números informados, e a quantidade de números 
pares. 
 
Algoritmo "ExemploRepeticaoEnquanto3" 
var 
 cont, 
 contPar, 
 numero : inteiro 
inicio 
 cont <- 0 
 contPar <- 0 
 escreval("Informe um número inteiro: ") 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 88 
 leia(numero) 
 enquanto numero <> 0 faca 
 cont <- cont + 1 
 se numero div 2 = 0 entao 
 escreval("NÚMERO PAR") 
 contPar <- contPar + 1 
 senao 
 escreval("NÚMERO ÍMPAR") 
 fimse 
 escreval 
 escreval("Informe um número inteiro: ") 
 leia(numero) 
 fimenquanto 
 escreval("A quantidade de números informados foi ",cont) 
 escreval("A quantidade de números PARES informados foi ",contPar) 
fimalgoritmo 
 
Este exemplo é importante pois ele utiliza como condição de parada do ENQUANTO o valor 
(ou variável) da entrada de dados, ou seja, dependendo do valor informado pelo usuário na 
variável numero, a repetição não se inicia ou mesmo é interrompida. Veja que foi necessário 
utilizar a dupla escreva/leia, para a leitura do número, fora (antes) e dentro (no fim) do 
ENQUANTO. A primeira utilização, fora (antes) do ENQUANTO, é necessária para solicitar ao 
usuário o primeiro número e iniciar as repetições, porém, se o usuário digitar 0(zero) de cara 
nenhuma repetição acontecerá e os contadores ficarão zerados e serão impressos desta 
forma. Ao passo que, se um número diferente de zero for informado pelo usuário, os 
comandos dentro do ENQUANTO serão executados repetidas vezes. A segunda utilização da 
dupla escreva/leia, está dentro do ENQUANTO, imediatamente antes do fimenquanto, 
para solicitar ao usuário um novo número e dar sequência às repetições, ou não. 
 
Importante: No algoritmo anterior, o valor 0(zero), informado pelo usuário, armazenado na 
variável numero, e que foi utilizado para interromper a repetição, é chamado de flag. O flag é 
uma informação chave a ser informada pelo usuário para indicar que não há mais dados a 
serem digitados na entrada de dados. Esta chave indica então que a repetição do comando 
de entrada de dados deve ser encerrada. O flag é útil em situações onde o número de 
informações a ser digitada pelo usuário é variável, ou não previsível, e por isto surge a 
necessidade de se criar uma condição pré-definida e conhecida pelo usuário para encerrar a 
entrada de dados. 
 
 
8.2 - Comando REPITA 
 
O comando repita...ate caracteriza-se por primeiro executar a lista de comandos 
contidos no loop antes de verificar a condição, que é inserida somente no final (rodapé) do 
comando. Após executar os comandos do loop será verificada a condição. Se a condição for 
FALSA, os comandos que estão dentro da estrutura de repetição continuam sendo 
executados. Se a condição for VERDADEIRA, a repetição é encerrada e o programa segue 
executando os demais comandos após o final da repetição, ou seja, fora do loop. 
 
Importante: No comando REPITA pelo menos uma repetição acontece (a primeira), pois a 
condição é verificada somente no fim do comando. Fique atento a isto! 
 
Sintaxe: 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 89 
 
repita 
 comando1 
 comando2 
 comandon 
ate condição 
 
Fluxo: 
comando 
comando 
repita 
 comando1 
 comando2 
 ... 
 comandon 
ate condição 
comando 
comando 
 
 
comando 
comando 
repita 
 comando1 
 comando2 
 ... 
 comandon 
ate condição 
comando 
comando 
 
 
Exemplo 1: 
 
Faça um algoritmo para ler uma série denúmeros inteiros informados pelo usuário e calcular 
e imprimir a soma dos mesmos. O último número a ser informado será igual a 0(zero). 
 
Algoritmo "CalculaSoma" 
var 
 numero, 
 soma : inteiro 
inicio 
 soma <- 0 
 repita 
 escreva("Informe um número: ") 
 leia(numero) 
 soma <- soma + numero 
 ate numero = 0 
 escreval("Soma dos números informados = ",soma) 
fimalgoritmo 
 
Condição FALSA: os 
comandos dentro do 
REPITA serão novamente 
executados 
Condição VERDADEIRA: 
os comandos dentro do 
REPITA deixarão de ser 
executados 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 90 
Inicialmente a variável soma é zerada. Logo após, uma primeira repetição acontece e um 
primeiro valor é solicitado ao usuário, que é armazenado na variável numero. Logo após, este 
valor é acumulado na variável soma. Na sequência acontece o teste da condição do REPITA. 
Se a variável numero for diferente de 0(zero) uma nova repetição acontece e um novo valor é 
informado e acumulado, ao passo que, se a variável numero for igual a 0(zero) a repetição é 
interrompida, e o algoritmo segue depois do ate, imprimindo o valor da variável soma. 
 
 
Exemplo 2: 
 
Faça um algoritmo para ler uma série de números inteiros informados pelo usuário e calcular 
e imprimir a média dos mesmos. O último número a ser informado, e que não deverá entrar 
nos cálculos, será igual a -1. 
 
Importante: Variáveis de somatório e contadores deverão ser inicializadas (normalmente são 
zeradas) antes das estruturas de repetição! 
 
Importante: Cálculo de médias só podem acontecer depois que o somatório tiver sido 
finalizado, por isso este cálculo só pode acontecer após a estrutura de repetição! 
 
Versão 1 (incorreta): 
 
Algoritmo "CalculaMédia" 
var 
 numero, 
 soma, 
 cont : inteiro 
 media : real 
inicio 
 soma <- 0 
 cont <- 0 
 repita 
 escreva("Informe um número: ") 
 leia(numero) 
 soma <- soma + numero 
 cont <- cont + 1 
 ate numero = -1 
 media <- soma / cont 
escreval("Média dos números informados = ",media) 
fimalgoritmo 
 
Neste algoritmo, para o cálculo da média dos números, como não se sabe a quantidade de 
números que serão somados, utilizou-se um contador para contar quantos números serão 
somados. Porém, pelo enunciado do problema, o valor -1, a ser digitado pelo usuário, 
interromperá a repetição e não deverá entrar nos cálculos (ser somado e contado), mas nesta 
versão do algoritmo ele está entrando nos cálculos, como os outros números, e interferindo no 
valor final da média. A versão seguinte do algoritmo resolve este problema pois o comando 
SE, depois da leitura do número, exclui o valor -1 dos cálculos internos do REPITA (somatório 
e contagem). 
 
Versão 2 (correta): 
Incorreto! 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 91 
 
Algoritmo "CalculaMédia" 
var 
 numero, 
 soma, 
 cont : inteiro 
 media : real 
inicio 
 soma <- 0 
 cont <- 0 
 repita 
 escreva("Informe um número: ") 
 leia(numero) 
 se numero <> -1 entao 
 soma <- soma + numero 
 cont <- cont + 1 
 fimse 
 ate numero = -1 
 media <- soma / cont 
 escreval("Média dos números informados = ",media) 
fimalgoritmo 
 
Como já dito anteriormente, quando se adota um valor de entrada, que também é informado 
pelo usuário apenas para interromper a repetição, e que normalmente não entra nos cálculos, 
chame-se este valor de flag tornando o uso do comando SE dentro do REPITA obrigatório a 
fim de que o flag não interfira nos cálculos. 
 
 
Exemplo 3: 
 
Faça um algoritmo para calcular e imprimir a soma dos rendimentos familiares de todos os 
alunos de uma sala de aula. Para isto serão digitados os nomes e os rendimentos de todos os 
alunos. O último nome informado, que não deverá ser processado, será igual a ZZZ. 
 
Algoritmo "RendimentoFamiliar" 
var 
 rend, 
 total : real 
 nome : caractere 
inicio 
 total <- 0 
 escreval("Para finalizar digite ZZZ no nome") 
 repita 
 escreva("Informe o nome do aluno: ") 
 leia(nome) 
 se nome <> "ZZZ" entao 
 escreva("Informe o rendimento familiar: ") 
 leia(rend) 
 total <- total + rend 
 fimse 
 ate nome = "ZZZ" 
 escreval("Soma dos rendimentos = ",total) 
fimalgoritmo 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 92 
 
No algoritmo é mostrada uma mensagem, antes das solicitações dos nomes e rendimentos de 
cada aluno, informando que a digitação do texto ZZZ (flag) interromperá a repetição. Observe 
que dentro da estrutura de repetição é utilizado o comando SE depois da leitura do nome do 
aluno para verificar se o flag foi digitado (ZZZ), “pulando” os demais comandos do REPITA, 
indo direto para o teste da condição de parada. 
 
 
8.3 - Comparação entre o PARA, ENQUANTO e REPITA 
 
O PARA deve ser utilizado em situações onde o número de repetições é previamente 
conhecido e não há condições especiais para que estas repetições parem de acontecer, elas 
simplesmente devem ocorrer em uma quantidade de vezes pré-determinada. 
 
O ENQUANTO deve ser utilizado em situações onde os comandos da repetição só devem ser 
executados se a condição da repetição for verdadeira antes de iniciar o loop. As repetições 
(ou loop) continuarão enquanto a condição for verdadeira. 
 
O REPITA deve ser utilizado em situações onde os comandos da repetição devem ser 
executados pelo menos uma vez independente se a condição da repetição é verdadeira ou 
falsa. As repetições (ou loop) continuarão até que a condição seja verdadeira. 
 
Os três quadros a seguir contêm uma mesma lógica escrita com cada um dos três comandos 
de repetição estudados (PARA, ENQUANTO e REPITA) para repetições pré-definidas. Desta 
forma podemos comparar as diferenças de sintaxe entre eles: 
 
Algoritmo "para...faca" 
var 
 area: inteiro 
 altura: inteiro 
 largura: inteiro 
 aux : inteiro 
inicio 
 altura <- 2 
 largura <- 6 
 para aux de 1 ate 5 faca 
 area <- altura * largura 
 escreval("Área = ",area) 
 altura <- altura + 2 
 largura <- largura - 1 
 fimpara 
fimalgoritmo 
Algoritmo "enquanto...faca" 
var 
 area: inteiro 
 altura: inteiro 
 largura: inteiro 
 aux : inteiro 
inicio 
 altura <- 2 
 largura <- 6 
 aux <- 0 
 enquanto aux < 5 faca 
 aux <- aux + 1 
 area <- altura * largura 
 escreval("Área = ",area) 
 altura <- altura + 2 
 largura <- largura - 1 
 fimenquanto 
fimalgoritmo 
Algoritmo "repita...ate" 
var 
 area: inteiro 
 altura: inteiro 
 largura: inteiro 
 aux : inteiro 
inicio 
 altura <- 2 
 largura <- 6 
 aux <- 0 
 repita 
 aux <- aux + 1 
 area <- altura * largura 
 escreval("Área = ",area) 
 altura <- altura + 2 
 largura <- largura - 1 
 ate aux = 5 
fimalgoritmo 
 
Os dois quadros a seguir contêm uma mesma lógica para repetições indefinidas, onde 
devemos utilizar os comandos ENQUANTO ou REPITA: 
 
Algoritmo "enquanto...faca" 
var 
 nome: caracter 
 idade : inteiro 
 cont : inteiro 
 soma : inteiro 
 media : real 
inicio 
 cont <- 0 
 soma <- 0 
 nome <- "" 
Algoritmo "repita...ate" 
var 
 nome: caracter 
 idade : inteiro 
 cont : inteiro 
 soma : inteiro 
 media : real 
inicio 
 cont <- 0 
 soma <- 0 
 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 93 
 enquanto nome <> "Zilma" faca 
 escreval("Informe nome: ") 
 leia(nome) 
 escreval("Informe idade: ") 
 leia(idade) 
 cont <- cont + 1 
 soma <- soma + idade 
 fimenquanto 
 media <- soma / cont 
 escreval("Média das idades = ",media) 
fimalgoritmo 
 repita 
 escreval("Informe nome: ") 
 leia(nome) 
 escreval("Informe idade: ") 
 leia(idade) 
 cont <- cont + 1 
 soma <- soma + idade 
 ate nome = "Zilma" 
 media <- soma / cont 
 escreval("Média das idades = ",media) 
fimalgoritmo 
 
Nos dois quadros anteriores é utilizadoum flag (valor que interromperá a repetição) que será 
a leitura do texto “Zilma” pela variável nome. Este dado é real (Zilma é o nome de uma pessoa 
“de carne e osso”) por isso ele deve entrar nos cálculos, com isto os algoritmos ficam muito 
parecidos, apesar de utilizarem comandos de repetição diferentes (ENQUANTO e REPITA). 
Além dos comandos de repetição diferentes, a única diferença está na inicialização da 
variável nome no primeiro quadro que utiliza o comando ENQUANTO, para que aconteça pelo 
menos uma repetição. 
 
Algoritmo "enquanto...faca" 
var 
 nome: caracter 
 idade : inteiro 
 cont : inteiro 
 soma : inteiro 
 media : real 
inicio 
 cont <- 0 
 soma <- 0 
 escreval("Informe nome: ") 
 leia(nome) 
 enquanto nome <> "fim" faca 
 escreval("Informe idade: ") 
 leia(idade) 
 cont <- cont + 1 
 soma <- soma + idade 
 escreval("Informe nome: ") 
 leia(nome) 
 fimenquanto 
 media <- soma / cont 
 escreval("Média das idades = ",media) 
fimalgoritmo 
Algoritmo "repita...ate" 
var 
 nome: caracter 
 idade : inteiro 
 cont : inteiro 
 soma : inteiro 
 media : real 
inicio 
 cont <- 0 
 soma <- 0 
 repita 
 escreval("Informe nome: ") 
 leia(nome) 
 se nome <> "fim" entao 
 escreval("Informe idade: ") 
 leia(idade) 
 cont <- cont + 1 
 soma <- soma + idade 
 fimse 
 ate nome = "fim" 
 media <- soma / cont 
 escreval("Média das idades = ",media) 
fimalgoritmo 
 
Vejam que nos dois quadros anteriores o flag, que será a leitura do texto “fim” pela variável 
nome, não deve entrar nos cálculos (fim não é nome de uma pessoa e sim um valor fictício), 
por isso os algoritmos contêm diferenças importantes: o comando ENQUANTO necessita da 
leitura da variável nome (que se constitui no flag) antes do comando de repetição 
(imediatamente antes do enquanto) e antes de seu término (imediatamente antes do 
fimenquanto), já o comando REPITA necessita do uso do comando SE imediatamente 
depois da leitura da variável nome. 
 
8.4 - Uso de estrutura de repetição para fazer consistência na entrada de dados 
 
Quando um programa solicita ao usuário que digite um dado, o mesmo digitará o valor que 
bem entender. Entretanto, a maior parte dos dados possuem uma faixa limitada de valores 
válidos. Como por exemplo a idade de uma pessoa. Nenhuma pessoa poderia ter idade 
negativa, assim como também não seria possível uma pessoa ter 200 anos. Desta forma, 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 94 
para evitar que usuários digitem na entrada de dados valores impossíveis ou inválidos, 
devemos validar, ou consistir, a digitação. 
 
A consistência na entrada de dados é uma forma de não aceitar valores impossíveis ou 
inválidos digitados pelo usuário. 
 
Para criar esta consistência, utiliza-se uma estrutura de repetição do tipo abaixo para cada 
dado de entrada a ser consistido no programa: 
 
repita 
 escreva(<solicitação do dado de entrada>) 
 leia(<variável de entrada>) 
 se <variável de entrada> <> <valores válidos> entao 
 escreval("Dado inválido! Digite novamente.") 
 fimse 
ate <variável de entrada> = <valores válidos> 
 
A estrutura de repetição garantirá que o programa seguirá em frente somente após o valor 
digitado ser válido. 
 
Exemplo de lógica de validação com o comando REPITA: 
 
repita 
 escreva("Digite a idade do aluno: ") 
 leia(idade) 
 se (idade < 0) ou (idade > 200) entao 
 escreval("Erro! A idade deve estar entre 0 e 200") 
 fimse 
ate (idade >= 0) e (idade <= 200) 
 
Nesta lógica, o usuário será repetidamente solicitado que digite a idade do aluno até que o 
valor digitado esteja entre 0 e 200. 
 
O comando REPITA é o que melhor se encaixa na lógica de repetição para a consistência já 
que só testa a condição após ter executado todo o conjunto de comandos pelo menos uma 
vez. Entretanto, a lógica também pode ser feita com o comando ENQUANTO: 
 
idade <- 999 
enquanto (idade < 0) ou (idade > 200) faca 
 escreva("Digite o idade do aluno: ") 
 leia(idade) 
 se (idade < 0) ou (idade > 200) entao 
 escreval("Erro! A idade deve estar entre 0 e 200") 
 fimse 
fimenquanto 
 
A desvantagem do ENQUANTO é a necessidade de inicializar a variável que receberá a 
digitação com um valor inválido, caso contrário a condição do enquanto será falsa desde o 
início e não seriam executados os comandos escritos entre o enquanto e o fimenquanto. 
 
 
Exemplo: 
 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 95 
Faça um algoritmo para ler os nomes, idades e os salários recebidos no fim do mês por cada 
um dos 123 funcionários de uma empresa, e calcular e imprimir o valor total que a empresa 
gastará com a folha de pagamento. 
 
Algoritmo "FolhaDePagamento" 
var 
 nome : caractere 
 aux, idade : inteiro 
 salário, total : real 
inicio 
 total <- 0 
 para aux de 1 ate 123 faca 
 escreva("Informe o nome do funcionário: ") 
 leia(nome) 
 repita 
 escreva("Informe a idade do funcionário: ") 
 leia(idade) 
 se (idade < 12) ou (idade > 100) entao 
 escreval("Idade inválida! Digite novamente.") 
 fimse 
 ate (idade >= 12) e (idade < 100) 
 repita 
 escreva("Informe o salário recebido: ") 
 leia(salario) 
 se (salario < 0) ou (salario > 100000) entao 
 escreval("Salário inválido! Digite novamente.") 
 fimse 
 ate (salario >= 0) e (salario <= 100000) 
 total <- total + salario 
 fimpara 
 escreval("Total da folha de pagamento = ",total) 
fimalgoritmo 
 
No exemplo anterior, o primeiro comando REPITA faz a consistência da digitação da idade do 
funcionário pelo usuário, que tem que estar entre 12 e 100. Enquanto ela não estiver dentro 
deste intervalo, o programa não passa para a próxima entrada de dados (salário). O segundo 
comando REPITA faz a consistência da digitação do salário do funcionário, também pelo 
usuário, que tem que estar entre 0 e 100000. Só depois de consistido o salário é que o 
somatório dos salários é executado. 
 
 
8.5 - Uso do comando INTERROMPA para finalizar abruptamente um loop 
 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 96 
Cada um dos comandos que representam as estruturas de repetição tem sua forma de 
interromper suas repetições (loops). O comando PARA tem suas repetições interrompidas 
quando a sua variável auxiliar ultrapassa o parâmetro VALOR FINAL especificado no 
cabeçalho do comando. O comando ENQUANTO interrompe suas repetições quando a 
condição (expressão booleana) colocada no seu cabeçalho se torna FALSA. Já o comando 
REPITA interrompe suas repetições quando a condição (expressão booleana) colocada no 
seu rodapé se torna VERDADEIRA. 
 
Porém, independente da maneira como o comando interrompe a repetição (loop), o algoritmo 
tem executar todos os comandos dentro do comando de repetição para depois verificar, e, se 
for o caso, interromper a repetição (loop). 
 
Uma forma rápida e eficaz de interromper qualquer uma das estruturas (comandos) de 
repetição é utilizar o comando INTERROMPA, colocado dentro de um comando SE, em 
qualquer ponto dentro do comando de repetição, fazendo com que a execução do programa 
prossiga a partir da primeira linha após o final do comando de repetição. 
 
Sintaxe (PARA): 
 
para aux de ? ate ? faca 
 comando1 
 comando2 
 se condição entao 
 interrompa 
 fimse 
 comandon-1 
 comandon 
fimpara 
 
Fluxo: 
comando 
comando 
para aux de ? ate ? faca 
 comando1 
 comando2 
 se condição entao 
 interrompa 
 fimse 
 comandon-1 
 comandon 
fimpara 
comando 
comando 
 
 
Sintaxe (ENQUANTO): 
 
enquanto condição faca 
 comando1 
 comando2 
 se condição entao 
 interrompa 
Condição VERDADEIRA: o comando 
INTERROMPA será executado, as 
repetições serão interrompidas e o 
algoritmo continuará a ser executado a 
partir do primeiro comandodepois do 
fimpara. 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 97 
 fimse 
 comandon-1 
 comandon 
fimenquanto 
 
Fluxo: 
comando 
comando 
enquanto condição faca 
 comando1 
 comando2 
 se condição entao 
 interrompa 
 fimse 
 comandon-1 
 comandon 
fimenquanto 
comando 
comando 
 
 
Sintaxe (REPITA): 
 
repita 
 comando1 
 comando2 
 se condição entao 
 interrompa 
 fimse 
 comandon-1 
 comandon 
ate condição 
 
Fluxo: 
comando 
comando 
repita 
 comando1 
 comando2 
 se condição entao 
 interrompa 
 fimse 
 comandon-1 
 comandon 
ate condição 
comando 
comando 
 
 
Exemplo (PARA): 
 
Condição VERDADEIRA: as 
repetições serão interrompidas e o 
algoritmo continuará a ser executado a 
partir do primeiro comando depois do 
ate 
Condição VERDADEIRA: as 
repetições serão interrompidas e o 
algoritmo continuará a ser executado a 
partir do primeiro comando depois do 
ate 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 98 
Faça um algoritmo para ler a idade e o sexo (M ou F) de cada um dos 500 funcionários de 
uma empresa, e calcular e imprimir a média das idades e a quantidade de mulheres. Se a 
idade digitada for igual a 0(zero) a repetição deverá ser interrompida. 
 
Algoritmo "IdadeSexoInterrompa" 
var 
 nome, sexo : caractere 
 aux, idade, soma, cont1, cont2 : inteiro 
 media : real 
inicio 
 soma <- 0 
 cont1 <- 0 
 cont2 <- 0 
 para aux de 1 ate 500 faca 
 escreva("Digite a idade do empregado: ") 
 leia(idade) 
 se idade = 0 entao 
 interrompa 
 fimse 
 soma <- soma + idade 
 cont1 <- cont1 + 1 
 escreva("Digite o sexo do empregado: ") 
 leia(sexo) 
 se sexo = "F" entao 
 cont2 <- cont2 + 1 
 fimse 
 fimpara 
 media <- soma / cont1 
 escreval("Média das idades = ",media) 
 escreval("Quantidade mulheres = ",cont2) 
fimalgoritmo 
 
Neste exemplo, apesar do comando PARA utilizar o contador aux, que varia de 1 a 500, 
gerando 500 repetições (500-1+1 = 500), se o valor digitado na variável idade for zero, o 
PARA será finalizado pelo comando INTERROMPA, interrompendo as repetições, e a 
próxima linha de comando a ser executada será aquela após o fimpara. 
 
 
8.6 - Exercícios Resolvidos 
 
Exercício 1: 
 
Faça um algoritmo para calcular e imprimir o valor da multa a ser aplicada a uma série de 
valores financeiros informados pelo usuário. A cada valor lido o algoritmo deverá imprimir a 
multa. O último valor é igual a -1 e não deverá entrar nos cálculos. No final o algoritmo deverá 
imprimir a média das multas calculadas. 
 
MULTA = 10% do VALOR 
 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 99 
Solução no VisuAlg: 
 
 
 
 
Exercício 2: 
 
Faça um algoritmo para ler os valores recebidos pelos serviços prestados por uma empresa 
de projetos durante o mês. O algoritmo deverá calcular e imprimir: 
 
a) A média dos valores recebidos; 
b) O valor total recebido; 
c) A quantidade de valores recebidos acima de R$1000,00. 
 
O último valor, que não entrará nos cálculos, é igual a 0(zero). 
 
Solução no VisuAlg: 
 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 100 
 
 
 
Exercício 3: 
 
O preço final de um produto manufaturado é calculado somando-se os custos parciais dos 
materiais consumidos na sua fabricação somado ao BDI (Bonificação e Despesas Indiretas = 
lucro). Faça um algoritmo para calcular e imprimir este preço final, para isto ele deverá ler a 
taxa de BDI (em %) da empresa, uma única vez no início do algoritmo, e o nome, a 
quantidade e o preço unitário de uma série de materiais utilizados na manufatura do produto. 
A cada material lido o algoritmo deverá calcular e imprimir o seu custo parcial. 
 
Custo Parcial = Quantidade do Material X Preço Unitário 
Custo Total = Somatório dos Custos Parciais 
BDI = Taxa sobre o Custo Total (Valor BDI = Custo Total X Taxa BDI / 100) 
Preço Final = Custo Total + BDI 
 
O último material a ser lido terá seu nome igual a FIM e não deverá entrar nos cálculos. 
 
Solução no VisuAlg: 
 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 101 
 
 
 
8.7 - Síntese 
 
Neste capítulo você aprendeu a utilizar mais duas estruturas de repetição, os comandos 
ENQUANTO e REPITA que permitirão ao algoritmo trabalhar com quantidades indefinidas de 
repetições. Aprendeu também a fazer consistência de dados de entrada e interromper 
processos de repetição mais rapidamente via comando INTERROMPA. 
 
Programação de Computadores–Prof. Ricardo Luiz de Freitas 102 
ANEXO 1 
 
Palavras reservadas do VisuAlg: 
 
aleatorio 
algoritmo 
arquivo 
ate 
caractere 
caso 
cronometro 
debug 
e 
eco 
enquanto 
entao 
escolha 
escreva 
escreval 
faca 
falso 
fimalgoritmo 
fimenquanto 
fimescolha 
fimfuncao 
fimpara 
fimprocedimento 
fimrepita 
fimse 
funcao 
inicio 
inteiro 
interrompa 
leia 
logico 
nao 
ou 
outrocaso 
para 
passo 
pausa 
real 
procedimento 
repita 
retorne 
se 
senao 
timer 
var 
vetor 
verdadeiro 
xou