Aprenda a Programar do Zero

Prévia do material em texto

APRENDA A 
PROGRAMAR 
DO ZERO
LÓGICA DE PROGRAMAÇÃO
DANIEL G. SOUTO
EDUARDO M. SILVA
WWW.CRIANDOCODIGO.COM.BR CriandoC ó d i g o
 
 
 
"O seu tempo é limitado, então não o desperdice 
vivendo a vida de outra pessoa..." 
STEVE JOBS 
AUTORES 
 
Daniel G. Souto 
Analista graduado em Sistemas de Informação pela Universidade 
Potiguar, com mais de 15 anos de experiência desenvolvendo sistemas 
para indústria, comércio e setor público. 
Expert nas linguagens C, C++, Java, Object Pascal (Delphi) e 
Banco de Dados Microsoft SQL Server. 
 
Eduardo M. Silva 
 Graduado em Sistemas de Informação pela Universidade 
Potiguar e pós-graduado em Engenharia de Software pela Impacta 
Tecnologia. 
Possui mais de 10 anos de experiência em desenvolvimento web 
e mobile, administração de redes e bancos de dados. Expert nas 
linguagens Java, C#, ASP e C++ com foco em ambientes .NET. 
Atualmente é empresário no segmento de automação comercial 
na cidade de Natal/RN. 
 
 
 
 
 
 
 
Atenção 
 
 
Todos os nomes de marcas, produtos e serviços 
mencionados aqui são propriedade de seus respectivos 
donos e são usados somente como referência. Além disso, 
não existe a intenção de difamar, desrespeitar, insultar, 
humilhar ou menosprezar você, leitor, ou qualquer outra 
pessoa, cargo ou instituição. Caso você acredite que 
alguma parte deste guia seja, de alguma forma, 
desrespeitosa ou indevida, e deva ser removida ou alterada, 
você pode entrar em contato diretamente conosco através 
do e-mail suporte@criandocodigo.com.br 
 
INTRODUÇÃO 
 
Este livro é destinado a pessoas interessadas em aprender a programar, mas que 
nunca tiveram contado com uma linguagem de programação, e aqueles que sentiram 
dificuldade no passado e que desejam retornar aos estudos objetivando a superação. O e-
book aborda de forma clara e simples o conteúdo da lógica de programação utilizando o 
português estruturado. 
Os capítulos estão organizados de maneira que o estudante possa evoluir 
gradativamente. Iniciando com conceitos sobre algoritmos partindo em seguida para o básico 
na construção de um algoritmo até os comandos e estruturas mais avançados, o leitor 
aprenderá como estruturar o código através de exemplos e diagramas. A cada capítulo é 
apresentado uma lista de exercícios que visa a fixação do conteúdo, para tal é muito 
importante que o estudante elabore a sua própria solução e confronte a sua resposta com a 
resolução do exercício no final do livro. 
Desenvolver o raciocínio lógico para encontrar soluções é a parte mais importante 
quando se estuda uma linguagem de programação. 
 
 
DICAS 
 
Segue aqui algumas dicas para que você possa obter o melhor aproveitamento 
possível deste livro: 
Verifique no site www.criandocodigo.com.br se você está com a versão atualizada 
deste livro. 
Atualizamos constantemente a versão deste livro com as mais atuais e avançadas 
formas de estudar lógica de programação, atualizamos também para adicionar melhores 
explicações de alguma parte que possa ter gerado dúvidas. 
A ideia é que esse livro nunca tenha um fim. Ele será atualizado continuamente para 
que você sempre esteja com o que há de mais moderno no estudo da lógica de programação. 
A cada nova versão, eu mostro o que foi mudado para que você leia somente as partes 
atualizadas (não tendo que ler o livro todo novamente, se não quiser ou não tiver tempo). 
 
 
SUMÁRIO 
1 ALGORITMOS ....................................................................................................... 8 
1.1 Lógica de programação ............................................................................................. 8 
1.2 Algoritmos ................................................................................................................. 8 
1.3 Formas de representação ......................................................................................... 9 
1.3.1 Descrição narrativa ....................................................................................................................... 9 
1.3.2 Pseudocódigo ............................................................................................................................... 9 
1.3.3 Diagrama de bloco ...................................................................................................................... 10 
2 MEMÓRIA, TIPOS DE DADOS E VARIÁVEIS .......................................................... 13 
2.1 Identificadores ......................................................................................................... 13 
2.2 Tipos de dados primitivos ........................................................................................ 14 
2.2.1 Inteiros ..................................................................................................................................... 14 
2.2.2 Reais ........................................................................................................................................ 14 
2.2.3 Literais ..................................................................................................................................... 14 
2.2.4 Lógicos ..................................................................................................................................... 14 
2.3 Constantes ............................................................................................................... 14 
2.4 Variáveis ................................................................................................................... 14 
3 COMENTÁRIOS ................................................................................................... 18 
4 VISUALG............................................................................................................. 20 
5 OPERADORES .................................................................................................... 23 
5.1 Operadores aritméticos ........................................................................................... 23 
5.2 Operadores relacionais ........................................................................................... 24 
5.3 Operadores lógicos .................................................................................................. 24 
5.3.1 Operador lógico E ....................................................................................................................... 25 
5.3.2 Operador lógico OU ..................................................................................................................... 25 
5.3.3 Operador lógico NAO ................................................................................................................... 25 
5.3.4 Operador lógico XOU ................................................................................................................... 25 
5.4 Exercícios ................................................................................................................. 26 
6 ESTRUTURAS DE CONTROLE ............................................................................. 28 
6.1 Estrutura seqüencial ............................................................................................... 28 
6.2 Estrutura de decisão ............................................................................................... 28 
6.2.1 Decisão simples ......................................................................................................................... 28 
6.2.2 Decisão composta ...................................................................................................................... 29 
6.2.3 Seleção encadeada .....................................................................................................................30 
6.2.4 Decisão múltipla ........................................................................................................................ 32 
6.3 Estrutura de repetição ............................................................................................ 34 
6.3.1 Variável de controle .................................................................................................................... 34 
6.3.2 Laços condicionais ..................................................................................................................... 36 
6.3.2.1 Teste lógico no início do laço .................................................................................................. 36 
6.3.2.2 Teste lógico no final do laço .................................................................................................... 37 
6.3.3 Interrompendo as estruturas de laço ............................................................................................ 38 
6.4 Exercícios ................................................................................................................. 39 
7 ESTRUTURA DE DADOS HOMOGÊNEAS .............................................................. 42 
7.1 Vetores ..................................................................................................................... 42 
7.2 Matrizes ................................................................................................................... 43 
7.3 Exercícios ................................................................................................................. 44 
8 MODULARIZAÇÃO .............................................................................................. 46 
8.1 Subprogramas ......................................................................................................... 46 
8.2 Procedimentos ........................................................................................................ 46 
8.3 Funções ................................................................................................................... 47 
8.4 Variáveis locais e globais ......................................................................................... 48 
8.5 Passagem de parâmetros por referência ............................................................... 48 
8.6 Funções do VisuAlg ................................................................................................. 49 
8.7 Exercícios ................................................................................................................. 52 
9 RESOLUÇÃO DOS EXERCÍCIOS ........................................................................... 54 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1 ALGORITMOS 
 
APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO 
8 
Livro versão 1.1 verifique se esta é a versão mais atualizada em www.criandocodigo.com.br 
 
1 Algoritmos 
 
1.1 Lógica de programação 
 
 A lógica de programação é a técnica que tem como objetivo desenvolver algoritmos 
para solucionar problemas ao utilizara lógica matemática no desenvolvimento de um 
programa. 
 Para ser um bom programador é importante aprender a lógica. Ela é a base para 
aprender as linguagens de programação. 
 
1.2 Algoritmos 
 
 Algoritmo é uma palavra derivada do nome Mohammed ibn Musa Al-Khowarizmique, 
que foi um matemático, astrônomo e astrólogo por volta de 800 d.C. Seus trabalhos 
introduziram o cálculo hindu aos árabes e, em seguida, para Europa. 
 Um programa de computador é um algoritmo que segue a sintaxe de uma linguagem 
de programação. Algoritmo é essencialmente uma ordem de comandos, ou instruções, que 
diz ao computador o que deve fazer. 
 Algoritmos são compostos por blocos de código que se conectam por meio de três 
estruturas, que são a sequenciação, seleção e repetição. Baseado nessas estruturas temos 
a origem da programação estruturada. 
 
• Sequenciação: São os passos de processamento que descrevem um programa: 
"execute a Tarefa A e depois a Tarefa B" 
• Seleção: Permite a mudança do fluxo de execução de um programa baseado 
em ocorrências lógicas: "se X for verdadeiro, faça a Tarefa A; senão faça a 
Tarefa B" 
• Repetição: Permite a repetição de partes do programa: "repita Tarefa A 
enquanto X for menor que 10" 
 
 Um algoritmo é dividido em três partes: Entrada, processamento e saída. 
 Na entrada temos os dados a serem inseridos no programa para resolução de um 
problema. No processamento estará o código responsável para se chegar a um resultado. A 
saída retornará o resultado do processamento. 
 
Definição: 
1. Um algoritmo é um conjunto não ambíguo e ordenado de passos executáveis que 
definem um processo finito1. 
 
2. Um dado é qualquer registro que não esteja contextualizado, organizado ou 
trabalhado, que não representa um significado. Uma informação é o dado tratado, organizado 
e formatado para passar um significado para quem a recebe. 
 
1Conceito de algoritmo formalizado por Alan Turing e Alonzo Church em 1936 
 
APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO 
9 
Livro versão 1.1 verifique se esta é a versão mais atualizada em www.criandocodigo.com.br 
 
 
1.3 Formas de representação 
 
 Exigem várias formas que podem ser usadas na representação de algoritmos, as mais 
