Ebook v1.1 5952472

APRENDA A
PROGRAMAR
DO ZERO
LÓGICA DE PROGRAMAÇÃO
DANIEL G. SOUTO
EDUARDO M. SILVA
WWW.CRIANDOCODIGO.COM.BR Criando
C ó 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
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.
Conceito de algoritmo formalizado por Alan Turing e Alonzo Church em 1936

1
APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO

Livro versão 1.1 verifique se esta é a versão mais atualizada em www.criandocodigo.com.br 8
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
Portugol é a união entre Português + ALGOL (significa AlgorithmicLanguage, é uma linguagem de

2
programação voltada para aplicações científicas criada em 1958)

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, sistema ou 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

incluídas na diagramação.
Conector utilizado
para conectar pares.
Figura 1.1 Formas geométricas

Exemplo:
Figura 1.2 Diagrama do pseudocódigo

2 MEMÓRIA, TIPOS DE DADOS E VARIÁVEIS

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

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.

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:
nota <- 7.5 (nota recebe 7.5)

Y <- 1
Z <- 2
X <- Y + Z
X <- X + 1
nome <- "Maria"
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

nome <- "Maria"
nota <- 7.5
Y <- 1
Z <- 2
X <- Y + Z
X <- X + 1
resposta <- falso
fimalgoritmo

3 COMENTÁRIOS

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 VisuAlg ele 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

4 VISUALG

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.

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

5 OPERADORES

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

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:
𝑥+𝑦
[ + (10 𝑥 4)] + 18
2
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

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 Resultado

Falso 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.

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.

Falso Falso Falso
Verdadeiro Falso Verdadeiro
Falso Verdadeiro Verdadeiro
Verdadeiro Verdadeiro Falso

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.

6 ESTRUTURAS DE CONTROLE

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

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
senao
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:

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.
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

senao
se <expressão-lógica-2> entao
senao
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

Figura 6.3
6.2.4 Decisã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

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

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
fimpara

<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

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
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

enquanto j <= 10 faca
escreva(j)
j <- j + 1
fimenquanto
fimalgoritmo
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
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

repita
escreva(j)
j <- j + 1
ate j > 10
fimalgoritmo
Outra diferença em relação à estrutura enquanto é a possibilidade da variável da

<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

fimse
ate falso
fimalgoritmo
6.4 Exercícios

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
9.𝐶 + 160
de conversão é𝐹 = onde F é a temperatura em Fahrenheit e C é a temperatura em
5
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

< 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.

7 ESTRUTURAS DE DADOS HOMOGÊNEAS

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

vet[7] <- 25
vet[8] <- 120
vet[9] <- 9
vet[10] <- 1

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

fimpara
fimalgoritmo
7.3 Exercícios

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 vetor A multiplicados pelo número do índice.
Imprima o vetor B em ordem decrescente.

8 MODULARIZAÇÃO

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

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.

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

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.

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.

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.

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

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).

9 RESOLUÇÃO DOS EXERCÍCIOS

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.
var
produto: inteiro
inicio
produto <- 15 * 36
escreva(produto)
fimalgoritmo
3.
var
media: real
inicio
media <- (4 + 5 + 2) / 3
escreva("Média aritmética é: ", media)
fimalgoritmo
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)

escreval("Telefone ", telefone)
fimalgoritmo
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.
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.
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

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.
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.
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

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.
var
num: real
inicio
leia(num)
se num > 0 entao
escreval("Positivo")
senao
se num < 0 entao
escreval("Negativo")
senao
escreval("Nulo")
fimse
fimse
fimalgoritmo
13.
var
a, b, c, maior: real
inicio
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

escreva("maior número: ", maior)
fimalgoritmo
14.
var
a, b, c, aux: real
inicio
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.
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

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.
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)

fimalgoritmo
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.
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.
var
dia, mes, ano: real
val: logico
inicio
escreva("Digite o dia: ")
leia(dia)

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.
var
i: inteiro
inicio
para i de 1 ate 100
escreval(i)
fimpara
fimalgoritmo
22.
var
i: inteiro

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.
var
i, num, total: real
inicio
total <- 0

leia(num)
total <- total + num
fimpara
escreva("Média: ", total / 4)

fimalgoritmo
25.
var
i, x: inteiro
inicio
leia(x)

escreval(x, " x", i, " = ", x * i)
fimpara
fimalgoritmo

26.
var
operador: caractere
x, y: inteiro
inicio
repita
escreval("Entre com dois números: ")
leia(x, y)
escreval("Digite a operação desejada:")

escreval("+ para somar")
escreval("- para subtrair")
escreval("/ para dividir")
escreval("* para multiplicar")
escreval("s para sair")
leia(operador)
se operador <> "s" então

escolha operador
caso "+"
escreval("resultado : ", x + y)
caso "-"
escreval("resultado : ", x - y)
caso "/"
escreval("resultado : ", x / y)
caso "*"
escreval("resultado : ", x * y)
outrocaso
escreval("comando não reconhecido")
fimescolha
fimse
ate operador = "s"
fimalgoritmo
Capítulo 7
27.
var
vnome: vetor [1..4] de caractere
nome: caractere
i: inteiro
inicio
escreva("Entre com um nome: ")
leia(nome)
vnome[i] <- nome
fimpara

para i de 4 ate 1 passo -1 faca
escreval(vnome[i])
fimpara
fimalgoritmo
28.
algoritmo "exercicio 28"
var
nome: vetor[1..10] de caractere
i, j: inteiro
X: caractere
inicio
escreva("Digite o nome ",i,": ")
leia(nome[i])
fimpara