comumente utilizadas são: Descrição narrativa, pseudocódigo e fluxograma. 
 
1.3.1 Descrição narrativa 
 
 Na descrição narrativa os algoritmos são expressos em linguagem natural em 
português ou outro idioma. A linguagem natural está bem distante do entendimento da 
linguagem utilizada pelos computadores. Tem como desvantagem a dificuldade de traduzi-la 
para computadores, são mais propensas a ambiguidades e a extensão do conteúdo. Por ser 
uma linguagem que temos familiaridade pode ser criada com facilidade. A seguir, um 
exemplo: 
 
• Algoritmo para fritar um ovo 
 
1. Retire o ovo da geladeira. 
2. Coloque a frigideira no fogo. 
3. Coloque óleo na frigideira. 
4. Quebre ovo, separando a casca. 
5. Ponha a clara e a gema na frigideira. 
6. Espere um minuto. 
7. Apague o fogo. 
8. Retire o ovo da frigideira. 
 
1.3.2 Pseudocódigo 
 
 O pseudocódigo, também conhecido por pseudo-linguagem, é uma representação da 
linguagem natural sobre uma linguagem de programação. Não existe um padrão formal de 
como o pseudocódigo deve ser escrito, apenas que deve ser didático o bastante para que 
represente uma linguagem de programação. 
 O VisuAlg será a nossa ferramenta de criação de pseudocódigo através do português 
estruturado (portugol2) a partir deste ponto e em todo livro, a seguir um exemplo de 
algoritmo: 
 
algoritmo "calculo da média" 
var 
 nota1, nota2, M: real 
inicio 
 leia(nota1) 
 leia(nota2) 
 M <- (nota1 + nota2) / 2 
 
2Portugol é a união entre Português + ALGOL (significa AlgorithmicLanguage, é uma linguagem de 
programação voltada para aplicações científicas criada em 1958) 
 
APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO 
10 
Livro versão 1.1 verifique se esta é a versão mais atualizada em www.criandocodigo.com.br 
 
 
 se M >= 7.0 entao 
 escreva("Aprovado") 
 senao 
 escreva("Reprovado") 
 fimse 
fimalgoritmo 
 
 O código inicia com a palavra algoritmo que define o título do programa. Em var temos 
a área onde as variáveis são declaradas. inicio e fimalgoritmo determinam o inicio e fim da 
área reservada aos comandos. 
 
1.3.3 Diagrama de bloco 
 
 É uma representação esquemática de um processo, sistemaou algoritmo. Um 
diagrama de bloco, também conhecido como diagrama de fluxo, usa formas geométricas 
como retângulos, círculos entre outras conectados por setas que indicam o fluxo e sequência 
do processo. Na Figura 1.1 temos as formas usadas com maior frequência. 
 
 Terminação sinaliza o 
início ou fim do fluxo de um 
programa. 
 Fluxo do algoritmo 
representa o sentido do fluxo 
conectando os símbolos. 
 
 
 
Processo utilizado 
para indicar que algum 
cálculo, atribuição ou outra 
manipulação de dados será 
realizado. 
 Entrada de dados 
indica que novos dados serão 
inseridos atraves de algum 
dispositivo. 
 Saída de dados indica 
a saída dos dados 
processados. 
 Decisão determina 
uma mudança no fluxo após 
o resultado de uma 
comparação. 
 Preparação 
Representa um grupo de 
operações que não estão 
 
APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO 
11 
Livro versão 1.1 verifique se esta é a versão mais atualizada em www.criandocodigo.com.br 
 
incluídas na diagramação. 
 Conector utilizado 
para conectar pares. 
Figura 1.1 Formas geométricas 
 Exemplo: 
 
 
 
Figura 1.2 Diagrama do pseudocódigo 
 
 
 
APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO 
12 
Livro versão 1.1 verifique se esta é a versão mais atualizada em www.criandocodigo.com.br 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2 MEMÓRIA, TIPOS DE DADOS E VARIÁVEIS 
 
APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO 
13 
Livro versão 1.1 verifique se esta é a versão mais atualizada em www.criandocodigo.com.br 
 
2 Memória, tipos de dados e variáveis 
 
 A memória do computador é o componente eletrônico capaz de armazenar as 
variáveis, o código do algoritmo e outros dados pertinentes a um programa. Na programação 
cada posição da memória possui um endereço e é nesse espaço que armazenamos as 
variáveis. Ao definir uma variável estaremos reservando um endereço que conterá uma 
representação simbólica (nome) e o valor, a figura 2.1 ilustra um o endereçamento da 
memória. 
 
Endereço Variável Valor 
0 idade 30 
1 altura 1,62 
2 nome Maria 
... ... ... 
n x 0 
Tabela 2.1 Representação da memória com endereço, nome da variável e valor 
 
2.1 Identificadores 
 
 Os nomes das variáveis, funções e outros componentes adicionados a um programa 
são chamados de identificadores. 
 Algumas palavras, que são os comandos da linguagem de programação, não podem 
ser usadas, como por exemplo no VisuAlg as palavras-chave, ou palavras reservadas, inteiro, 
para, se, senao, inicio entre outras não podem ser usadas. A seguir as regras para criação de 
identificadores: 
 
• 
• Não são permitidos espaços em branco 
• Os caracteres utilizados devem ser números, letras minúsculas, letras maiúsculas e o 
caractere sublinhado 
• Palavras reservadas não podem ser usadas como identificadores 
 
Alguns exemplos: 
 
Identificadores válidos 
X 
nome_aluno 
rua2020 
abc_123 
LOGICA 
 
Identificadores inválidos 
3X // iniciando com número 
 
APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO 
14 
Livro versão 1.1 verifique se esta é a versão mais atualizada em www.criandocodigo.com.br 
 
nome aluno // espaço em branco 
rua@2020 // caractere especial @ 
LÓGICA // caracteres especiais como acentuações 
inteiro // palavra reservada do VisuAlg 
 
2.2 Tipos de dados primitivos 
 
 Variáveis e constantes são os espaços na memória que armazenam valores. Para um 
programa de computador funcionar ele necessita dessas informações. No VisuAlg podemos 
utilizar quatro tipos dados primitivos: inteiro, real, caractere e lógico. 
 
2.2.1 Inteiros 
 
São tipos de dados numéricos positivos ou negativos sem qualquer número 
fracionado. Exemplos: 50, -12, 0, entre outros. 
 
2.2.2 Reais 
 
São tipos de dados numéricos positivos, negativos e números fracionados: Exemplos: 
50, -12, 0, 1.45, -23.891, entre outros. (Quando usamos números fracionados em programas 
de computador devemos utilizar a notação inglesa e substituir a vírgula pelo ponto). 
 
2.2.3 Literais 
 
São tipos de dados que tem como característica possuírem uma cadeia de caracteres 
como delimitadores. Uma cadeia de caracteres é também conhecida como string. Exemplos: 
Avenida Paulista, 1234 99)3444- 
 
2.2.4 Lógicos 
 
São tipos de dados que recebem valores verdadeiro ou falso. Também conhecido 
como tipo booleano devido à contribuição do matemático e filósofo George Boole. 
 
2.3 Constantes 
 
As constantes são valores fixos e que não podem ser alterados durante a execução de 
um programa. Exemplos:12, 102.48, "palavra", -5.8, entre outros. 
 
2.4 Variáveis 
 
 Uma variável pode armazenar apenas um valor e seu conteúdo pode ser modificado 
programaticamente durante a execução do programa. Tal modificação é possível ao executar 
o comando de atribuição. O comando de atribuição é representado por uma seta apontando 
para esquerda. 
 
 
APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO 
15 
Livro versão 1.1 verifique se esta é a versão mais atualizada em www.criandocodigo.com.br 
 
identificador ← expressão 
Figura 2.1 
 
 Uma variável é também um identificador e na figura 2.1 temos uma variável recebendo 
um valor (expressão), pode- A seguir alguns 
exemplos de uso: 
 
 
 Para declarar uma variável no VisuAlg usamos as seguintes palavras-chave: 
 
• inteiro: Tipos numéricos inteiros 
• real: Tipos numéricos reais 
• caractere: Tipo literais 
• logico: Tipos lógicos 
 
 Os nomes das variáveis devem começar por uma letra e depois conter letras, números 
ou sublinhado, até um limite de 30 caracteres no VisuAlg. A declaração de uma variável deve 
seguir o padrão mostrado a seguir: 
 
<lista-de-variáveis>: <tipo-de-dado> 
 
A <lista-de-variáveis> suporta a inserção de um nome ou vários nomes 
separados por vírgula. No <tipo-de-dado> deve-se informar o tipo de dado desejado. 
Exemplos: 
 
valor: real 
x, y, z: inteiro 
aprovado: logico 
nome, rua, cidade, telefone: caractere 
 
As variáveis são declaradas após a palavra-chave var e recebem valor após inicio: 
 
Algoritmo "exemplo" 
var 
 nota: real 
 X, Y, Z: inteiro 
 nome: caractere 
 resposta: logico 
inicio 
nota <- 7.5 (nota recebe 7.5) 
Y <- 1 
Z <- 2 
X <- Y + Z 
X <- X + 1 
nome <- "Maria" 
 
APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO 
16 
Livro versão 1.1 verifique se esta é a versão mais atualizada em www.criandocodigo.com.br 
 
 nome <- "Maria" 
 nota <- 7.5 
 Y <- 1 
 Z <- 2 
 X <- Y + Z 
 X <- X + 1 
 resposta <- falso 
fimalgoritmo 
 
 
 
APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO 
17 
Livro versão 1.1 verifique se esta é a versão mais atualizada em www.criandocodigo.com.br 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3 COMENTÁRIOS 
 
APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO 
18 
Livro versão 1.1 verifique se esta é a versão mais atualizada em www.criandocodigo.com.br 
 
3 Comentários 
 
 Os comentários servem para descrever partes, ou blocos, de código para facilitar a sua 
leitura ou quando o programador passar muitos dias sem trabalhar e ter dificuldade em 
relembrar a funcionalidade de determinado código. No VisuAlg o delimitador // indica que a 
linha, ou parte da linha, é um comentário, exemplo: 
 
// esta linha é um comentário 
X <- Y + Z // X recebe a soma de Y e Z 
 
 Assim que você inicia o VisuAlgele nos fornece um esqueleto de um programa. Como 
pode ser visto no quadro abaixo há vários comentários com informações sobre o autor e as 
seções do código. 
 
algoritmo "semnome" 
// Disciplina : [Linguagem e Lógica de Programação] 
// Professor : Antonio Carlos Nicolodi 
// Descrição : Aqui você descreve o que o programa faz! (função) 
// Autor(a) : Nome do(a) aluno(a) 
// Data atual : 23/3/2018 
var 
// Seção de Declarações das variáveis 
 
inicio 
// Seção de Comandos, procedimento, funções, operadores, etc... 
 
fimalgoritmo 
 
 
 
 
APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO 
19 
Livro versão 1.1 verifique se esta é a versão mais atualizada em www.criandocodigo.com.br 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4 VISUALG 
 
APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO 
20 
Livro versão 1.1 verifique se esta é a versão mais atualizada em www.criandocodigo.com.br 
 
4 VisuAlg 
 
 Neste capítulo iremos apresentar o editor VisuAlg que permite criar, interpretar e 
executar algoritmos em português estruturado como se fosse um programa de computador. 
O VisuAlg simula um ambiente de execução de um programa real onde os resultados 
serão mostrados numa tela de texto (semelhante ao MS-DOS), com recursos como 
depuração de erros e a possibilidade de exportar o código para outras linguagens de 
programação. 
Neste e-book todos os exemplos de código serão criados na versão 3.0.6.5 do VisuAlg, 
para baixa-lo acesse o site http://visualg3.com.br. 
 
 
Figura 4.1 Tela principal do VisuAlg 
 
Na tela principal do VisuAlg (figura 4.1) você tem a área para digitação do código, área 
para visualizar o valor de cada variável e uma área com os resultados. 
O menu que você irá usar bastant .2), as opções desse 
menu lhe permitirá executar os algoritmos apresentados em cada capitulo. 
Para rodar um algoritmo utilize a tecla de atalho F9. Quando quiser testar o código 
linha por linha coloque o cursor na linha desejada e tecle F5 para ativar o ponto de parada 
(breakpoint) e tecle F8 para rodar o algoritmo passo a passo (modo depuração). 
 
A seguir temos uma descrição de cada função do menu: 
 
Rodar o Algoritmo: Inicia (ou continua) a execução automática do pseudocódigo. 
 
Rodar Passo a passo: Inicia (ou continua) a execução linha por linha do pseudocódigo, 
dando ao usuário a oportunidade de acompanhar o fluxo de execução, os valores das 
variáveis e a pilha de ativação dos subprogramas. 
 
Rodar com tempo: Insere um atraso (que pode ser especificado) antes da execução de 
cada linha. Também realça em fundo azul o comando que está sendo executado, da mesma 
forma que na execução passo a passo. 
 
 
APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO 
21 
Livro versão 1.1 verifique se esta é a versão mais atualizada em www.criandocodigo.com.br 
 
Parar: Termina imediatamente a execução do pseudocódigo. Evidentemente, este item 
fica desabilitado quando o pseudocódigo não está sendo executado. 
 
Liga/desliga breakpoint: Insere/remove um ponto de parada na linha em que esteja o 
cursor. Estes pontos de parada são úteis para a depuração e acompanhamento da execução 
dos pseudocódigos, pois permitem a verificação dos valores das variáveis e da pilha de 
ativação de subprogramas. 
 
Desmarcar todos os breakpoints: Desativa todos os breakpoints que estejam 
ativados naquele momento. 
 
Executar em modo DOS: Com esta opção ativada, tanto a entrada como a saída-
padrão passa a ser uma janela que imita o MS-DOS, simulando a execução de um programa 
neste ambiente. 
 
Gerar valores aleatórios: Ativa a geração de valores aleatórios que substituem a 
digitação de dados. A faixa padrão de valores gerados é de 0 a 100 inclusive, mas pode ser 
modificada. Para a geração de dados do tipo caractere, não há uma faixa preestabelecida: os 
dados gerados serão sempre strings de 5 letras maiúsculas. 
 
Perfil: Após a execução de um pseudocódigo, exibe o número de vezes que cada umas 
das linhas foi executada. É útil para a análise de eficiência (por exemplo, métodos de 
ordenação) 
 
Pilha de ativação: Exibe a pilha de subprogramas ativados num dado momento. 
Convém utilizar este comando em conjunto com breakpoints ou com a execução passo a 
passo. 
 
 
 
Figura 4.2 Menu Run 
 
APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO 
22 
Livro versão 1.1 verifique se esta é a versão mais atualizada em www.criandocodigo.com.br 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
5 OPERADORES 
 
APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO 
23 
Livro versão 1.1 verifique se esta é a versão mais atualizada em www.criandocodigo.com.br 
 
5 Operadores 
 
 Um operador é um elemento aplicado a um ou mais operandos em uma expressão ou 
instrução. A seguir veremos como usar os operadores matemáticos no computador. 
 
5.1 Operadores aritméticos 
 
 Para criar uma expressão aritmética devemos utilizar variáveis de tipo inteiro ou real e 
os operadores aritméticos. Existem dois tipos de operadores aritméticos: unários e binários. 
 
• Unários: Operadores que usam apenas um operando. Por exemplo, quando queremos 
inverter um valor de positivo para negativo. 
• Binários: Operadores que usam dois operando. Exemplos: exponenciação, 
multiplicação, adição, subtração e divisão. 
 
Prioridade Tipo Operador Descrição 
1 Unário - Sinal negativo 
1 Unário + Sinal positivo 
2 Binário ^ Exponenciação 
3 Binário \ Divisão Inteira 
3 Binário % ou MOD Resto da divisão (módulo) 
3 Binário / Divisão 
3 Binário * Multiplicação 
4 Binário + Adição 
4 Binário - Subtração 
Tabela 5.1 
Exemplos de uso de operadores: 
 
x <- 3 * 10 
y <- x - 1 
x <- x * y + 5 
z <- x + (y * x) 
x <- (y / z)^2 
 
 Expressões matemáticas complexas podem utilizar múltiplos operadores, colchetes e 
chaves. Para que o computador compreenda essa expressão será necessário converte-la 
para um formato compatível com a linguagem de programação. Ao invés de usar colchetes e 
 
APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO 
24 
Livro versão 1.1 verifique se esta é a versão mais atualizada em www.criandocodigo.com.br 
 
chaves, na programação os únicos elementos usados para agrupar as expressões são os 
parênteses. A seguir um exemplo: 
 
Expressão original: 
[
𝑥 + 𝑦
2
+ (10 𝑥 4)] + 18 
 
Expressão em VisuAlg: 
((x+y)/2+(10*4))+18 
 
5.2 Operadores relacionais 
 
 Os operadores relacionais são usados para comparar dois valores do mesmo tipo. São 
operadores binários e retornam apenas dois valores: verdadeiro ou falso. 
 
Símbolo Significado 
= Igual 
< Menor 
> Maior 
<= Menor ou igual 
>= Maior ou igual 
<> Diferente 
Tabela 5.2 
 
Exemplos: 
 
x <- 8 
y <- 1 
nome <- "Maria" 
letra <- "A" 
 
x = 4 //falso 
x > 1 //verdadeiro 
x = x + 1 //falso 
x = y //falso 
y <= x //verdadeiro 
y <> x //verdadeiro 
nome = "João" //falso 
letra < "B" //verdadeiro 
 
5.3 Operadores lógicos 
 
 
APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO 
25 
Livro versão 1.1 verifique se esta é a versão mais atualizada em www.criandocodigo.com.br 
 
 Os operadores lógicos são utilizados para combinar mais de uma expressão relacional, 
o resultado sempre será verdadeiro ou falso. 
 
5.3.1 Operador lógico E 
 
Operador que resulta VERDADEIRO somente se seus dois operandos lógicos forem 
verdadeiros. Na tabela 5.3 temos a tabela verdade do operador E. 
 
Operando 1 Operando 2 ResultadoFalso Falso Falso 
Verdadeiro Falso Falso 
Falso Verdadeiro Falso 
Verdadeiro Verdadeiro Verdadeiro 
Tabela 5.3 
 
5.3.2 Operador lógico OU 
 
 Operador que resulta VERDADEIRO quando um dos seus operandos lógicos for verdadeiro. 
A seguir, na tabela 5.4, temos a tabela verdade do operador OU. 
 
Operando 1 Operando 2 Resultado 
Falso Falso Falso 
Verdadeiro Falso Verdadeiro 
Falso Verdadeiro Verdadeiro 
Verdadeiro Verdadeiro Verdadeiro 
Tabela 5.4 
 
5.3.3 Operador lógico NAO 
 
 Operador unário de negação, inverte a expressão. VERDADEIRO será FALSO, e FALSO 
será VERDADEIRO. Tem a maior prioridade entre os operadores lógicos. Na tabela 5.5 temos a 
tabela verdade do operador NAO. 
 
Operando Resultado 
Falso Verdadeiro 
Verdadeiro Falso 
Tabela 5.5 
 
5.3.4 Operador lógico XOU 
 
Lê-se ou exclusivo. Operador que resulta VERDADEIRO se seus dois operandos lógicos 
forem diferentes, e FALSO se forem iguais. A tabela 5.6 mostra a tabela verdade do operador XOU. 
 