para j de i+1 ate 10 faca
se nome[i] > nome[j] entao
X <- nome[i]
nome[i] <- nome[j]
nome[j] <- X
fimse
fimpara
fimpara

escreval(i, " ", nome[i])
fimpara
fimalgoritmo
29.
var
numeros: vetor[1..10, 1..10] de inteiro
i, j: inteiro
inicio
numeros[i,j] <- RandI(100) + 1
escreva(numeros[i,j], " ")
fimpara
escreval()
fimpara
fimalgoritmo
30.
var
A, B: vetor[1..12] de inteiro

i, j, aux: inteiro
inicio
escreva("Insira elemento ", i , ": ")
leia(A[i])
B[i] <- A[i] * i
fimpara

para j de i+1 ate 12 faca
se B[i] < B[j] entao
aux<- B[i]
B[i] <- B[j]
B[j] <- aux
fimse
fimpara
fimpara

escreval(B[i])
fimpara
fimalgoritmo
Capítulo 8
31.
funcao maior(n1, n2: real): real

inicio
se n1 > n2 entao
retorne n1
senao
retorne n2
fimse
fimfuncao
var
num1, num2: real
inicio
escreva("Entre com número 1: ")
leia(num1)
escreva("Entre com número 2: ")
leia(num2)
escreva(maior(num1, num2))
fimalgoritmo

32.
funcao potencia(p1, p2: real): real

var
inicio
retorne p1 ^ p2
fimfuncao
var
num, pot: real
inicio
escreva("Entre com um número: ")
leia(num)
escreva("Entre o valor da potência: ")
leia(pot)
escreva("resultado: ", potencia(num, pot))
fimalgoritmo
33.
funcao fatorial(n: inteiro):inteiro

var
i, fat: inteiro
inicio
fat <- 1
para i de 1 ate n faca
fat <- fat * i
fimpara
retorne fat
fimfuncao
var
num: inteiro
inicio
escreva("Entre com um número: ")
leia(num)
escreva("Fatorial de", num, ": ", fatorial(num))
fimalgoritmo
34.
funcao maiusculo(txt: caractere): caractere

var
primeira_letra, novo_txt: caractere
inicio
primeira_letra <- copia(txt, 1, 1)

novo_txt <- Maiusc(primeira_letra) + copia(txt, 2, compr(txt) - 1)
retorne novo_txt
fimfuncao
var
txt: caractere
inicio
escreva("Entre com um texto: ")
leia(txt)
escreva(maiusculo(txt))
fimalgoritmo


Ebook v1.1 5952472

Caricato da

Informazioni sul documento

Descrizione originale:

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Ebook v1.1 5952472

Caricato da

Copyright:

Formati disponibili

APRENDA A

Analista graduado em Sistemas de Informação pela Universidade

Expert nas linguagens C, C++, Java, Object Pascal (Delphi) e

Graduado em Sistemas de Informação pela Universidade

Possui mais de 10 anos de experiência em desenvolvimento web

Atualmente é empresário no segmento de automação comercial

Todos os nomes de marcas, produtos e serviços

Este livro é destinado a pessoas interessadas em aprender a programar, mas que

Os capítulos estão organizados de maneira que o estudante possa evoluir

Desenvolver o raciocínio lógico para encontrar soluções é a parte mais importante

Verifique no site www.criandocodigo.com.br se você está com a versão atualizada

Atualizamos constantemente a versão deste livro com as mais atuais e avançadas

1.1 Lógica de programação

A lógica de programação é a técnica que tem como objetivo desenvolver algoritmos

Algoritmo é uma palavra derivada do nome Mohammed ibn Musa Al-Khowarizmique,

• Sequenciação: São os passos de processamento que descrevem um programa:

Um algoritmo é dividido em três partes: Entrada, processamento e saída.

2. Um dado é qualquer registro que não esteja contextualizado, organizado ou

Conceito de algoritmo formalizado por Alan Turing e Alonzo Church em 1936

APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO

1.3.1 Descrição narrativa

Na descrição narrativa os algoritmos são expressos em linguagem natural em

• Algoritmo para fritar um ovo

1. Retire o ovo da geladeira.

O pseudocódigo, também conhecido por pseudo-linguagem, é uma representação da

algoritmo "calculo da média"

Portugol é 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

1.3.3 Diagrama de bloco

É uma representação esquemática de um processo, sistema ou algoritmo. Um

APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO

Figura 1.1 Formas geométricas

Figura 1.2 Diagrama do pseudocódigo

APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO

APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO

A memória do computador é o componente eletrônico capaz de armazenar as

Endereço Variável Valor

Os nomes das variáveis, funções e outros componentes adicionados a um programa

APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO

2.2 Tipos de dados primitivos

Variáveis e constantes são os espaços na memória que armazenam valores. Para um

São tipos de dados numéricos positivos ou negativos sem qualquer número

São tipos de dados numéricos positivos, negativos e números fracionados: Exemplos:

APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO

nota <- 7.5 (nota recebe 7.5)

Para declarar uma variável no VisuAlg usamos as seguintes palavras-chave:

• inteiro: Tipos numéricos inteiros

A <lista-de-variáveis> suporta a inserção de um nome ou vários nomes

APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO

APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO

APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO

// esta linha é um comentário

APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO

APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO

Figura 4.1 Tela principal do VisuAlg

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.

APRENDA A PROGRAMAR DO ZERO - LÓGICA DE PROGRAMAÇÃO

Liga/desliga breakpoint: Insere/remove um ponto de parada na linha em que esteja o

Desmarcar todos os breakpoints: Desativa todos os breakpoints que estejam

Gerar valores aleatórios: Ativa a geração de valores aleatórios que substituem a