Operando 1 Operando 2 Resultado 
Falso Falso Falso 
Verdadeiro Falso Verdadeiro 
Falso Verdadeiro Verdadeiro 
Verdadeiro Verdadeiro Falso 
 
APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO 
26 
Livro versão 1.1 verifique se esta é a versão mais atualizada em www.criandocodigo.com.br 
 
Tabela 5.6 
 
Exemplos: 
 
x <- 8 
y <- 1 
r <- falso 
 
(x > 0) ou (y = 3) //verdadeiro 
nao r //verdadeiro 
nao ((x > 0) ou (y = 3)) //falso 
(x <> y) e ("A" = "B") ou (r = falso) //verdadeiro 
(x > 0) e (x < 5) //falso 
(x > 0) xou (x < 5) // verdadeiro 
 
5.4 Exercícios 
 
Desenvolva os algoritmos das questões a seguir. As resoluções dos exercícios estão no 
capítulo 9, no final deste livro. 
 
Veja no capítulo 8.6 como usar os comandos LEIA para entrada de dados e ESCREVA para 
saída de dados (imprimir textos e variáveis na tela). 
 
1. Leia dois números inteiros e imprima-os. 
 
2. Imprima o produto entre 15 e 36. 
 
3. Imprima a média aritmética entre os números 4, 5 e 2. 
 
4. Entrar com nome, endereço e telefone e imprima-os. 
 
5. Leia dois números inteiros para as variáveis X e Y, e realize a troca de valores entre as 
duas variáveis. Faça com que a variável X tenha o valor Y e a variável Y tenha o valor de X. 
Imprima os valores trocados. 
 
6. Leia dois números reais A, B e C. Crie uma variável X e atribua a ela o quadrado da soma 
de A, B e C. Imprima o resultado de X. 
 
7. Ler dois números inteiros que serão o numerador e denominador de uma fração e atribuir 
o resultado a uma variável real. Imprima o resultado. 
 
8. Entrar com dois números inteiros e imprimir o quociente e resto. 
 
 
 
APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO 
27 
Livro versão 1.1 verifique se esta é a versão mais atualizada em www.criandocodigo.com.br 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
6 ESTRUTURAS DE CONTROLE 
 
APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO 
28 
Livro versão 1.1 verifique se esta é a versão mais atualizada em www.criandocodigo.com.br 
 
6 Estruturas de controle 
 
 No capítulo 1 vimos que os algoritmos são compostos por blocos de código que se 
conectam por meio de três estruturas: sequenciação, seleção e repetição. Neste capítulo 
veremos em detalhes como construir cada estrutura. 
 
6.1 Estrutura sequencial 
 
A estrutura sequencial é um grupo de comandos que são executados em sequência, 
de cima para baixo, sem mudança no fluxo. A sequência de comandos fica entre as palavras-
chave inicio e fimalgortimo. 
 
inicio 
 x <- 100 
 y <- 200 
 soma <- x +y 
 escreva(soma) 
fimalgoritmo 
 
6.2 Estrutura de decisão 
 
A estrutura de decisão é usada para permitir a execução de blocos de comandos a 
partir do resultado de uma expressão lógica. Essas estruturas podem ser simples, composta, 
encadeada ou múltipla. 
 
6.2.1 Decisão simples 
 
A estrutura de decisão simples é quando uma única condição é testada. O resultado 
dessa condição irá determinar o fluxo de comandos a ser seguido. Exemplo da sintaxe: 
 
se <expressão-lógica> entao 
 <sequência-de-comandos> 
fimse 
 
Apenas quando a <expressão-lógica> tenha um resultado VERDADEIRO os 
comandos após entao serão executados. Caso a <expressão-lógica> tenha um resultado 
FALSO a sequência de comandos não será executada e a decisão simples é encerrada. 
Exemplo em pseudocódigo: 
 
 
algoritmo "Decisão simples" 
var 
 x: inteiro 
 
inicio 
 x <- 10 
 
 
APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO 
29 
Livro versão 1.1 verifique se esta é a versão mais atualizada em www.criandocodigo.com.br 
 
 se x = 10 entao 
 escreva("o valor de x é 10") 
 fimse 
 
fimalgoritmo 
 
 Representação no diagrama de blocos: 
 
 
Figura 6.1 
 
6.2.2 Decisão composta 
 
Na estrutura de decisão composta uma segunda sequência de instruções será 
executada após o resultado da condição ser falso. Sintaxe da estrutura: 
 
se <expressão-lógica> entao 
<sequência-de-comandos> 
senao 
<sequência-de-comandos> 
fimse 
 
 Quando a <expressão-lógica> apresentar um resultado VERDADEIRO a primeira 
sequência de comandos, logo após entao, será executada e a decisão composta é encerrada. 
Caso a <expressão-lógica> retorne FALSO a sequência de comandos após senao será 
executada e a decisão composta terminará. A seguir um exemplo: 
 
 
APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO 
30 
Livro versão 1.1 verifique se esta é a versão mais atualizada em www.criandocodigo.com.br 
 
algoritmo "Decisão composta" 
var 
 numero: inteiro 
 
inicio 
 escreva("digite um número e tecle enter: ") 
 leia(numero) 
 
 se (numero >= 0) e (numero <= 1000) entao 
 escreva("O numero esta entre 0 e 1000") 
 senao 
 escreva("O numero é maior que 1000") 
 fimse 
 
fimalgoritmo 
 
 
Nota: Existindo duas ou mais expressões lógicas após o comando SE essas expressões devem ser 
agrupadas usando parênteses. 
 
 
 Representação no diagrama de blocos: 
 
Figura 6.2 
 
6.2.3 Seleção encadeada 
 
A estrutura de seleção encadeada é usada quando se deseja realizar comparações 
sucessivas. Uma sequência de comandos será executada quando as condições anteriores 
forem satisfeitas. Uma condição com resultado VERDADEIRO vai executar outra condição, e 
se esta última for VERDADEIRA executará outra condição e assim por diante até encontrar 
uma condição com resultado FALSO ou o fim da estrutura com o fimse. Veja a sintaxe a 
seguir: 
 
se <expressão-lógica-1> entao 
 
APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO 
31 
Livro versão 1.1 verifique se esta é a versão mais atualizada em www.criandocodigo.com.br 
 
<sequência-de-comandos> 
senao 
se <expressão-lógica-2> entao 
<sequência-de-comandos> 
senao 
<sequência-de-comandos> 
fimse 
fimse 
 
 Exemplo de algoritmo: 
 
algoritmo "Seleção encadeada" 
var 
 media: real 
 
inicio 
 escreva("digite a nota media do aluno: ") 
 leia(media) 
 
 se media >= 7 entao 
 escreva("aprovado") 
 senao 
 se (media >= 5) e (media < 7) entao 
 escreva("exames de recuperação") 
 senao 
 escreva("reprovado") 
 fimse 
 fimse 
 
fimalgoritmo 
 
 
 
APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO 
32 
Livro versão 1.1 verifique se esta é a versão mais atualizada em www.criandocodigo.com.br 
 
Representação no diagrama de blocos: 
 
Figura 6.3 
6.2.4Decisão múltipla 
 
A estrutura de decisão múltipla é usada para avaliar o valor de uma determinada 
variável através da palavra-reservada escolha. A estrutura escolha aceita apenas constantes 
inteiras ou caracteres e testa sucessivamente esse valor contra uma lista até encontrar um 
valor que coincida. A sintaxe é a seguinte: 
 
escolha<expressão-de-seleção> 
caso<exp-1>, <exp-2>, ..., <exp-n> 
<sequência-de-comandos-1> 
caso<exp-1>, <exp-2>, ..., <exp-n> 
<sequência-de-comandos-2> 
. 
. 
. 
outrocaso 
<sequência-de-comandos-extra> 
fimescolha 
 
 A estrutura escolha recebe um valor inteiro ou caractere em <expressão-de-
seleção> e irá testá-lo na sequência de comandos caso até encontrar um valor que 
 
APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO 
33 
Livro versão 1.1 verifique se esta é a versão mais atualizada em www.criandocodigo.com.br 
 
coincida, ao encontrar executará a <sequência-de-comandos N> correspondente ao 
comando caso e em seguida encerrará a estrutura de decisão múltipla em fimescolha. O 
comando caso aceita múltiplas constantes do mesmo tipo do comando escolha. O comando 
outrocaso é opcional e é usado quando não há valor correspondente a <expressão-de-
seleção> durante a sequência dos comandos caso. A <sequência-de-comandos-
extra> será executada apenas se outrocaso estiver definido. A seguir um exemplo: 
 
algoritmo "Times" 
var 
 time: caractere 
inicio 
 escreva("Entre com o nome de um time de futebol: ") 
 leia(time) 
 
 escolha time 
 caso "Flamengo", "Fluminense", "Vasco", "Botafogo" 
 escreval("É um time carioca.") 
 caso "São Paulo", "Palmeiras", "Santos", "Corinthians" 
 escreval("É um time paulista.") 
 outrocaso 
 escreval("É de outro estado.") 
 fimescolha 
fimalgoritmo 
 
 
 
APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO 
34 
Livro versão 1.1 verifique se esta é a versão mais atualizada em www.criandocodigo.com.br 
 
 Representação no diagrama de blocos: 
 
 
Figura 6.4 
 
6.3 Estrutura de repetição 
 
Em vários momentos em que estiver programando surgirá a necessidade de efetuar a 
repetição de um trecho do código um determinado número vezes, para isso deverá utilizar 
uma estrutura de repetição. Essa estrutura também é conhecida como estrutura de laços, 
estrutura de iteração ou loops. 
 
6.3.1 Variável de controle 
 
Laços com variável de controle permitem a repetição de comandos através de 
contadores finitos de execuções. A estrutura de laços para repete uma sequência de 
comandos um determinado número de vezes. A seguir a sintaxe: 
 
para<variável>de<valor-inicial>ate<valor-limite> [passo<incremento>] 
faca 
<sequência-de-comandos> 
fimpara 
 
APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO 
35 
Livro versão 1.1 verifique se esta é a versão mais atualizada em www.criandocodigo.com.br 
 
 
<variável> é a variável contadora que controla o número de repetições do laço. Deve ser 
necessariamente uma variável do tipo inteiro, como todas as expressões deste comando. 
 
<valor-inicial> é uma expressão que especifica o valor de inicial da variável contadora antes 
da primeira repetição do laço. 
 
<valor-limite> é uma expressão que especifica o valor máximo que a variável contadora pode 
alcançar. 
 
<incremento> é opcional. Quando presente é uma expressão que especifica o incremento que 
será acrescentado à variável contadora em cada repetição do laço. Quando esta opção não é 
utilizada, o valor padrão de <incremento> é 1. É possível especificar valores negativos para 
<incremento>. 
 
fimpara Indica o fim da sequência de comandos a serem repetidos. Cada vez que o programa 
chega neste ponto, é acrescentado à variável contadora o valor de <incremento>, e 
comparado a <valor-limite>. 
 
<valor-inicial>, <valor-limite> e <incremento> são avaliados uma única vez antes da 
execução da primeira repetição, e não se alteram durante a execução do laço, mesmo que 
variáveis eventualmente presentes nessas expressões tenham seus valores alterados. No 
exemplo a seguir, os números de 1 a 10 são exibidos em ordem crescente: 
 
algoritmo "Números de 1 a 10" 
var 
 j: inteiro 
inicio 
 
 para j de 1 ate 10 faca 
 escreva(j) 
 fimpara 
 
fimalgoritmo 
 
No próximo exemplo os números de 1 a 10 são exibidos em ordem decrescente usando 
um laço negativo com o comando opcional passo. 
 
algoritmo "Números de 10 a 1" 
var 
 j: inteiro 
inicio 
 
 para j de 10 ate 1 passo -1 faca 
 escreva(j) 
 fimpara 
 
fimalgoritmo 
 
 
APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO 
36 
Livro versão 1.1 verifique se esta é a versão mais atualizada em www.criandocodigo.com.br 
 
 
 Representação no diagrama de blocos: 
 
 
Figura 6.5 
 
6.3.2 Laços condicionais 
 
São laços em que a variável que controla a repetição é testada no início ou no final. A 
repetição está condicionada a atualização da variável no interior do laço. Caso a variável não 
seja incrementada o laço nunca terminará, deixando o programa em loop infinito. 
 
6.3.2.1 Teste lógico no início do laço 
 
Estrutura de laço que realiza teste lógico no início do loop, verificando se o valor da 
expressão é VERDADEIRO antes da executar os comandos internos do loop. 
 
enquanto<expressão-lógica>faca 
<sequência-de-comandos> 
fimenquanto 
 
A estrutura enquanto avalia a <expressão-lógica> antes de iniciar a execução. Se 
o resultado da expressão for FALSO a <sequência-de-comandos> não será executada e o 
laço termina após fimenquanto. Caso seja VERDADEIRO será executada a sequência de 
comandos internos. Enquanto a <expressão-lógica> for VERDADEIRA a <sequência-
de-comandos> continuará sendo executada. Quando o resultado dessa expressão for FALSO 
o fluxo de execução do laço será interrompido e chegará ao próximo comando após 
fimenquanto. 
O mesmo exemplo anterior pode ser resolvido com esta estrutura de repetição: 
 
algoritmo "Números de 1 a 10 (com enquanto)" 
var 
 j: inteiro 
inicio 
 j <- 1 
 
APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO 
37 
Livro versão 1.1 verifique se esta é a versão mais atualizada em www.criandocodigo.com.br 
 
 
 enquanto j <= 10 faca 
 escreva(j) 
 j <- j + 1 
 fimenquanto 
 
fimalgoritmo 
 
 Representação no diagrama de blocos: 
 
 
Figura 6.6 
 
6.3.2.2 Teste lógico no final do laço 
 
Semelhante a estrutura enquanto, esta estrutura avalia a expressão lógica no final do 
laço para uma nova repetição, ou não, da execução da sequência dos comandos internos. A 
principal diferença é que esta estrutura executa pelo menos uma vez os comandos internos 
antes de verificar o resultado da expressão lógica. 
 
 
repita 
<sequência-de-comandos> 
ate<expressão-lógica> 
 
 A <sequência-de-comandos> será executada pelo menos uma vez, em seguida a 
<expressão-lógica> será testada e caso seja FALSA a sequência de comandos será 
executada novamente e esse procedimento irá se repetir até que a expressão lógica seja 
VERDADEIRA, e, com isso, causando a interrupção do laço. Considerando ainda o mesmo 
exemplo: 
 
algoritmo "Números de 1 a 10 (com repita)" 
var 
 j: inteiro 
inicio 
 j <- 1 
 
APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO 
38 
Livro versão 1.1 verifique se esta é a versão mais atualizada em www.criandocodigo.com.br 
 
 
 repita 
 escreva(j) 
 j <- j + 1 
 ate j > 10 
 
fimalgoritmo 
 
 Outra diferença em relação à estrutura enquanto é a possibilidade da variávelda 
<expressão-lógica> ser inicializada ou lida dentro laço antes de ser testada. 
 
 Representação no diagrama de dados: 
 
Figura 6.7 
 
 
 
6.3.3 Interrompendo as estruturas de laço 
 
As estruturas de repetição para, enquanto e repita permitem o uso do comando 
interrompa que causa uma saída imediata do laço. Seu uso é exemplificado a seguir: 
 
algoritmo "Números de 1 a 10 (com interrompa)" 
var 
 x: inteiro 
inicio 
 x <- 0 
 
 repita 
 x <- x + 1 
 escreva(x) 
 
 se x = 10 entao 
 interrompa 
 
APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO 
39 
Livro versão 1.1 verifique se esta é a versão mais atualizada em www.criandocodigo.com.br 
 
 fimse 
 ate falso 
 
fimalgoritmo 
 
 
6.4 Exercícios 
 
Desenvolva os algoritmos das questões a seguir. As resoluções dos exercícios estão no 
capítulo 9, no final deste livro. 
 
9. Entrar com um número e imprimir se ele está na faixa de 1 a 30 e qualquer outro número 
imprima uma mensagem dizendo que está fora da faixa. 
 
10. Ler uma entrada de caracteres que identifique as palavras azul, verde ou vermelho como 
uma cor primaria e qualquer outra palavra como cor desconhecida. 
 
11. Entrar com um número e imprimir se ele é par ou ímpar. 
 
12. Ler a entrada de um número e imprimir se ele é positivo, negativo ou nulo. 
 
13. Entrar com três números e armazenar o maior número em uma variável. 
 
14. Entrar com três números e imprimi-los em ordem crescente. 
 
15. Entrar com a idade de uma pessoa e informar se é maior de idade, menor de idade ou se 
é maior ou igual a 65 anos. 
 
16. Ler um número e escrever o nome do mês correspondente. 
 
17. Ler a entrada de três varáveis A, B e X. Somente será efetuado o cálculo de C <- 
(A+B)*X , se o valor da variável X não for maior que 3. Qualquer valor de 3 para cima efetua 
o cálculo C <- (A-B)*X. Utilize o operador NAO para este exercício. 
 
18. Entrar com uma temperatura em graus centígrados e exibi-la em Fahrenheit. A fórmula 
de conversão é𝐹 = 
9.𝐶 + 160
5
onde F é a temperatura em Fahrenheit e C é a temperatura em 
centígrados. 
 
19. Criar um algoritmo que calcule o Índice de Massa Corporal (IMC), usando a seguinte 
formula: 
IMC = 
𝑝𝑒𝑠𝑜
𝑎𝑙𝑡𝑢𝑟𝑎2
 
 
O usuário deve informa o peso em Kg e a altura em metros. O resultado do cálculo do IMC 
deve seguir a tabela abaixo: 
IMC Classificação 
 
APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO 
40 
Livro versão 1.1 verifique se esta é a versão mais atualizada em www.criandocodigo.com.br 
 
< 18,5 Magreza 
18,5 a < 25 Saudável 
25 a < 30 Sobrepeso 
> 30 Obesidade 
 
20. Crie um algoritmo que leia o dia, mês e ano e imprima se a data é válida ou não. 
 
21. Imprima todos os números de 1 até 100. 
 
22. Imprima todos os números de 100 até 1. 
 
23. Escreva um algoritmo que crie 30 números aleatórios entre 15 e 53 e imprima somente 
os números impares. Para gerar um número aleatório use a função RandI(limite) que recebe 
como parâmetro um número inteiro limite. 
 
24. Utilizando um laço crie um algoritmo que permita a entrada de 4 números reais e 
imprima a média aritmética. 
 
25. Imprima a tabuada de multiplicar (de 1 até 10) de um número qualquer. O número deve 
ser inserido pelo usuário. 
 
26. Utilizando a estrutura de seleção múltipla faça um algoritmo que simule uma calculadora 
de números inteiros que possua as quatro operações básicas. Permita que o usuário possa 
 sair seja pressionada. 
 
 
 
 
APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO 
41 
Livro versão 1.1 verifique se esta é a versão mais atualizada em www.criandocodigo.com.br 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
7 ESTRUTURAS DE DADOS HOMOGÊNEAS 
 
APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO 
42 
Livro versão 1.1 verifique se esta é a versão mais atualizada em www.criandocodigo.com.br 
 
7 Estrutura de dados homogêneas 
 
As estruturas de dados homogêneas agrupam várias informações do mesmo tipo de 
dado dentro de uma mesma variável. Por armazenarem o mesmo tipo de dado são chamadas 
de estruturas homogêneas. Essa estrutura de dados recebe outros nomes como: variáveis 
compostas, variáveis subscritas, variáveis indexadas, arranjos, matrizes, vetores, tabelas em 
memória ou arrays. 
 
7.1 Vetores 
 
São variáveis que tem o mesmo nome mas podem armazenar uma informação 
diferente do mesmo tipo. Conhecido como variável indexada, tabela ou array, uma variável 
vetor possui índices que indicam as posições onde o valor está armazenado. A figura 7.1 
representa um vetor: 
 
V = 5 2 7 1 0 8 3 
Figura 7.1 
 
 Podemos acessar os elementos do array através dos índices: 
 
Índice Elemento 
1 5 
2 2 
3 7 
4 1 
5 0 
6 8 
7 3 
 
Sintaxe de um vetor: 
 
<nome_da_variavel>:vetor[<coluna_inicial>..<coluna_final>]de<tipo_de
_dado> 
 
No exemplo a seguir inserimos valores diferentes em cada índice do vetor e em 
seguida percorremos o vetor com um laço e imprimimos cada valor com a função escreval: 
 
algoritmo "vetores" 
var 
 vet: vetor [1..10] de inteiro 
 j: inteiro 
inicio 
 vet[1] <- 5 
 vet[2] <- 2 
 vet[3] <- 7 
 vet[4] <- 41 
 vet[5] <- 3 
 vet[6] <- 10 
 
APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO 
43 
Livro versão 1.1 verifique se esta é a versão mais atualizada em www.criandocodigo.com.br 
 
 vet[7] <- 25 
 vet[8] <- 120 
 vet[9] <- 9 
 vet[10] <- 1 
 
 para j de 1 ate 10 faca 
 escreval(vet[j]) 
 fimpara 
 
fimalgoritmo 
 
7.2 Matrizes 
 
As matrizes são vetores bidimensionais que utilizam dois índices para representarem 
as linhas e colunas. Na figura 7.2 temos um exemplo de matriz 3x4: 
 
M = 4 10 9 6 
3 5 1 31 
6 32 42 8 
Figura 7.2 
 
Podemos acessar os elementos dos arrays através dos índices de linha e coluna: 
 
 1 2 3 4 
1 4 10 9 6 
2 3 5 1 31 
3 6 32 42 8 
 
 Sintaxe de uma matriz: 
 
<nome_da_variavel> :vetor [<linha_inicial> .. <linha_final>, 
<coluna_inicial> ..<coluna_final>] de<tipo_de_dado> 
 
No exemplo abaixo utilizamos dois laços para preencher cada posição da matriz com o 
valor zero. Observe que o laço mais externo percorre as linhas da matriz enquanto o outro 
laço percorre as colunas da matriz: 
 
algoritmo "Matrizes" 
var 
 matriz: vetor [1..3, 1..4] de inteiro 
 linha, coluna: inteiro 
inicio 
 
 // preenche a matriz com valores zero 
 para linha de 1 ate 3 faca 
 para coluna de 1 ate 4 faca 
 matriz[linha, coluna] <- 0 
 fimpara 
 
APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO 
44 
Livro versão 1.1 verifique se esta é a versão mais atualizada em www.criandocodigo.com.br 
 
 fimpara 
 
fimalgoritmo 
 
7.3 Exercícios 
 
Desenvolva os algoritmos das questões a seguir. As resoluções dos exercícios estão no 
capítulo 9, no final deste livro. 
 
27. Crie um algoritmo que permita a entrada de 4 nomes que serão armazenados em um 
vetor e imprima-os na ordem inversa usando um laço. 
 
28. Ler 10 nomes e armazene-os em um vetor e em seguida imprima os nomes em ordem 
crescente. 
 
29. Escreva um algoritmo que preencha uma matriz 10x10 com números inteiros aleatórios 
com valores entre 1 e 100 e imprima no formato de uma tabela. Para gerar um número 
aleatório use a função RandI(limite). 
 
30. Elabore um algoritmo que leia a entrada de um vetor A com 10 elementos. Construa um 
vetor B e preencha-o com os valores do vetorA multiplicados pelo número do índice. 
Imprima o vetor B em ordem decrescente. 
 
 
 
APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO 
45 
Livro versão 1.1 verifique se esta é a versão mais atualizada em www.criandocodigo.com.br 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
8 MODULARIZAÇÃO 
 
APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO 
46 
Livro versão 1.1 verifique se esta é a versão mais atualizada em www.criandocodigo.com.br 
 
8 Modularização 
 
A modularização é um processo que permite simplificar um problema complexo em 
partes menores. Consiste em dividir partes complexas do algoritmo em partes pequenas 
especializadas. 
 
8.1 Subprogramas 
 
Subprograma é um programa que auxilia o programa principal através da realização 
de uma determinada subtarefa. Também costuma receber os nomes de sub-rotina, 
procedimento, método ou módulo. Os subprogramas são chamados dentro do corpo do 
programa principal como se fossem comandos. Após seu término, a execução continua a 
partir do ponto onde foi chamado. É importante compreender que a chamada de um 
subprograma simplesmente gera um desvio provisório no fluxo de execução. 
 
8.2 Procedimentos 
 
É um subprograma que não retorna nenhum valor. Todas as variáveis declaradas no 
início do programa podem ser utilizadas nos procedimentos. Um procedimento pode ser 
declarado antes ou após a declaração das variáveis de um programa. Pode ser chamado em 
qualquer parte do código dentro do bloco de execução principal (entre as palavras-chave 
inicio e fimalgoritmo) ou em outro subprograma. 
 
Sintaxe de um procedimento: 
 
procedimento<nome-de-procedimento> [(<sequência-de-declarações-de-
parâmetros>)] 
// Seção de Declarações Internas 
inicio 
// Seção de Comandos 
fimprocedimento 
 
A expressão <nome-de-procedimento> obedece as mesmas regras de 
nomenclatura das variáveis. A [(<sequência-de-declarações-de-parâmetros>)] é 
um bloco de parâmetros separados por parênteses. Esses parâmetros são uma lista de 
definições de variáveis separadas por ponto e vírgula e que podem ser opcionais. Os 
parâmetros servem para passarmos valores para os subprogramas. 
 
Exemplo de um procedimento sem parâmetros: 
 
algoritmo "procedimento soma sem parâmetros" 
 
procedimento soma 
inicio 
 resultado <- x + y 
fimprocedimento 
 
 
APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO 
47 
Livro versão 1.1 verifique se esta é a versão mais atualizada em www.criandocodigo.com.br 
 
var 
 resultado, x, y: inteiro 
inicio 
 x <- 10 
 y <- 20 
 soma 
 escreva(resultado) 
fimalgoritmo 
 
O mesmo exemplo anterior, mas agora com os valores de x e y passados por 
parâmetros: 
 
algoritmo "procedimento soma com parâmetros" 
 
procedimento soma(x, y: inteiro) 
inicio 
 resultado <- x + y 
fimprocedimento 
 
var 
 resultado: inteiro 
inicio 
 soma(10, 20) 
 escreva(resultado) 
fimalgoritmo 
 
8.3 Funções 
 
 A função é um subprograma que retorna um valor. A declaração e a chamada dentro 
do programa são análogas ao procedimento. 
 
 Sintaxe de uma função: 
 
funcao<nome-de-função> [(<sequência-de-declarações-de parâmetros>)]: 
<tipo-de-dado> 
// Seção de Declarações Internas 
inicio 
// Seção de Comandos 
fimfuncao 
 
A expressão <nome-de-função> obedece as mesmas regras de nomenclatura das 
variáveis. A [(<sequência-de-declarações-de-parâmetros>)] é um bloco de 
parâmetros separados por parênteses. Esses parâmetros são uma lista de definições de 
variáveis separadas por ponto e vírgula e que podem ser opcionais. 
 
O valor retornado pela função será do tipo especificado na sua declaração <tipo-de-
dado>. Em alguma parte da função, este valor deve ser retornado através do comando 
retorne. 
 
 
APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO 
48 
Livro versão 1.1 verifique se esta é a versão mais atualizada em www.criandocodigo.com.br 
 
O mesmo exemplo do procedimento agora modificado para usar uma função: 
 
Algoritmo "função soma" 
 
funcao soma(x, y: inteiro): inteiro 
inicio 
 retorne x + y 
fimfuncao 
 
inicio 
 escreva(soma(10,20)) 
fimalgoritmo 
 
8.4 Variáveis locais e globais 
 
 Um subprograma pode ter suas próprias variáveis da mesma forma que um programa 
principal. As variáveis declaradas no início do algoritmo são chamadas de globais, elas são 
declaradas depois da palavra-chave var. As variáveis globais podem ser vistas em qualquer 
parte do programa principal e inclusive em todos os subprogramas. 
 Quando as variáveis são declaradas no início de um subprograma elas são chamadas 
de locais. Essas variáveis locais só podem ser usadas dentro do subprograma que as 
declarou. 
Exemplo de declaração de variáveis locais e globais: 
 
Algoritmo "variáveis globais e locais" 
 
funcao soma(x, y: inteiro): inteiro 
var 
 total: inteiro// variável local 
inicio 
 total <- x + y 
 retorne total 
fimfuncao 
 
var 
 total: inteiro// variável global 
inicio 
 total <- 40 + 30 
 escreval("Total da função: ", soma(10, 20)) 
 escreval("Total da variável global: ", total) 
fimalgoritmo 
 
 No exemplo acima temos duas variáveis de mesmo nome chamada total, uma 
declarada no início do programa (global) e outra declarada no início da função (local). A 
variável local da função soma não afetará a variável global. 
 
8.5 Passagem de parâmetros por referência 
 
 
APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO 
49 
Livro versão 1.1 verifique se esta é a versão mais atualizada em www.criandocodigo.com.br 
 
 Vimos anteriormente como criar subprogramas e como passar valores para eles 
através dos parâmetros. Os parâmetros são a comunicação entre o subprograma, o 
programa principal ou outro subprograma. 
Até agora passamos parâmetros apenas por valor. Quando colocamos um valor 
qualquer como parâmetro de um subprograma estamos enviando apenas uma cópia, esse 
parâmetro não é alterado em sua origem. Ao passar um parâmetro por referência qualquer 
alteração desse parâmetro dentro do subprograma será devolvida ao programa chamador, 
alterando a variável em sua origem. Veja o exemplo a seguir: 
 
Algoritmo "parâmetro por valor" 
 
procedimento soma(A: inteiro) 
inicio 
 A <- A + 1 
fimprocedimento 
 
var 
 X: inteiro 
inicio 
 X <- 1 
 escreva("Valor de X antes da função soma: ", X) 
 soma(X) 
 escreva("Valor de X depois da função soma: ", X) 
fimalgoritmo 
 
No exemplo passamos por valor a variável X como parâmetro do subprograma soma. 
Ao executar o programa notamos que o valor de X não foi alterado. 
No próximo exemplo passamos a variável X por referência ao acrescentarmos a 
palavra-reservada var. Ao executar o programa veremos que o valor de X foi alterado no 
retorno da função. 
 
Algoritmo "parâmetro por referência" 
 
procedimento soma(var A: inteiro) 
inicio 
 A <- A + 1 
fimprocedimento 
 
var 
 X: inteiro 
inicio 
 X <- 1 
 escreva("Valor de X antes da função soma: ", X) 
 soma(X) 
 escreva("Valor de X depois da função soma: ", X) 
fimalgoritmo 
 
8.6 Funções do VisuAlg 
 
 Nesta seção trazemos algumas funções do VisuAlg. 
 
 
APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO 
50 
Livro versão 1.1 verifique se esta é a versão mais atualizada em www.criandocodigo.com.br 
 
escreva(<lista-de-expressões>) Este comando escreve no dispositivo de saída padrão o 
conteúdo de cada uma das expressões que compõem <lista-de-expressões>.As expressões 
devem estar separadas por vírgulas; depois de serem avaliadas, seus resultados são 
impressos na ordem indicada. Exemplos: 
 
escreva("visualg") 
escreva(x) 
escreva("123", x, y, z, "abc") 
escreva("aluno: ", nome, "idade: ", numero) 
 
escreval(<lista-de-expressões>) Idem ao anterior, com uma única diferença que pula uma 
linha em seguida. 
 
leia(<lista-de-variáveis>) Este comando recebe valores digitados pelos usuários, 
atribuindo-os às variáveis cujos nomes estão em <lista-de-variáveis> (é respeitada a ordem 
especificada nesta lista). Exemplos: 
 
leia(x) 
leia(nome) 
leia(rua, endereco, x, y) 
 
 
Funções para manipulação de cadeias de caracteres (strings) 
 
Asc (s: caracter) - Retorna um inteiro com o código ASCII do primeiro caracter da expressão. 
 
Carac (c: inteiro) - Retorna o caractere cujo código ASCII corresponde à expressão. 
 
Caracpnum (c: caracter) - Retorna o inteiro ou real representado pela expressão. 
 
Compr (c: caracter) - Retorna um inteiro contendo o comprimento (quantidade de 
caracteres) da expressão. 
 
Copia (c: caracter; p, n: inteiro) - Retorna um valor do tipo caracter contendo uma cópia 
parcial da expressão, a partir do caracter p, contendo n caracteres. Os caracteres são 
numerados da esquerda para a direita, começando de 1. 
 
Maiusc (c: caracter) - Retorna um valor caracter contendo a expressão em maiúsculas. 
 
Minusc (c: caracter) - Retorna um valor caracter contendo a expressão em minúsculas. 
 
Numpcarac (n: inteiro ou real) - Retorna um valor caracter contendo a representação de n 
como uma cadeia de caracteres. 
 
 
APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO 
51 
Livro versão 1.1 verifique se esta é a versão mais atualizada em www.criandocodigo.com.br 
 
Pos (subc, c: caracter) - Retorna um inteiro que indica a posição em que a cadeia subc se 
encontra em c, ou zero se subc não estiver contida em c. 
 
 
Funções numéricas, algébricas e trigonométricas 
 
Abs(expressão) - Retorna o valor absoluto de uma expressão do tipo inteiro ou real. Equivale 
a | expressão | na álgebra. 
 
ArcCos(expressão) - Retorna o ângulo (em radianos) cujo cosseno é representado por 
expressão. 
 
ArcSen(expressão) - Retorna o ângulo (em radianos) cujo seno é representado por 
expressão. 
 
ArcTan(expressão) - Retorna o ângulo (em radianos) cuja tangente é representada por 
expressão. 
 
Cos(expressão) - Retorna o cosseno do ângulo (em radianos) representado por expressão. 
 
CoTan(expressão) - Retorna a co-tangente do ângulo (em radianos) representado por 
expressão. 
 
Exp( base, expoente) - Retorna o valor de base elevado a expoente, sendo ambos expressões 
do tipo real. 
 
GraupRad(expressão) - Retorna o valor em radianos, correspondente ao valor em graus 
representado por expressão. 
 
Int(expressão) - Retorna a parte inteira do valor representado por expressão. 
 
Log(expressão) - Retorna o logaritmo na base 10 do valor representado por expressão. 
 
LogN(expressão) - Retorna o logaritmo neperiano (base e) do valor representado por 
expressão. 
 
Pi - Retorna o valor 3.141592. 
 
Quad(expressão) - Retorna quadrado do valor representado por expressão. 
 
RadpGrau(expressão) - Retorna o valor em graus correspondente ao valor em radianos, 
representado por expressão. 
 
RaizQ(expressão) - Retorna a raiz quadrada do valor representado por expressão. 
 
 
APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO 
52 
Livro versão 1.1 verifique se esta é a versão mais atualizada em www.criandocodigo.com.br 
 
Rand - Retorna um número real gerado aleatoriamente, maior ou igual a zero e menor que 
um. 
 
RandI(limite) - Retorna um número inteiro gerado aleatoriamente, maior ou igual a zero e 
menor que limite. 
 
Sen(expressão) - Retorna o seno do ângulo (em radianos) representado por expressão. 
 
Tan(expressão) - Retorna a tangente do ângulo (em radianos) representado por expressão. 
 
 
8.7 Exercícios 
 
Desenvolva os algoritmos das questões a seguir. As resoluções dos exercícios estão no 
capítulo 9, no final deste livro. 
 
31. Escreva um algoritmo que receba dois números reais e uma função chamada maior que 
retorne o maior número entre dois números passados por parâmetro. 
 
32. Elabore um algoritmo que tenha uma função para calcular e retornar o valor de uma 
potência de um número qualquer. A função receberá dois parâmetros, o primeiro será a base 
e o segundo o expoente, onde p1 será elevado a p2. Use o operador de exponenciação para 
efetuar o cálculo. O usuário deve fornecer os dois números reais para função. 
 
33. Elabore um algoritmo que tenha um subprograma do tipo função que retorne o fatorial 
de um número inteiro qualquer. Fatorial é o produto dos números naturais desde 1 até o 
inteiro n. Por exemplo, no fatorial de 5 temos que 5! = 5 x 4 x 3 x 2 x 1 ou seja 5! = 120. 
 
34. Criar um algoritmo com uma função que receba uma string como parâmetro e retorne 
uma nova string. Essa nova string terá o mesmo conteúdo da string do parâmetro com a 
primeira letra modificada para ficar maiúscula. Para realizar este exercício você precisará 
das seguintes funções do VisuAlg: Maiusc(c: caracter) e Copia(c: caracter; p, n: inteiro). 
 
 
 
APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO 
53 
Livro versão 1.1 verifique se esta é a versão mais atualizada em www.criandocodigo.com.br 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
9 RESOLUÇÃO DOS EXERCÍCIOS 
 
APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO 
54 
Livro versão 1.1 verifique se esta é a versão mais atualizada em www.criandocodigo.com.br 
 
9 Resolução dos exercícios 
 
 
Capítulo 5 
 
1. 
algoritmo "exercício 1" 
var 
 num1, num2: inteiro 
inicio 
 escreval("Entre com um número: ") 
 leia(num1) 
 escreval("Entre com outro número: ") 
 leia(num2) 
 escreval(num1, "", num2) 
fimalgoritmo 
 
 
2. 
algoritmo "exercício 2" 
var 
 produto: inteiro 
inicio 
 produto <- 15 * 36 
 escreva(produto) 
fimalgoritmo 
 
 
3. 
algoritmo "exercício 3" 
var 
 media: real 
inicio 
 media <- (4 + 5 + 2) / 3 
 escreva("Média aritmética é: ", media) 
fimalgoritmo 
 
 
4. 
algoritmo "exercício 4" 
var 
 nome, endereço, telefone: caractere 
inicio 
 escreva("Entre com nome: ") 
 leia(nome) 
 escreva("Entre com endereço: ") 
 leia(telefone) 
 escreva("Entre com telefone: ") 
 leia(telefone) 
 escreval("Nome: ", nome) 
 escreval("Endereço: ", endereco) 
 
APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO 
55 
Livro versão 1.1 verifique se esta é a versão mais atualizada em www.criandocodigo.com.br 
 
 escreval("Telefone ", telefone) 
fimalgoritmo 
 
 
5 
algoritmo "exercício 5" 
var 
 X, Y, aux: inteiro 
inicio 
 escreva("Digite o número X: ") 
 leia(X) 
 escreva("Digite o número Y: ") 
 leia(Y) 
 aux<- X 
 X <- Y 
 Y <- aux 
 escreval("X: ", X) 
 escreval("Y: ", Y) 
fimalgoritmo 
 
 
6. 
algoritmo "exercício 6" 
var 
 A, B, C, X: real 
inicio 
 escreva("Entre com o número A: ") 
 leia(A) 
 escreva("Entre com o número B: ") 
 leia(B) 
 escreva("Entre com o número C: ") 
 leia(C) 
 X <- (A + B + C) ^ 2 
 escreva("Valor de X é ", X) 
fimalgoritmo 
 
 
7. 
algoritmo "exercício 7" 
var 
 num, den: inteiro 
 res: real 
inicio 
 escreva("Entre com o numerador: ") 
 leia(num) 
 escreva("Entre com o denominador: ")leia(den) 
 res <- num / den 
 escreva("resultado: ", res) 
fimalgoritmo 
 
 
 
APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO 
56 
Livro versão 1.1 verifique se esta é a versão mais atualizada em www.criandocodigo.com.br 
 
8. 
algoritmo "exercício 8" 
var 
 num1, num2, quoc, rest: inteiro 
inicio 
 escreval("Entre com dividendo: ") 
 leia(num1) 
 escreval("Entre com divisor: ") 
 leia(num2) 
 quoc <- num1 / num2 
 rest <- num1 % num2 
 escreval("quociente: ", quoc) 
 escreval("resto: ", rest) 
fimalgoritmo 
 
 
Capítulo 6 
 
9. 
algoritmo "exercício 9" 
var 
 numero: inteiro 
inicio 
 leia(numero) 
 
 se (numero>= 1) e (numero<= 30) entao 
 escreva("Número está dentro da faixa de 1 a 30") 
 senao 
 escreva("Número está fora da faixa de 1 a 30") 
 fimse 
fimalgoritmo 
 
 
10. 
algoritmo "exercício 10" 
var 
 cor: caractere 
inicio 
 leia(cor) 
 
 se (cor = "azul") ou (cor = "verde") ou (cor = "vermelho") entao 
 escreva("cor primária") 
 senao 
 escreva("cor desconhecida") 
 fimse 
fimalgoritmo 
 
 
 
 
 
 
APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO 
57 
Livro versão 1.1 verifique se esta é a versão mais atualizada em www.criandocodigo.com.br 
 
11. 
algoritmo "exercício 11" 
var 
 num: inteiro 
inicio 
 escreva("Digite um número: ") 
 leia(num) 
 se num % 2 = 0 entao 
 escreval("Par") 
 senao 
 escreval("Impar") 
 fimse 
fimalgoritmo 
 
 
12. 
algoritmo "exercício 12" 
var 
 num: real 
inicio 
 escreva("Digite um número: ") 
 leia(num) 
 se num > 0 entao 
 escreval("Positivo") 
 senao 
 se num < 0 entao 
 escreval("Negativo") 
 senao 
 escreval("Nulo") 
 fimse 
 fimse 
fimalgoritmo 
 
 
13. 
algoritmo "exercício 13" 
var 
 a, b, c, maior: real 
inicio 
 escreva("Digite um número: ") 
 leia(a) 
 escreva("Digite outro número: ") 
 leia(b) 
 escreva("Digite mais um número: ") 
 leia(c) 
 
 maior <- a 
 se b > maior entao 
 maior <- b 
 fimse 
 se c > maior entao 
 maior <- c 
 fimse 
 
APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO 
58 
Livro versão 1.1 verifique se esta é a versão mais atualizada em www.criandocodigo.com.br 
 
 escreva("maior número: ", maior) 
fimalgoritmo 
 
 
14. 
algoritmo "exercício 14" 
var 
 a, b, c, aux: real 
inicio 
 escreva("Digite um número: ") 
 leia(a) 
 escreva("Digite outro número: ") 
 leia(b) 
 escreva("Digite mais outro número: ") 
 leia(c) 
 
 se a > b entao 
 aux <- a 
 a <- b 
 b <- aux 
 fimse 
 se a > c entao 
 aux<- a 
 a <- c 
 c <- aux 
 fimse 
 se b > c entao 
 aux<- b 
 b <- c 
 c <- aux 
 fimse 
 escreval("Ordem crescente: ", a, "", b, "", c) 
fimalgoritmo 
 
 
15. 
algoritmo "exercício 15" 
var 
 idade: inteiro 
inicio 
 escreva("Digite sua idade: ") 
 leia(idade) 
 se idade >= 65 entao 
 escreva("maior de 65 anos") 
 senao 
 se idade >= 18 entao 
 escreva("maior de idade") 
 senao 
 escreva("menor de idade") 
 fimse 
 fimse 
fimalgoritmo 
 
 
APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO 
59 
Livro versão 1.1 verifique se esta é a versão mais atualizada em www.criandocodigo.com.br 
 
16. 
algoritmo "exercício 16" 
var 
 mes: inteiro 
inicio 
 escreva("Digite o número do mês: ") 
 leia(mes) 
 
 escolha mes 
 caso 1 
 escreva("janeiro") 
 caso 2 
 escreva("fevereiro") 
 caso 3 
 escreva("março") 
 caso 4 
 escreva("abril") 
 caso 5 
 escreva("maio") 
 caso 6 
 escreva("junho") 
 caso 7 
 escreva("julho") 
 caso 8 
 escreva("agosto") 
 caso 9 
 escreva("setembro") 
 caso 10 
 escreva("outubro") 
 caso 11 
 escreva("novembro") 
 caso 12 
 escreva("dezembro") 
 outrocaso 
 escreva("mês inexistente") 
 fimescolha 
fimalgoritmo 
 
 
17. 
algoritmo "exercício 17" 
var 
 A, B, C, X: inteiro 
inicio 
 leia(A, B, X) 
 
 se nao(X > 3) entao 
 C <- (A + B) * X 
 senao 
 C <- (A - B) * X 
 fimse 
 
 escreva(C) 
 
APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO 
60 
Livro versão 1.1 verifique se esta é a versão mais atualizada em www.criandocodigo.com.br 
 
fimalgoritmo 
 
 
18. 
algoritmo "exercício 18" 
var 
 f, c: real 
inicio 
 escreva("Entre com o valor da temperatura em graus centigrados: ") 
 leia(c) 
 f <- (9 * c + 160) / 5 
 escreval("O valor da temperatura em graus fahrenheit é: ", f) 
fimalgoritmo 
 
 
19. 
algoritmo "exercício 19" 
var 
 peso, altura, imc: real 
inicio 
 escreva("Digite o peso: ") 
 leia(peso) 
 escreva("Digite a altura: ") 
 leia(altura) 
 imc <- peso / altura ^ 2 
 
 se imc < 18.5 entao 
 escreva("Magreza") 
 senao 
 se imc < 25 entao 
 escreva("Saudável") 
 senao 
 se imc < 30 entao 
 escreva("Sobrepeso") 
 senao 
 se imc > 30 entao 
 escreva("Obesidade") 
 fimse 
 fimse 
 fimse 
 fimse 
fimalgoritmo 
 
 
20. 
algoritmo "exercício 20" 
var 
 dia, mes, ano: real 
 val: logico 
inicio 
 escreva("Digite o dia: ") 
 leia(dia) 
 
APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO 
61 
Livro versão 1.1 verifique se esta é a versão mais atualizada em www.criandocodigo.com.br 
 
 escreva("Digite o mês: ") 
 leia(mes) 
 escreva("Digite o ano: ") 
 leia(ano) 
 
 se ano >= 1 entao 
 val <- verdadeiro 
 se (mes< 1) ou (mes> 12) ou (dia < 1) ou (dia > 31) entao 
 val <- falso 
 senao 
 se (mes = 4) ou (mes = 6) ou (mes = 9) ou (mes = 11) e (dia > 30) entao 
 val<- falso 
 senao 
 se mes = 2 entao 
 se (ano % 4 = 0) e (ano % 100 <> 0) ou (ano % 400 = 0) entao 
 se dia > 29 entao 
 val <- falso 
 fimse 
 senao 
 se dia > 28 entao 
 val <- falso 
 fimse 
 fimse 
 fimse 
 fimse 
 fimse 
 senao 
 val<- falso 
 fimse 
 
 se val = falso entao 
 escreva("data inválida") 
 senao 
 escreva("data válida") 
 fimse 
fimalgoritmo 
 
 
21. 
algoritmo "exercício 21" 
var 
 i: inteiro 
inicio 
 para i de 1 ate 100 
 escreval(i) 
 fimpara 
fimalgoritmo 
 
 
22. 
algoritmo "exercício 22" 
var 
 i: inteiro 
 
APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO 
62 
Livro versão 1.1 verifique se esta é a versão mais atualizada em www.criandocodigo.com.br 
 
inicio 
 para i de 100 ate 1 passo -1 faca 
 escreval(i) 
 fimpara 
fimalgoritmo 
 
 
23. 
Algoritmo "exercício 23" 
var 
 i, r: inteiro 
inicio 
 para i de 1 ate 30 faca 
 r <- randi(53) + 15 
 
 se r % 2 <> 0 entao 
 escreval(r) 
 fimse 
 
 fimpara 
Fimalgoritmo 
 
 
24. 
algoritmo "exercício 24" 
var 
 i, num, total: real 
inicio 
 total <- 0 
 
 para i de 1 ate 4 faca 
 leia(num) 
 total <- total + num 
 fimpara 
 
 escreva("Média: ", total / 4) 
fimalgoritmo 
 
 
25. 
algoritmo "exercício 25" 
var 
 i, x: inteiro 
inicio