Lógica de programação com visu alg

CEET
Apostila organizada, a partir dos textos
originais disponibilizados pelo prof. Cláudio
Morgado de Souza, no site
Hhttp://www.apoioinformatica.inf.br/H
Pelo professor

Disciplina de Lógica de programação
Editor e Interpretador de Pseudocódigos
Objetivos
Apresentação do VisuaAlg pelo prof. Cláudio Morgado de Souza.
A idéia de escrever este programa nasceu a partir de uma necessidade: uma ferramenta que
permitisse aos alunos iniciantes em programação o exercício dos seus conhecimentos num
ambiente próximo da realidade. Em minha experiência como professor desta disciplina, tenho
notado que a abstração de "rodar o chinês", ou seja, de executar um programa apenas no
papel, é um grande obstáculo (quase intransponível para alguns) no aprendizado das técnicas
de elaboração de algoritmos. Por outro lado, submeter um iniciante aos rigores de uma
linguagem de programação como Pascal ou ao “esoterismo” do C também me parecia
exagerado. O ideal seria uma linguagem mais simples, parecida com o "Portugol", de grande
popularidade nos meios acadêmicos e presente nos livros mais utilizados; com ela, os
princípios básicos da programação estruturada poderiam ser ensinados sem que a curva de
aprendizagem fosse íngreme. Além disso, esta ferramenta deveria também ser capaz de
simular o que acontece na tela do computador com o uso dos famosos comandos "leia" e
"escreva", bem como possibilitar a verificação dos valores das variáveis, o acompanhamento
passo a passo da execução de um algoritmo (pelo seu grande valor didático), e até mesmo
suportar um modo simples de depuração. Aliado a tudo isto, deveria estar um editor de texto
com recursos razoáveis (tais como abrir e salvar arquivos) e que dispusesse de todos os
principais recursos de um ambiente gráfico.
O VisuAlg é para mim a concretização desta idéia. Espero que, colocando-o em domínio
público (numa versão freeware), possa ajudar professores e alunos de programação, e também
ser ajudado por eles através de sugestões e críticas que visem sempre a sua melhoria. A idéia
básica é manter o VisuAlg simples: deve ser como as rodinhas de apoio que uma criança usa
ao aprender a andar de bicicleta, e que são retiradas quando deixam de ser necessárias. Isto
não quer dizer que o VisuAlg não possa ou deva ser melhorado: conto com a colaboração de
todos que vierem a utilizá-lo.
Instalação e Requerimentos de Hardware
O VisuAlg é um programa simples, que não depende de DLLs, OCXs ou outros componentes.
Sua instalação não copia arquivos para nenhuma outra pasta a não ser aquela em que for
instalado, e exige cerca de 1 MB de espaço em disco. Pode ser executado sob Windows 95 ou
posterior, e tem melhor aparência com resolução de vídeo de 800x600 ou maior.
Conheça o VisuAlg
A Tela Principal do VisuAlg
O menu do programa
A linguagem de programação do VisuAlg
Referências da linguagem do VisuAlg
Auto-digitação e sugestão de digitação
Criado por Reinaldo 2-72

A Tela Principal do VisuAlg
A tela do VisuAlg compõe-se da barra de tarefas, do editor de textos (que toma toda a sua
metade superior), do quadro de variáveis (no lado esquerdo da metade inferior), do simulador
de saída (no correspondente lado direito) e da barra de status. Quando o programa é
carregado, já apresenta no editor um "esqueleto" de pseudocódigo, com a intenção de poupar
trabalho ao usuário e de mostrar o formato básico que deve ser seguido. Explicaremos a seguir
cada componente da interface do VisuAlg.
A Barra de Tarefas
Contém os comandos mais utilizados no VisuAlg (estes comandos também podem ser
acessados pelo menu ou por atalhos no teclado).

Abrir (Ctrl-A): Abre um arquivo anteriormente gravado, substituindo o texto presente no editor.
Se este tiver sido modificado, o VisuAlg pedirá sua confirmação para salvá-lo antes que seja
sobreposto.
Novo (Ctrl-N): Cria um novo "esqueleto" de pseudocódigo, substituindo o texto presente no
editor. Se este tiver sido modificado, o VisuAlg pedirá sua confirmação para salvá-lo antes que
seja sobreposto.
Salvar (Ctrl-S): Grava imediatamente o texto presente no editor. Na primeira vez que um novo
texto é gravado, o VisuAlg pede seu nome e localização.
Imprimir: Imprime imediatamente na impressora padrão o texto presente no editor. Para
configurar a impressão, use o comando Imprimir do menu Arquivo (acessível também pelo
atalho Ctrl-P).
Cortar (Ctrl-X): Apaga texto selecionado, armazenando-o em uma área de transferência.
Copiar (Ctrl-C): Copia o texto selecionado para a área de transferência.
Colar (Ctrl-V): Copia texto da área de transferência para o local em que está o cursor.
Gravar bloco de texto: Permite a gravação em arquivo de um texto selecionado no editor. A
extensão sugerida para o nome do arquivo é .inc.
Inserir bloco de texto: Permite a inserção do conteúdo de um arquivo. A extensão sugerida
para o nome do arquivo é .inc.
Desfazer (Ctrl-Z): Desfaz último comando efetuado.
Refazer (Shift-Ctrl-Z): Refaz último comando desfeito.
Localizar (Ctrl-L): Localiza no texto presente no editor determinada palavra especificada.
Substituir (Ctrl-U): Localiza no texto presente no editor determinada palavra especificada,
substituindo-a por outra.
Corrigir Indentação (Ctrl-G): Corrige automaticamente a indentação (ou tabulação) do
pseudocódigo, tabulando cada comando interno com espaços à esquerda.
Numerar linhas: Ativa ou desativa a exibição dos números das linhas na área à esquerda do
editor. A linha e a coluna do editor em que o cursor está em um determinado momento também
são mostradas na barra de status (parte inferior da tela). Por motivos técnicos, esta opção é
automaticamente desativada durante a execução do pseudocódigo, mas volta a ser ativada
logo em seguida.
Mostrar variáveis modificadas: Ativa ou desativa a exibição da variável que está sendo
modificada. Como o número de variáveis pode ser grande, muitas podem estar fora da janela
de visualização; quando esta característica está ativada, o VisuAlg rola a grade de exibição de
modo que cada variável fique visível no momento em está sendo modificada. Este recurso é
especialmente útil quando se executa um pseudocódigo passo a passo. Por questões de
desempenho, a configuração padrão desta característica é desativada, quando o pseudocódigo
está sendo executado automaticamente. No entanto, basta clicar este botão para executá-lo
automaticamente com a exibição ativada. No final da execução, a configuração volta a ser
desativada.
Restaurar tela inicial: Retorna a divisão da tela ao formato inicial, caso você tenha mudado o
tamanho da área do editor de texto, quadro de variáveis ou simulador de saída.

Executar (F9): Inicia (ou continua) a execução automática do pseudocódigo.
Executar com timer (Shift-F9):: Insere um atraso (que pode ser especificado no intervalo ao
lado) 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.
Intervalo do timer: Atraso em cada linha, para quando se deseja executar o pseudocódigo
com timer.
Passo (F8): 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.
Parar (Ctrl-F2): Termina imediatamente a execução do pseudocódigo. Evidentemente, este
botão fica desabilitado quando o pseudocódigo não está sendo executado.
Liga/desliga breakpoint (F5): 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 (Ctrl-F5): 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 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
(basta alterar intervalo ao lado). Para a geração de dados do tipo caractere, não há uma faixa
pré-estabelecida: os dados gerados serão sempre strings de 5 letras maiúsculas.
Intervalo dos valores aleatórios: Faixa de valores que serão gerados automaticamente,
quando esta opção estiver ativada.
Perfil (F7): Após a execução de um pseudocódigo, exibe o número de vezes que cada umas
das suas linhas foi executada. É útil para a análise de eficiência (por exemplo, nos métodos de
ordenação).
Mostrar pilha de ativação (Ctrl-F3): 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.
Ajuda (F1): Possibilita acesso às páginas de ajuda e às informações sobre o VisuAlg.
Quadro de Variáveis
É formado por uma grade na qual são mostrados o escopo de cada variável (se for do
programa principal, será global; se for local, será apresentado o nome do subprograma onde foi
declarada), seus nomes (também com os índices, nos casos em que sejam vetores), seu tipo
("I" para inteiro, "R" para real, "C" para caractere e "L" para lógico) e o seu valor corrente. A
versão atual do VisuAlg permite a visualização de até 500 variáveis (contando individualmente
cada elemento dos vetores).
A Barra de Status
Situada na parte inferior da tela, esta barra contém dois painéis: o primeiro mostra a linha e a
coluna onde o cursor está, e o segundo mostra a palavra Modificado no caso em que o

pseudocódigo tenha sido alterado desde que foi carregado ou salvo pela última vez. Nesta
barra, há ainda um terceiro painel disponível, que ainda não tem um uso específico na atual
versão.

Menu do VisuAlg
Este menu compõe-se de 7 partes:
Arquivo: Possui os comandos para se abrir, salvar e imprimir algoritmos:
Novo: Cria um novo "esqueleto" de pseudocódigo, substituindo o texto existente no editor. Se
este texto anterior tiver sido modificado, o VisuAlg pedirá sua confirmação para salvá-lo antes
que seja sobreposto.
Abrir: Abre o texto de um pseudocódigo anteriormente gravado, substituindo o texto existente
no editor. Se este tiver sido modificado, o VisuAlg pedirá sua confirmação para salvá-lo antes
que seja sobreposto.
Salvar: Salva imediatamente o texto presente no editor. Caso seja a primeira vez que um novo
texto é gravado, o VisuAlg pedirá o nome do arquivo e sua localização.
Salvar como: Permite salvar o texto presente no editor exibindo antes uma janela na qual se
pode escolher o nome do arquivo e sua localização.
Enviar por email: Permite o envio por email do texto presente no editor.
Imprimir: Permite a impressão do algoritmo corrente, mostrando antes a janela de
configuração de impressão (o correspondente botão da barra de tarefas imprime
imediatamente o texto do pseudocódigo na impressora padrão).
Sair: Abandona o VisuAlg.
Além destes comandos, há ainda a lista dos 5 últimos algoritmos utilizados, que podem ser
abertos diretamente ao se escolher o seu nome.
Editar: Além dos conhecidos comandos de um editor de texto (copiar, cortar, colar, desfazer,
refazer, selecionar tudo, localizar, localizar de novo, substituir), há também as seguintes
opções:
Corrigir indentação: Corrige automaticamente a indentação do pseudocódigo, tabulando cada
comando interno com espaços à esquerda.
Gravar bloco de texto: Permite a gravação em arquivo de um texto selecionado no editor. A
extensão sugerida para o nome do arquivo é .inc.
Inserir bloco de texto: Permite a inserção do conteúdo de um arquivo. A extensão sugerida
para o nome do arquivo é .inc.
Exibir: Possui os comandos para ativar/desativar as seguintes características:
Número de linhas: Ativa/desativa a exibição da numeração das linhas na área à esquerda do
editor. A numeração corrente da posição do cursor também é mostrada na primeira parte da
barra de status, situada na parte inferior da tela. Por motivos técnicas, a numeração é
desativada durante a execução do pseudocódigo, voltando à situação anterior logo em
seguida.
Variáveis modificadas: Ativa/desativa a exibição da variável que está sendo modificada.
Como o número de variáveis pode ser grande, muitas podem estar fora da janela de
visualização; quando esta característica está ativada, o VisuAlg rola a grade de exibição de
modo que cada variável fique visível no momento em está sendo modificada. Este recurso é
especialmente útil quando se executa um pseudocódigo passo a passo. Por questões de
desempenho, a configuração padrão desta característica é desativada, quando o pseudocódigo
está sendo executado automaticamente. No entanto, basta clicar este botão para executá-lo
automaticamente com a exibição ativada. No final da execução, a configuração volta a ser
desativada.
Pseudocódigo: Contém os comandos relativos à execução do algoritmo:

Executar: Inicia (ou continua) a execução automática do pseudocódigo.
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.
Executar com timer: 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 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 pré-estabelecida: 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
suas linhas foi executada. É útil para a análise de eficiência (por exemplo, nos 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.
Linguagens: Permite a tradução automático do pseudocódigo presente no editor para outras
linguagens de programação. Atualmente, apenas a tradução para Pascal está implementada,
mas ainda em fase de testes.
Ferramentas: Neste menu, é possível configurar algumas opções do VisuAlg: cores e tipos de
letras na exibição do pseudocódigo, número de espaços para indentação automática, etc.
Ajuda: Entre outras coisas, possibilita acesso às páginas de ajuda e às informações sobre o
VisuAlg.

A Linguagem de Programação do
VisuAlg (1)
Introdução
A linguagem que o VisuAlg interpreta é bem simples: é uma versão portuguesa dos
pseudocódigos largamente utilizados nos livros de introdução à programação, conhecida como
"Portugol". Tomei a liberdade de acrescentar-lhe alguns comandos novos, com o intuito de criar
facilidades específicas para o ensino de técnicas de elaboração de algoritmos. Inicialmente,
pensava em criar uma sintaxe muito simples e "liberal", para que o usuário se preocupasse
apenas com a lógica da resolução dos problemas e não com as palavras-chave, pontos e
vírgulas, etc. No entanto, cheguei depois à conclusão de que alguma formalidade seria não só
necessária como útil, para criar um sentido de disciplina na elaboração do "código-fonte".
A linguagem do VisuAlg permite apenas um comando por linha: desse modo, não há
necessidade de tokens separadores de estruturas, como o ponto e vírgula em Pascal. Também
não existe o conceito de blocos de comandos (que correspondem ao begin e end do Pascal e
ao { e } do C), nem comandos de desvio incondicional como o goto. Na versão atual do
VisuAlg, com exceção das rotinas de entrada e saída, não há nenhum subprograma embutido,
tal como Inc(), Sqr(), Ord(), Chr(), Pos(), Copy() ou outro.
Importante: para facilitar a digitação e evitar confusões, todas as palavras-chave do VisuAlg
foram implementadas sem acentos, cedilha, etc. Portanto, o tipo de dados lógico é definido
como logico, o comando se..então..senão é definido como se..entao..senao, e assim por
diante. O VisuAlg também não distingue maiúsculas e minúsculas no reconhecimento de
palavras-chave e nomes de variáveis.
Formato Básico do Pseudocódigo e Inclusão de
Comentários
O formato básico do nosso pseudocódigo é o seguinte:
algoritmo "semnome"
// Função :
// Autor :
// Data :
// Seção de Declarações
inicio
// Seção de Comandos
fimalgoritmo
A primeira linha é composta pela palavra-chave algoritmo seguida do seu nome delimitado
por aspas duplas. Este nome será usado como título nas janelas de leitura de dados (nas
futuras versões do VisuAlg, talvez utilizemos este dado de outras formas). A seção que se
segue é a de declaração de variáveis, que termina com a linha que contém a palavra-chave
inicio. Deste ponto em diante está a seção de comandos, que continua até a linha em que
se encontre a palavra-chave fimalgoritmo. Esta última linha marca o final do pseudocódigo:
todo texto existente a partir dela é ignorado pelo interpretador.
O VisuAlg permite a inclusão de comentários: qualquer texto precedido de "//" é ignorado, até
se atingir o final da sua linha. Por este motivo, os comentários não se estendem por mais de

uma linha: quando se deseja escrever comentários mais longos, que ocupem várias linhas,
cada uma delas deverá começar por "//".
Tipos de Dados
O VisuAlg prevê quatro tipos de dados: inteiro, real, cadeia de caracteres e lógico (ou
booleano). As palavras-chave que os definem são as seguintes (observe que elas não têm
acentuação):
• inteiro: define variáveis numéricas do tipo inteiro, ou seja, sem casas decimais.
• real: define variáveis numéricas do tipo real, ou seja, com casas decimais.
• caractere: define variáveis do tipo string, ou seja, cadeia de caracteres.
• logico: define variáveis do tipo booleano, ou seja, com valor VERDADEIRO ou
FALSO.
O VisuAlg permite também a declaração de variáveis estruturadas através da palavra-chave
vetor, como será explicado a seguir.
Nomes de Variáveis e sua Declaração
Os nomes das variáveis devem começar por uma letra e depois conter letras, números ou
underline, até um limite de 30 caracteres. As variáveis podem ser simples ou estruturadas (na
versão atual, os vetores podem ser de uma ou duas dimensões). Não pode haver duas
variáveis com o mesmo nome, com a natural exceção dos elementos de um mesmo vetor.
A seção de declaração de variáveis começa com a palavra-chave var, e continua com as
seguintes sintaxes:
<lista-de-variáveis> : <tipo-de-dado>
<lista-de-variáveis> : vetor "["<lista-de-intervalos>"]" de <tipo-de-
dado>
Na <lista-de-variáveis>, os nomes das variáveis estão separados por vírgulas. Na
<lista-de-intervalos>, os <intervalo> são separados por vírgulas, e têm a seguinte
sintaxe:
<intervalo>: <valor-inicial> .. <valor-final>
Na versão atual do VisuAlg, tanto <valor-inicial> como <valor-final> devem ser
inteiros. Além disso, exige-se evidentemente que <valor-final> seja maior do que
<valor-inicial>.
Exemplos:
var a: inteiro
Valor1, Valor2: real
vet: vetor [1..10] de real
matriz: vetor [0..4,8..10] de inteiro
nome_do_aluno: caractere
sinalizador: logico
Note que não há a necessidade de ponto e vírgula após cada declaração: basta pular linha. A
declaração de vetores é análoga à linguagem Pascal: a variável vet acima tem 10 elementos,
com os índices de [1] a [10], enquanto matriz corresponde a 15 elementos com índices [0,8],

[0,9], [0,10], [1,8], [1,9], [1,10], ... até [4,10]. O número total de variáveis suportado pelo VisuAlg
é 500 (cada elemento de um vetor é contado individualmente).
Constantes e Comando de Atribuição
O VisuAlg tem três tipos de constantes:
• Numéricos: são valores numéricos escritos na forma usual das linguagens de
programação. Podem ser inteiros ou reais. Neste último caso, o separador de decimais
é o ponto e não a vírgula, independente da configuração regional do computador onde
o VisuAlg está sendo executado. O VisuAlg também não suporta separadores de
milhares.
• Caracteres: qualquer cadeia de caracteres delimitada por aspas duplas (").
• Lógicos: admite os valores VERDADEIRO ou FALSO.
A atribuição de valores a variáveis é feita com o operador <-. Do seu lado esquerdo fica a
variável à qual está sendo atribuído o valor, e à sua direita pode-se colocar qualquer expressão
(constantes, variáveis, expressões numéricas), desde que seu resultado tenha tipo igual ao da
variável.
Alguns exemplos de atribuições, usando as variáveis declaradas acima:
a <- 3
Valor1 <- 1.5
Valor2 <- Valor1 + a
vet[1] <- vet[1] + (a * 3)
matriz[3,9] <- a/4 - 5
nome_do_aluno <- "José da Silva"
sinalizador <- FALSO

Referências da Linguagem de
Programação do VisuAlg
Nesta página estão todas as palavras-chave da linguagem de programação do VisuAlg. Em
cada uma delas, há um link para sua correspondente seção dentro das páginas de ajuda.
aleatorio
algoritmo
arquivo
asc
ate
carac
caracpnum
caractere
caso
compr
copia
cronometro
debug
e
eco
enquanto
entao
escolha
escreva
escreval
faca
falso
fimalgoritmo
fimenquanto
fimescolha
fimfuncao
fimpara
fimprocedimento
fimrepita
fimse
funcao
inicio
int
inteiro
interrompa
leia
limpatela
logico
maiusc
minusc
mod
nao
numpcarac
ou
outrocaso
para
passo
pausa
pos
real
procedimento
repita
retorne
se
senao
timer
var
vetor
verdadeiro
xou

Auto-digitação e Sugestão de Digitação
Auto-digitação
O VisuAlg tem uma característica para a criação de pseudocódigos que pode aumentar a
rapidez da digitação e também diminuir a possibilidade de erros: é a auto-digitação. Para
utilizar esta característica, basta escrever uma abreviatura da palavra-chave ou do comando a
ser diigtado e teclar Ctrl-Espaço. O VisuAlg completa então o comando automaticamente,
colocando o cursor no ponto adequado para se continuar a digitação (nos exemplos abaixo,
este ponto é indicado através de um *). Eis a lista de abreviaturas com os respectivos
comandos:
! - (Ponto de exclamação) Cria um modelo de pseudocódigo.
algoritmo "semnome"
*
inicio
fimalgoritmo
# - Cria um cabeçalho de programa.
// Algoritmo : *
// Função :
// Autor :
// Data :
ale, aof, aon - Inserem os comandos aleatorio, aleatorio off ou aleatorio on,
respectivamente.
alg - Insere a linha algoritmo e pede a digitação do seu nome.
algoritmo "*"
arq - Insere o comando arquivo e pede a digitação do seu nome.
arquivo "*"
cof, con - Inserem os comandos cronometro off ou cronometro on, respectivamente.
dcc - Insere uma declaração de variáveis caracteres.
var * : caractere
dcl - Insere uma declaração de variáveis lógicas.
var * : logico
dcr - Insere uma declaração de variáveis reais.
var * : real
deb - Insere o comando debug.

eof, eon - Inserem os comandos eco off ou eco on, respectivamente.
esc - Insere o comando escreva.
escl - Insere o comando escolha (sem a cláusula outrocaso).
escolha *
caso
fimescolha
esco - Insere o comando escolha (com a cláusula outrocaso).
escolha *
caso
outrocaso
fimescolha
enq - Insere o comando enquanto.
enquanto * faca
fimenquanto
fal - Insere a linha fimalgoritmo.
ini - Insere a linha inicio.
int - Insere o comando interrompa.
lep - Insere o comando leia.
leia (*)
par - Insere o comando para.
para * de 1 ate faca
fimpara
parp - Insere o comando para com passo.
para * de ate passo faca
fimpara
rep - Insere o comando repita.
repita
*
ate
repf - Insere o comando repita com fimrepita.
repita
*
fimrepita
see - Insere o comando se sem a alternativa senao.

se * entao
fimse
ses - Insere o comando se completo.
se * entao
senao
fimse
tim - Insere os comandos timer on e timer off.
timer on
*
timer off
tof, ton - Inserem os comandos timer on ou timer off, respectivamente.
Sugestão de Digitação
A sugestão de digitação é disponibilizada através das teclas Ctrl-J. Basta começar a digitação
de uma palavra e teclar Ctrl-J para que o VisuAlg mostre uma lista com sugestões de palavras-
chave que completam o que foi digitado. Para escolher, é necessário dar um duplo-clique sobre
a opção desejada, ou então selecioná-la com as setas e teclar Enter. Se o usuário continua
escrevendo depois que o VisuAlg apresentou a lista de sugestões, o programa continuará
procurando palavras que ainda complementem o que foi digitado. Ao se teclar Esc ou clicar
"fora da lista", ela desaparece.

As Funções do Visualg Versão 2.0
Toda linguagem de programação já vem com um grupo de funções que facilitam a vida do
programador. Estas funções realizam os cálculos aritméticos, trigonométricos e de manipulação
e conversão de dados mais comuns; assim, o programador não tem que reinventar a roda a
cada programa que faz. A este grupo de funções dá-se às vezes o nome de biblioteca.
Como usar uma função? Em termos simples, uma função pode ser usada em qualquer lugar
onde uma variável também pode, a não ser, naturalmente, no "lado esquerdo da seta" em um
comando de atribuição - uma função produz (diz-se no linguajar dos programadores retorna)
um valor, e não o recebe.
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 co-seno é 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 co-seno 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.
Os valores que estão entre parênteses, representados pelas palavras como expressão, base e
expoente, são os parâmetros, ou como dizem alguns autores, os argumentos que passamos
para a função para que realize seus cálculos e retorne um outro, que usaremos no programa.
Algumas funções, como Pi e Rand, não precisam de parâmetros, mas a maioria tem um ou
mais. O valor dos parâmetros naturalmente altera o valor retornado pela função.
A seguir temos alguns exemplos que ilustram o uso destas funções.
algoritmo "exemplo_funcoes"

var a, b, c : real
inicio
a <- 2
b <- 9
escreval( b - a ) // será escrito 7 na tela
escreval( abs( a - b ) ) // também será escrito 7 na tela
c <- raizq( b ) // c recebe 3, a raiz quadrada de b, que é 9
// A fórmula da área do círculo é pi (3.1416) vezes raio ao
quadrado...
escreval("A área do circulo com raio " , c , " é " , pi * quad(c) )
// Um pouco de trigonometria...
escreval("Um ângulo de 90 graus tem " , grauprad(90) , " radianos" )
escreval( exp(a,b) ) // escreve 2 elevado à 9ª, que é 512
// escreve 1, que é a parte inteira de 1.8, resultado de 9/(3+2)
escreval( int( b / ( a + c ) ) )
fimalgoritmo
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 caracter cujo código ASCII corresponde à expressão.
Caracpnum (c : caracter) : Retorna o inteiro ou real representado pela expressão.
Corresponde a StrToInt() ou StrToFloat() do Delphi, Val() do Basic ou Clipper, etc.
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. Corresponde a Copy() do Delphi,
Mid$() do Basic ou Substr() do Clipper.
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. Corresponde a IntToStr() ou FloatToStr() do Delphi, Str() do
Basic ou Clipper.
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. Corresponde funcionalmente a Pos()
do Delphi, Instr() do Basic ou At() do Clipper, embora a ordem dos parâmetros possa ser
diferente em algumas destas linguagens.
A seguir temos alguns exemplos que ilustram o uso destas funções.
algoritmo "exemplo_funcoes2"
var
a, b, c : caracter
inicio
a <- "2"
b <- "9"
escreval( b + a ) // será escrito "92" na tela
escreval( caracpnum(b) + caracpnum(a) ) // será escrito 11 na tela

escreval( numpcarac(3+3) + a ) // será escrito "62" na tela
c <- "Brasil"
escreval(maiusc(c)) // será escrito "BRASIL" na tela
escreval(compr(c)) // será escrito 6 na tela
b <- "O melhor do Brasil"
escreval(pos(c,b)) // será escrito 13 na tela
escreval(asc(c)) // será escrito 66 na tela - código ASCII de "B"
a <- carac(65) + carac(66) + carac(67)
escreval(a) // será escrito "ABC" na tela
fimalgoritmo

Curso de Algoritmos
Lição 1 - Introdução
Todo mundo que tem contato com computadores sabe que eles precisam ser programados para
executar tarefas. Um programa é um conjunto de milhares de instruções que indicam ao
computador, passo a passo, o que ele tem que fazer. Estes programas são construídos com
ferramentas chamadas "linguagens de programação". Estas linguagens contém os comandos
que fazem o computador escrever algo na tela, realizar cálculos aritméticos, receber uma
entrada de dados via teclado, e milhares de outras coisas, mas estes comandos precisam estar
em uma ordem lógica e contribuir, cada um, para a tarefa em questão. A lógica da
programação, então, é o ponto principal na criação de aplicações para os computadores, e na
verdade, ela independe da linguagem de programação utilizada.
Provavelmente você já viu uma receita de bolo. Nela estão colocados os ingredientes
necessários e nas quantidades corretas; também na receita encontramos o modo de
preparação, dizendo o que deve ser misturado com o que, em que ordem, o tempo em que o
bolo ficará no forno, etc. A este conjunto de instruções poderíamos dar o nome de "algoritmo
para a confecção de um bolo". A palavra algoritmo significa "conjunto de regras e
instruções, que devem ser seguidas na ordem especificada, para resolver um
problema específico". Este termo está ligado às ciências da computação, mas na realidade
pode ser aplicado a qualquer problema cuja solução possa ser decomposta em um grupo de
instruções. A única diferença no caso é que, em relação ao computador, os comandos têm que
ser precisos, e cada um deve conter uma tarefa, apenas. Um computador não entenderia a
instrução "bata a massa até atingir a consistência desejada..." Provavelmente teríamos que
dizer "ligue a batedeira; bata a massa durante 5 minutos; delisgue a batedeira", ou coisa
parecida.
O termo "processamento de dados" é muitas vezes utilizado em conjunto com computadores,
pois isto é o que eles fazem: processar dados. Daí podemos extrair os dois componentes
básicos de um algoritmo (de agora em diante, esta palavra será sempre utilizada no contexto
da informática): dados e código. Dados são os valores (números, nomes, etc.) de que
precisamos para resolver o problema, e código são os comandos que usaremos para manipular
e "processar" os dados. A partir de agora estudaremos estes dois componentes
Os dados existem nas mais variadas formas, tanto no mundo real quanto nos computadores,
mas para este curso usaremos três tipos, que serão suficientes embora não representem toda a
gama possível. Estes tipos são:
• Dados Numéricos - são quantidades como o peso de uma pessoa, o número de alunos
em uma sala de aula, o preço de uma mercadoria, uma temperatura, etc. Nos
algoritmos são representados como na escrita corrente, com a exceção de que se usa o
ponto e não a vírgula para se separar a parte decimal, e não se separam as casas de
milhares, milhões, etc.
Exemplos: 1.23 -3 45657 0.66 -897.06 etc.
Nos nossos exemplos daremos a todas as variáveis que armazenam valores numéricos
o tipo numerico (assim mesmo, sem acento).

• Dados Literais - são letras, nomes, sinais de pontuação, etc. Outros nomes comuns
para este tipo de dados são caracteres e strings (por causa do inglês). Nos algoritmos
são representados por letras, números, espaços e sinais entre aspas.
Exemplos: "Rio de Janeiro" "Computador" "A" "?" "Fora!" "1234"
Nos nossos exemplos daremos a todas as variáveis que armazenam valores literais o
tipo caracter.
• Dados Lógicos - podem assumir apenas dois valores: Falso ou Verdadeiro. Também são
chamados de dados booleanos. Vamos estudar com mais profundidade este tipo à
frente no curso. Ele é importante porque dá a "inteligência" ao computador, mas neste
momento podemos ficar só com esta pequena explicação.
Nos nossos exemplos daremos a todas as variáveis que armazenam valores lógicos o tipo
logico (assim mesmo, sem acento).
E como os dados estão representados nos algoritmos? De duas maneiras: como constantes,
ou seja, o dado escrito como ele é, como nos exemplos acima, e armazenados em variáveis.
Variáveis são locais de armazenamento temporário para os dados. É um conceito parecido com
os famosos x, y e z que usamos na Álgebra. Elas têm três características:
• Nome: é como nos referimos às variáveis. Os nomes geralmente descrevem a função
das variáveis no programa; por exemplo, se você tem um programa para calcular a
média aritmética de dois valores, teria as variáveis PrimeiroValor, SegundoValor, e
Media; já em um outro, poderia ter a variável Salario, para armazenar o salário de um
funcionário, etc.
Regras para a formação de nomes de variáveis
Toda linguagem de programação tem regras para a formação de nomes de
variáveis, e nós também teremos: neste curso, os nomes de variáveis deverão
começar com uma letra, e depois poderão ter qualquer combinação de letras,
números e sublinhado ("_"). Não pode haver espaços no interior dos nomes, e
não haverá diferenciação entre maiúsculas e minúsculas (ou seja, os nomes
"Salario", "SALARIO", e "salario" se referem à mesma variável. Exemplos:
Nomes Válidos: Valor1, Valor2, Nota_do_Aluno, Salario
Nomes Inválidos: 1Valor, 2Valor, _Salario, Nota.do.Aluno, Media-
Aritmetica
• Tipo: indica o tipo de dado que aquela variável armazena. Assim, uma variável pode ser
do tipo numérico, literal ou lógico. Quando se define uma variável para uso no
programa (os programadores dizem "declarar uma variável"), temos que indicar ao
computador não só o seu nome, mas também o tipo de dados que ela vai armazenar.
• Conteúdo: É o valor armazenado na variável em determinado momento. Podemos fazer
duas coisas com o conteúdo de uma variável: examiná-lo, ou seja "ver o que ela
contém, para usar ou não", e modificá-lo. Quando criamos uma variável em um
programa, ela está "vazia", ou seja, seu conteúdo é indeterminado. Para que ela tenha
utilidade, devemos dar-lhe valores que tenham a ver com o problema em questão (os
programadores usam a expressão "atribuir valores a ela").
Na próxima lição estudaremos os comandos básicos para a construção de algoritmos.

Lição 2 - Comandos Básicos
O primeiro passo para a construção de um algoritmo é a declaração das variáveis que serão
usadas nele. Quase todas as linguagens de programação exigem a declaração das variáveis de
um programa. Em algumas isto é facultativo, mas é sempre uma boa técnica declarar variáveis,
por vários motivos. Em um algoritmo isto não é necessário, pois na realidade o algoritmo não é
uma linguagem de programação. Entretanto, para melhorar o entendimento do algoritmo e
também para treinar as técnicas corretas, vamos assumir que a declaração de variáveis é
"obrigatória".
Declarando Variáveis
Para declarar uma variável, colocamos, no início do algoritmo, a palavra chave declare e seu
nome, seguido por dois pontos e seu tipo:
declare Salario : Numerico
declare Nome : Literal
declare AlunoAusente : Logico
Se tivermos mais de uma variável do mesmo tipo, podemos colocar todas, separadas por
vírgulas, na mesma declaração:
declare Peso, Altura, Idade : Numerico
Como todas (ou quase todas) as linguagens de programação têm seus comandos e sintaxe
baseados no Inglês, vamos eliminar nos comandos e variáveis de nossos exemplos os acentos,
til, cedilha, etc. Os dados do tipo literal ou mensagens para o usuário, no entanto, serão
escritos corretamente.
Colocando Valores nas Variáveis
Quando declaramos uma variável, criamos uma área de armazenamento para os dados, mas
ela ainda está "sem valor". Para que ela seja útil, deve ter valores colocados por nós ou pelo
usuário, através de digitação. Quando o próprio programa coloca dados nas variáveis faz o que
se chama "atribuição de valores". Isto é feito pelo operador "<-" (uma seta apontando para a
esquerda). Por exemplo:
Peso <- 78
Este comando atribui à variável Peso o valor 78. O valor que ela tinha anteriormente é
"apagado", e não pode ser recuperado mais.
Nome <- "João da Silva"
Este comando atribui à variavel Nome o valor "João da Silva".
É importante lembrar que só se podem atribuir a uma variável valores do mesmo tipo da
variável. Nos exemplos acima, a variável Salário é do tipo numérico; então, o seguinte
comando seria inválido:
Salário <- "Insuficiente"

Uma variável, como o próprio nome está dizendo, pode ter seu conteúdo (seu valor) mudado
quantas vezes for necessário durante um programa.
Exibindo o Valor de uma Variável
Um programa que faça o seu processamento e não tenha como mostrar seus resultados é
inútil. Portanto, em algum ponto deve haver a exibição de valores, e todas as as linguagens de
programação têm comandos para este fim. Nos algoritmos usamos o comando Escreva para
isto. A sintaxe deste comando, isto é, o modo correto de ele ser usado, é a seguinte:
Escreva Expressão1, Expressão2, etc...
Expressão1, Expressão2, etc. são valores de qualquer tipo, separados por vírgula. Estes valores
podem ser constantes ou variáveis. Caso a expressão seja uma variável, será exibido o seu
valor. Veja os exemplos a seguir:
Comandos Resultado
(o que aparecerá na tela do
computador)
Escreva "Alô, mundo!" Alô, mundo!
Escreva 20 20
declare Nome : Caracter
declare Idade : Numerico
Nome <- "José"
Idade <- 40
Escreva Nome José
Escreva "O meu nome é ", Nome O meu nome é José
Escreva "Tenho ",Idade," anos" Tenho 40 anos
Obtendo Dados para o Programa
Nem todos os dados que um programa manipula são gerados por ele. Um programa de caixa
automático, por exemplo, tem que obter do usuário o número da conta, a senha, a opção de
serviço desejada, etc. Assim, deve haver um meio para que sejam digitados (ou fornecidos de
outra maneira) dados para uso do programa. Mais uma vez, todas as linguagens de
programação permitem isto, e nos algoritmos usamos o comando Leia. A sintaxe deste
comando é:
Leia <Nome_De_Variável>
Substitua <Nome_De_Variáve> pel o nome da variável onde serão armazenados os dados
digitados. Veja este exemplo:
Leia Nome
Leia Peso
Supondo que o usuário digitou "Paulo", teclou ENTER, digitou 80 e teclou ENTER novamente, o
valor "Paulo" foi atribuído automaticamente à variável Nome, e o valor 80 à variável Peso.

Lição 3 - Expressões Aritméticas
Grande parte do processamento em qualquer programa é numérica. As linguagens de
programação trabalham com a aritmética mais ou menos do mesmo jeito que nós, na escola
(veja bem, mais ou menos...) Os componentes básicos das expressões aritméticas são:
constantes, variáveis e operadores. Os dois primeiros já conhecemos; operadores são os
"sinais" que usamos nas contas:
Operador Operação Exemplo Resultado
+ Adição 3 + 2 5
- Subtração 10 - 5 5
* Multiplicação 3 * 7 21
/ Divisão 25 / 2 12.5
^ Potenciação 5 ^ 2 25
Divisão Inteira 25 2 12
Note que não se usa o "X" para indicar a multiplicação, nem a barra horizontal de
fração para indicar a divisão...
Você deve ter notado que há dois operadores para divisão. O segundo ( ) é o da divisão
inteira, ou seja, a que não tem parte decimal, mesmo que o dividendo não seja múltiplo do
divisor. Várias liguagens de programação têm estes dois operadores. Por outro lado em
algumas linguagens de programação, o operador de potenciação é ** (dois asteriscos juntos).
Nos nossos exemplos e exercícios sempre usaremos os operadores descritos acima.
Da mesma maneira que estudamos na escola, algumas operações têm prioridade sobre as
outras. A potenciação tem a maior prioridade entre todos estes operadores.
Multiplicação e divisão devem ser operadas antes da adição e subtração. Assim, na
expressão
3 + 2 * 5
primeiro operamos o 2*5, e somamos o resultado com 3 para obter 13.
Para mudar a ordem das operações, usamos parênteses: como na aritmética da escola, o que
estiver entre parênteses será operado primeiro. Por exemplo:
( 3 + 2 ) * 5
primeiro operamos o 3 + 2, porque está entre parênteses, e depois o resultado desta
operação será multiplicado com 5 para obter 25.
Quando na expressão só houver operações com a mesma prioridade, a avaliação é feita
normalmente da esquerda para a direita.
Nas linguagens de programação e nos algoritmos não se usam colchetes e chaves para
sucessivos agrupamentos de operações, e sim mais parênteses. Vamos ver um exemplo mais
complexo. Qual o valor de:
( 3 + 5 ) * ( 4 * ( 10 -7
) ) / 2
Opera-se o que estiver nos parênteses mais internos
( 3 + 5 ) * ( 4 * 3
) / 2 Operam-se os dois parênteses que restaram
8 * 12 / So há * e / - , então opera-se da esquerda para a

2 direita
96 / 2
48 Resultado final
Um outro exemplo:
6 * ( 9 + 3 * 2 ) / ( 2 * 4
- 11 ) Operam-se as multiplicações nos parênteses
6 * ( 9 + 6 ) / ( 8
- 11 ) Operam-se os parênteses
6 * 15 / -
3 So há * e / - opera-se da esquerda para a direita
90 / -3 Observe o sinal negativo antes do 3...
-30 Resultado final
Até agora só vimos expressões com constantes. Na maioria das vezes, porém, haverá
expressões que combinarão variáveis e constantes. Quando houver uma variável em uma
expressão, o cálculo deve ser feito usando-se o valor da variável naquele momento. Como
exemplo, veja os algoritmos a seguir:
Comandos Comentários
1) Declare A : Numerico Declaração da variável
A <- 3 Atribuição de valor
Escreva A * 5 Será exibido o valor 15, pois A=3, logo 3*5 = 15
2) Declare A, B : Numerico
A <- 10
B <- A * 3 O valor de B é 30 ( 10*3)
Escreva B - A + 1 Será exibido o valor 21 ( 30 - 10 + 1 )
B <- 40 Novo valor para B
Escreva B - A + 1 Agora será exibido o valor 31 (40 - 10 + 1), pois o
valor de B mudou
3) Declare A : Numerico
A <- 3 * 2 O valor de A é 6
A <- A + 1 Agora o valor de A passa a ser 7 (6, o valor
anterior, mais 1)
Escreva A * A Será exibido o valor 49 ( 7 * 7 )
4) Declare X : Numérico
Escreva "Digite um número
:"
Leia X Obtenha um número qualquer do usuário
Escreva X * 2 Será exibido o dobro do número digitado (qualquer
que ele seja)
Pelos exemplos acima, você deve ter notado que podemos usar uma expressão no comando
Escreva. Ela é calculada, e o seu resultado é exibido.
Com os conhecimentos adquiridos até agora, podemos começar a construir nossos próprios
algoritmos.

Lição 4 - Construindo os Primeiros Algoritmos
Basicamente a construção de um algoritmo se resume às seguintes etapas:
1. Entendimento do problema;
2. Definição dos dados que serão necessários para resolvê-lo (as entradas); aí já
deveremos ter idéia dos tipos de dados que usaremos;
3. Obtenção destes dados; alguns vêm do "exterior" do programa, e outros são calculados
no próprio algoritmo;
4. Processamento em si;
5. Exibição dos resultados.
A primeira fase é a mais difícil de se "pegar", pois depende um pouco da experiência do
programador. Entretanto, mesmo nesta fase há técnicas que podem ser aprendidas, e modelos
que podem ser aplicados. Programação é arte, ciência e técnica, tudo ao mesmo tempo...
Problema 1 - Cálculo de Média Aritmética
Enunciado
Faça um programa que leia dois valores numéricos, e calcule e exiba a sua média aritmética.
Etapa 1
Simples, hein? Dos tempos de escola lembramos que a média aritmética de dois valores é
calculada como (a+b)/2, e sendo assim a primeira etapa já está pronta.
Etapa 2
Os dados necessários serão os dois valores, que colocaremos em duas variáveis A e B, do tipo
numérico, e uma terceira variável, que chamaremos Média, que armazenará a média aritmética
calculada.
Etapa 3
A obtenção dos dados neste programa é simples e direta. Basta pedir ao usuário que digite os
valores.
Etapa 4
O processamento aqui é o cálculo da média, usando o método citado acima, na etapa 1. O
resultado do cálculo será armazenado na variável Média.
Etapa 5
Basta exibir o conteúdo da variável Média.
Solução
Declare A,B,Media : Numerico

Escreva "Programa que calcula a média aritmética de dois valores."
Escreva "Digite um valor : "
Leia A
Escreva "Digite outro valor : "
Leia B
Media <- (A+B)/2
Escreva "A média dos dois valores é : ", Media
Comentários
Você deve ter notado que colocamos na tela instruções para o usuário usando o comando
Escreva. Esta é uma boa técnica de programação, mesmo hoje em dia, com o ambiente do
Windows, etc. Da mesma forma, ao imprimir o resultado, não mostramos simplesmente a
média, mas explicamos ao usuário o que aquele valor significa.
Exercício 1
Reescreva o programa-solução do Problema 1, mas sem usar a variável Media. Lembre-se que
o comando Escreva aceita imprimir o resultado de uma expressão...
Resposta
Exercício 2
Faça um programa que leia três valores numéricos, e calcule e exiba a sua média aritmética.
Complicou?
Resposta

Lição 5 - Mais Algoritmos Básicos
Problema 2 - Cálculo Simples de Velocidade Média
Enunciado
Faça um programa que leia o nome de um piloto, uma distância percorrida em km e o tempo
que o piloto levou para percorrê-la (em horas). O programa deve calcular a velocidade média
em km/h, e exibir a seguinte frase:
A velocidade média de XX foi YY km/h.
Onde XX é o nome do piloto, e YY é sua velocidade média.
Etapas 1 e 2
Das aulas de Física sabemos que a velocidade média é dada pela distância percorrida dividida
pelo tempo gasto para percorrê-la (v=s/t), certo? Então temos dois valores numéricos
(distância e tempo), e um literal (o nome do piloto).
Etapa 3
A obtenção dos dados neste programa é simples e direta. Basta pedir ao usuário que digite os
valores.
Etapas 4 e 5
Usaremos as mesmas técnicas utilizadas no Problema 1.
Solução
Declare Nome : Caracter
Declare Distancia,Tempo,VelMedia : Numerico
Escreva "Programa que calcula a velocidade média de um piloto."
Escreva "Digite o nome do piloto : "
Leia Nome
Escreva "Digite a distância percorrida (em km) : "
Leia Distância
Escreva "Digite o tempo gasto para percorrê-la (em horas) : "
Leia Tempo
VelMédia <- Distância/Tempo
Escreva "A velocidade média de ",Nome," foi ", VelMédia
Problema 3 - Cálculo de Velocidade Média (mais complexo)
Enunciado
Em um rally foram percorridos dois trechos. Faça um programa que leia o nome de um piloto, a
quilometragem de cada um dos trechos em km, e depois o tempo total para percorrê-los, em
horas. Calcule e imprima a velocidade média geral do piloto.
Comentários

Como sabemos, a fórnula para se calcular a velocidade média é v=s/t, mas no nosso caso o
"s", que significa espaço percorrido, é o somatório dos dois trechos do rally. Assim, usando
como base o programa anterior, podemos resolver facilmente este problema, e não
analisaremos todas as 5 etapas.
Declare DistTrecho1, DistTrecho2, Tempo,VelMedia : Numerico
Leia Nome
Escreva "Digite a distância percorrida no trecho 1(em km) : "
Leia DistTrecho1
Escreva "Digite a distância percorrida no trecho 2(em km) : "
Leia DistTrecho2
Escreva "Digite o tempo gasto para percorrê-las (em horas) : "
Leia Tempo
VelMédia <- (DistTrecho1+DistTrecho2)/Tempo
Escreva "A velocidade média de ",Nome," foi ", VelMedia
Exercício 3
Realizarei uma viagem de vários dias em meu automóvel, e gostaria de saber a quilometragem
média por litro de gasolina. Para isto, anotarei a quilometragem no velocímetro ao sair de
viagem, e depois ao chegar; também vou somar toda a gasolina que comprar para o carro.
Você poderia fazer um programa que me desse, com estes dados, quantos km fiz, em média,
por litro de gasolina?
Resposta
Exercício 4
Em uma pizzaria, cada tulipa de chopp custa R$0,80 e uma pizza mista grande custa R$10,00
mais R$1,50 por tipo de cobertura pedida (queijo, presunto, banana, etc.). Uma turma vai à
pizzaria e pede uma determinada quantidade de "chopps" e uma pizza grande com uma
determinada quantidade de coberturas. Faça um programa que calcule a conta e, sabendo
quantas pessoas estão à mesa, quanto que cada um deve pagar (não esqueça os 10% do
garçon)...
Resposta

RESPOSTAS – Lição 4 e 5
Lembre-se que a resposta a um exercício é apenas uma das soluções possíveis. Fique à
vontade para criar suas próprias soluções e compará-las com as do curso.
Resposta do Exercício 1
Enunciado: Reescreva o programa-solução do Problema 1, mas sem usar a variável Média.
Declare A,B : Numerico
Escreva "Programa que calcula a média aritmética de dois valores."
Escreva "Digite um valor : "
Leia A
Escreva "Digite outro valor : "
Leia B
Escreva "A média dos dois valores é : ", (A+B)/2
Enunciado: Faça um programa que leia três valores numéricos, e calcule e exiba a sua média
aritmética.
Declare A,B,C, Media : Numerico
Escreva "Programa que calcula a média aritmética de três valores."
Escreva "Digite o primeiro valor : "
Leia A
Escreva "Digite o segundo valor : "
Leia B
Escreva "Digite o terceiro valor : "
Leia B
Media <- (A+B+C)/3
Escreva "A média dos três valores é : ", Media
Enunciado: Realizarei uma viagem de vários dias em meu automóvel, e gostaria de saber a
quilometragem média por litro de gasolina. Para isto, anotarei a quilometragem no velocímetro
ao sair de viagem, e depois ao chegar; também vou somar toda a gasolina que comprar para o
carro. Você poderia fazer um programa que me desse, com estes dados, quantos km fiz, em
média, por litro de gasolina?
Comentários: Nosso amigo quer saber a quilometragem média por litro de gasolina, ou seja,
km/litro. Esta simples fórmula já dá a "dica" para a solução do problema, pois basta saber
quantos quilômetros ele rodou e quantos litros de gasolina colocou no carro, e dividir o primeiro
pelo segundo (km/litro, é isto que estamos procurando). O problema é que ele não vai dizer
quantos quilômetros rodou, mas a quilometragem de seu velocímetro ao sair de viagem e ao
chegar. Para sabermos o quanto ele viajou basta... Isso mesmo, subtrair o primeiro do
segundo. Veja a nossa solução a seguir:
Declare KmInicial, KmFinal, Gasolina, Rendimento : Numerico

Escreva "Programa que calcula Km rodados por litro de gasolina."
Escreva "Digite a quilometragem inicial : "
Leia KmInicial
Escreva "Digite a quilometragem final : "
Leia KmFinal
Escreva "Digite quantos litros de gasolina comprou : "
Leia Gasolina
Rendimento <- (KmFinal-KmInicial)/Gasolina
Escreva "O rendimento médio foi de ", Rendimento, " km por litro."
Foi mais ou menos assim que você fez?
Enunciado: Em uma pizzaria, cada tulipa de chopp custa R$0,80 e uma pizza mista grande
custa R$10,00 mais R$1,50 por tipo de cobertura pedida (queijo, presunto, banana, etc.). Uma
turma vai à pizzaria e pede uma determinada quantidade de "chopps" e uma pizza grande com
uma determinada quantidade de coberturas. Faca um programa que calcula e conta e, sabendo
quantas pessoas estão à mesa, quanto que cada um deve pagar (não esqueça os 10% do
garçon)...
Comentários: Primeiramente vamos resolver este problema da maneira mais simples e
explicada, criando variáveis para armazenar todos os valores intermediários de nossos cálculos.
1. O preço da pizza é calculado somando-se o preço-base (R$10,00) ao produto do
número de coberturas vezes R$1,50, que é o preço de cada uma. Note a maneira pela
qual estes valores são representados no programa. O preço-base é 10, e o preço de
cada cobertura 1.5.
2. Depois vem o cálculo o preço do chopp, obtido pela multiplicação de R$0,80 (0.8 no
programa) pelo número de tulipas consumidas.
3. Somando estes dois, temos o primeiro subtotal. Com base nele calculamos a gorjeta de
10%. Dez por cento, como se sabe, é o mesmo que 10/100, ou seja, 1 décimo .
Dividindo o subtotal por 10 obtemos a gorjeta, e daí o total, que é o subtotal mais a
gorjeta.
4. O último passo é calcular o quanto cada pessoa deve pagar, que é a divisão do total
pelo número de pessoas.
Declare NumCoberturas,NumTulipas,NumPessoas : Numerico
Declare PrecoPizza,PrecoChopp,SubTotal,Gorjeta,Total,ValorPorPessoa :
Numerico
Escreva "Programa que calcula a conta em uma pizzaria."
Escreva "Quantidade de coberturas na pizza : "
Leia NumCoberturas
PrecoPizza <- 10 + (NumCoberturas * 1.5)
Escreva "Quantidade de tulipas de chopp : "
Leia NumTulipas
PrecoChopp <- 0.8 * NumTulipas
SubTotal <- PrecoPizza + PrecoChopp
Gorjeta <- SubTotal / 10
Total <- SubTotal + Gorjeta

Escreva "Número de pessoas na mesa : "
Leia NumPessoas
ValorPorPessoa <- Total / NumPessoas
Escreva "O valor por pessoa é ", ValorPorPessoa
Refinamento 1 : Podemos também resolver este problema de modo mais direto, evitando
alguns passos intermediários, como por exemplo, o cálculo da gorjeta, e do subtotal. A
matemática básica nos ensina que x + (x/10) é o mesmo que x * 1.1; podemos
aproveitar esta propriedade para melhorar nosso algoritmo.
Declare PrecoPizza,PrecoChopp,Total,ValorPorPessoa : Numerico
Leia NumCoberturas
Leia NumTulipas
Total <- (PrecoPizza + PrecoChopp) * 1.1
Leia NumPessoas
ValorPorPessoa <- Total / NumPessoas
Refinamento 2 : Vamos eliminar agora a variável Total. Preste atenção no uso dos parênteses
para que o cálculo se faça de modo correto.
Declare PrecoPizza,PrecoChopp,ValorPorPessoa : Numerico
Leia NumCoberturas
Leia NumTulipas
Leia NumPessoas
ValorPorPessoa <- ((PrecoPizza + PrecoChopp) * 1.1) / NumPessoas

Mais refinamentos: Na verdade, as únicas variáveis essenciais para o algoritmo são
NumCoberturas, NumTulipas, NumPessoas. Poderíamos ir eliminando todas as outras
até que o valor por pessoa fosse calculado de uma só vez, mas isto tornaria o programa de
difícil entendimento. Muitas vezes é interessante o uso de variáveis intermediárias para que se
produza um algoritmo de compreensão mais fácil. Caso você esteja interessado nesta versão
super-refinada, aí vai (se não entendê-la agora, não se preocupe; mais tarde você poderá voltar
aqui e analisá-la com mais calma...):
Leia NumCoberturas
Leia NumTulipas
Leia NumPessoas
Escreva "O valor por pessoa é "
Escreva (((10+(NumCoberturas*1.5))+(0.8*NumTulipas))*1.1)/NumPessoas
A última expressão ficou bem complicada, não é?

Lição 6 - Comentários e Mais Algoritmos
Toda linguagem de programação permite que se insiram no programa textos que não têm nada
a ver com a execução do algoritmo, mas servem para explicar a quem examiná-lo como ele
funciona, identificar o autor e data do programa, etc. A estes textos chamamos comentários.
Geralmente os comentários são precedidos de um ou dois caracteres ou uma palavra-chave da
linguagem, e vão até o fim da linha em que estão, ou podem se estender por várias linhas até
que outro grupo de caracteres apareça indicando o fim do comentário. Por curiosidade,
mostramos abaixo alguns exemplos (os caracteres que delimitam os comentários estarão em
negrito):
Em BASIC (QuickBasic, Visual Basic ou outras versões )
' Isto é um comentário - até o fim desta linha
REM Isto também é...
Em Pascal (Turbo Pascal, Delphi ou outros )
{ Isto é um comentário
pode se estender por
várias linhas }
(* Outro tipo de
comentário em várias linhas *)
Em DBase ou Clipper
* Comentário
&& Comentário
// Comentário
/* Comentário
de várias
linhas */
Em linguagem C
// Comentário até o fim da linha
/* Comentário
pode se estender por várias linhas */
Mesmo não sendo uma linguagem de programação, os algoritmos podem e devem ser
entremeados por comentários, de preferência seguindo uma das regras acima, para que os
comentários fiquem destacados e não se confundam com o "código" do algoritmo em si. Os
programadores usam comentários por várias razões, como já vimos acima:
1. Identificar o autor e a data da criação de um programa.
2. Documentar as alterações feitas no programa com o decorrer do tempo, as vezes até
explicando o porque de terem sido feitas, quem as pediu, etc.
3. Explicar (até para si mesmos, daqui a algum tempo...) o funcionamento de certos
trechos do algoritmo, que podem ser muito complexos. Isto é muito útil se mais de um
programador cuidar do programa; assim, todos ficam sabendo o que fazem as várias
partes, não importa quem as tenha criado.
4. Identificar trechos críticos no algoritmo, alertando para os efeitos que alterações
naquele ponto podem ter em outras partes do programa.
5. Justificar porque certas técnicas foram utilizadas em certos pontos do programa, etc.
Para nossos propósitos, usaremos o mesmo esquema de comentários da linguagem C. A seguir
temos a repetição da resposta do Problema 2, comentada (os trechos entre /* e */, e entre //

e o fim da linha não fazem parte do programa em si, são apenas comentários de documentação
e explicação) :
/*
Curso de Algoritmos - Problema 2
Programa que calcula a velocidade média de um piloto
Autor: C. M. Souza
Data : 02/09/1999
*/
// Declaração das Variáveis
Declare Distancia,Tempo,VelMedia : Numerico
// Apresentação do programa
// Obtenção dos dados
Leia Nome
Escreva "Digite a distância percorrida (em km) : "
Leia Distancia
Escreva "Digite o tempo gasto para percorrê-la (em horas) : "
Leia Tempo
// Cálculo da velocidade média
VelMedia <- Distância/Tempo
// Exibição dos resultados
Escreva "A velocidade média de ",Nome," foi ", VelMedia
Exercício 5
Uma financeira calcula o débito atual de uma conta atrasada da seguinte maneira: 10% de
multa sobre o valor original pelo atraso, independente do tempo, e 0.33% de juros ao dia, por
cada dia que ultrapassar 30 dias de atraso. Ela precisa de um programa que calcule o valor
atual a pagar de acordo com estas regras, e o divida pelo número de parcelas que combinou
com o devedor para o pagamento. Faça um programa que receba os seguintes dados:
• valor original do débito,
• dias de atraso além de 30 dias (caso o atraso seja menor que 30 dias, o usuário
digitará 0),
• e o número de parcelas para o pagamento.
O programa deverá calcular e exibir o valor de cada parcela.
Resposta

Lição 7 - Colocando mais Inteligência nos Programas
Até agora temos criado programas que são apenas uma sequência de comandos sem
possibilidade de escolha, ou seja não existe neles nada do tipo "se tal coisa acontecer, faça isto,
senão faça aquilo". Esta possibilidade de escolha é que dá "inteligência" aos programas de
computador; afinal, nós humanos estamos fazendo escolhas e pesando possibilidades o tempo
todo...
Todas as linguagens de programação têm comandos que permitem estes desvios da sequência
normal dos comandos de um programa baseados na avaliação de uma condição. Por isso,
estes comandos sào às vezes chamados de comandos condicionais, ou ainda desvios
condicionais. Para entendermos como estes comandos funcionam, primeiro temos que saber
o que é avaliar uma condição.
Na Lição 1, quando falamos de tipos de dados, nos referimos ao tipo Lógico, que poderia ter
apenas um de dois valores: Falso ou Verdadeiro. Estes valores se originam da análise de uma
expressão para se chegar à seguinte conclusão: ela é verdadeira ou falsa. Vejamos os exemplos
abaixo:
Expressão Resultado
A Terra gira em torno do Sol Verdadeiro
Zebras podem falar Falso
2 + 2 é igual a 5 Falso
14 é maior que 3 Verdadeiro
Todo dia 1o. de Janeiro é Segunda-Feira Falso
"Raposa" vem antes de "Borboleta" na ordem
alfabética
Falso
A palavra "José" começa com a letra "J" Verdadeiro
Devemos ter em mente, então, que uma expressão lógica pode conter qualquer tipo de
dados, pois o que nos interessa é saber que, ao analisá-la, concluiremos se é falsa ou
verdadeira. Num primeiro momento, estaremos interessados em expressões lógicas contendo
apenas valores numéricos, mas depois vamos analisar condições com outros tipos de dados.
Para trabalharmos com números, precisamos conhecer os operadores que nos permitem
compará-los. Nós os chamamos operadores relacionais (o nome não é importante, e sim
saber como usá-los). Eles são:
Nome Símbolo Exemplos Resultado
Igual a = 3 = 3 Verdadeiro
2+2 = 5 Falso
Diferente de <> 140 <> 410 Verdadeiro
(10+5) <> (30/2) Falso
(as duas expressões têm resultado 15)
Menor que < 13 < 7 Falso
77 < 20 * 2 Falso
Maior que > 0 > -1 Verdadeiro
345 > ((3 +1)*100) Falso (345 não é maior que 400...)

Menor ou igual a <= 20 <=20 Verdadeiro
19 <= 20 Verdadeiro
21 <= 20 Falso
Maior ou igual a >= 21 >= 20 Verdadeiro
19 >= 20 Falso
20 >= 20 Verdadeiro
Pelos exemplos acima, você deve ter notado que quando qualquer um dos "lados" da expressão
(tecnicamente dizemos "quando qualquer um dos operandos") for uma expressão aritmética e
não um simples número, nós a calculamos primeiro para depois fazer as comparações. Como a
prioridade dos operadores relacionais é maior que a dos operadores aritméticos, temos que
colocar a expressão numérica entre parênteses. Nestas expressões podem aparecer
variáveis, também, como nestes exemplos (para verificar, substitua os valores de x e y nas
expressões, calcule-as e compare-as) :
Comandos e Expressões Resultado
x <- 33
y <- 4
x = 33 Verdadeiro
(x+1) <> 90 Verdadeiro
(y * 2) = 10 Falso
(x/3) >= 11 Verdadeiro
(y + x) > 40 Falso
(y * 8) <= x Verdadeiro
Exercício 6
Dadas as variáveis A, B, C e D, numéricas, e os seguintes comandos de atribuição:
A <- 10
B <- 15
C <- 8
D <- 20
Avalie as expressões abaixo e descubra se são falsas ou verdadeiras.
1. A = (D / 2)
2. (B * 2) = (A + D)
3. B >= A
4. (A * ( C + 2 )) <> (D * 5)
5. (A + B + C + D) >= 43
Resposta
Exercício 7
Calcule o valor de K nas expressões lógicas abaixo de modo que sempre retornem Verdadeiro
como resultado (leve em consideração o valor das outras variáveis, I e J, atribuídos da seguinte
maneira):

I <- 18
J <- I / 2
1. (9 + K) = 17
2. K = (I + J)
3. (3 * K) = I
4. (K + J) = (I + 10)
5. (K / 2) = (I * 3) / ( J - 3 )
Resposta
Exercício 8
Calcule o maior valor possível para K nas expressões lógicas abaixo de modo que sempre
retornem Verdadeiro como resultado (leve em consideração o valor das outras variáveis, I e J,
atribuídos da seguinte maneira):
I <- 25
J <- I - 13
1. K <= (I - J)
2. K < (I - J)
3. (K * I) <= ((J + 8) * 4)
4. (K * I) <= I
Resposta

Lição 8 - Ensinando o Computador a Decidir
Depois de aprendermos o que são expressões lógicas, iremos ver agora como colocá-las em
nossos programas. Todas as linguagens de programação têm um ou mais comandos que
permitem a um programa tomar caminhos diferentes baseado na avaliação de uma expressão
lógica. Esses comandos recebem o nome genérico de comandos de decisão, e nós podemos
usá-los também em nossos algoritmos.
Na vida real tomamos decisões a todo momento baseados em uma situação existente. Em
programação chamamos esta situação de condição, e as alternativas possíveis de ações. Por
exemplo: "Se tiver R$10,00 sobrando irei ao cinema hoje à noite, mas se não tiver ficarei vendo
TV em casa". Qual é a condição nesta frase? Fácil, "tiver R$10,00 sobrando". Ela é uma
expressão lógica, pois a pergunta "Tenho R$10,00 sobrando?" pode (tem que) ser respondida
com "Sim" ou "Não". Lembre-se, então: em um algoritmo, toda condição tem que ser uma
expressão lógica. Quais são as ações possíveis? Fácil, mais uma vez; "irei ao cinema" e
"ficarei vendo TV em casa". A primeira só será realizada se a resposta à pergunta "Tenho
dinheiro suficiente?" for "Sim", enquanto que a segunda será realizada caso a resposta seja
"Não". Então, em um algoritmo, as ações são um ou mais comandos que serão
realizados, alguns caso a avaliação da condição resulte em Verdadeiro, outros caso ela
resulta em Falso.
Vamos colocar agora a frase do parágrafo anterior em outra forma, mais parecida com o que é
um programa de computador:
Se "tiver R$10,00 sobrando" então
"irei ao cinema"
senão
"ficarei vendo TV em casa".
Veja que grifamos três palavras: Se então senão. Elas são muito importantes na estrutura
dos comandos de decisão. Como próximo passo, vamos generalizar a estrutura que criamos
acima:
Se <condição> então
<ações (uma ou mais) a serem realizadas se a condição for verdadeira>
senão
<ações (uma ou mais) a serem realizadas se a condição for falsa>
Para terminar a nossa comparação, devemos lembrar que os comandos do algoritmo são
sempre imperativos, e que o computador só lida com quantidades definidas (ou seja, ele não
sabe o que é "ter R$10,00 sobrando"). Para aproximar mais nossa frase de um algoritmo,
poderemos ter a seguinte forma:
Se Dinheiro >= 10 então
Ir ao Cinema
senão
Ver TV em Casa
Entendeu a transformação? "Dinheiro" faz o papel de uma variável que contém o que eu tenho
sobrando no momento, e se valor é maior ou igual a 10, então "tenho R$10,00 sobrando". Por
falar nisso, fique sabendo que a técnica (ou arte) de se transformar perguntas do dia-a-dia em
quantidades definidas que possam ser colocadas em um programa é a chave de se fazer
algoritmos. Não se preocupe, no entanto: é algo fácil e que pode ser aprendido e desenvolvido.
Bom, agora já podemos fazer um programa que ajude nosso amigo...

Problema 4 - O que faço esta noite?
Enunciado
Faça um programa que peça ao usuário a quantia em dinheiro que tem sobrando e sugira, caso
ele tenha 10 ou mais reais, que vá ao cinema, e se não tiver, fique em casa vendo TV.
Declare Dinheiro: Numerico
Escreva "Serviço Informatizado de Sugestões"
Escreva "Quanto dinheiro você tem sobrando?"
Leia Dinheiro
Se Dinheiro >= 10 entao
Escreva "Vá ao cinema hoje à noite."
senao
Escreva "Fique em casa vendo TV."
fim se
Escreva "Obrigado e volte sempre."
Em relação ao que vimos até agora, apenas uma novidade: a expressão fim se ao final do
comando de decisão. Ela delimita o comando, isto é, mostra onde as ações da parte senão do
comando terminam. Imagine o comando sem ela; ficaria assim:
// Exemplo de um trecho de programa INCORRETO
senao
Neste caso, o computador não saberia se o comando Escreva "Obrigado e volte
sempre." faria ou não parte do comando de decisão (a indentação, ou seja, o fato de
algumas linhas estarem mais distantes da margem esquerda que as outras, não quer dizer nada
para o computador; fazemos isto apenas - e esta é uma dica importante para você - para que o
algoritmo fique mais fácil de ler). Assim o fim se é fundamental, e todas as linguagens de
programação têm algo que cumpra esta função.
Quer saber como este algoritmo funciona? Clique aqui.

RESPOSTA LIÇÃO DA LIÇÃO 5 A LIÇÃO 8
Enunciado:Uma financeira calcula o débito atual de uma conta atrasada da seguinte maneira:
10% de multa sobre o valor original pelo atraso, independente do tempo, e 0.33% de juros ao
dia, por cada dia que ultrapassar 30 dias de atraso. Ela precisa de um programa que calcule o
valor atual a pagar de acordo com estas regras, e o divida pelo número de parcelas que
combinou com o devedor para o pagamento. Faça um programa que receba os seguintes
dados:
• valor original do débito,
• dias de atraso além de 30 dias (caso o atraso seja menor que 30 dias, o usuário
digitará 0),
• e o número de parcelas para o pagamento.
O programa deverá calcular e exibir o valor de cada parcela.
/*
Curso de Algoritmos - Exercício 5
Programa para calcular prestações de débito em atraso
Autor: C. M. Souza
Data : 11/09/1999
*/
Declare ValorOriginal,DiasdeAtraso,ValorAtual,NumParcelas : Numerico
// Apresentacao do Programa
Escreva "Programa para calcular prestações de débito em atraso"
// Leitura dos dados necessarios para o calculo
Escreva "Qual o valor original do débito ? "
Leia ValorOriginal
// Instruindo o usuario para o fornecimento correto dos dados...
Escreva "Quantos dias de atraso além de 30 dias ?"
Escreva "(Digite 0 se o atraso for menor ou igual a 30 dias.)"
Leia DiasDeAtraso
// Calculo do valor atual
// Observacoes:
// 1 - Multiplicar um valor por 1.1 é o mesmo que acrescentar 10%; é o
calculo da multa.
// 2 - 0.33% é 0.0033 (lembre-se que POR CENTO siginifica DIVIDIR POR
CEM)
ValorAtual <- (ValorOriginal * 1.1) + (ValorOriginal * 0.0033 *
DiasDeAtraso)
Escreva "O valor atual do débito é ", ValorAtual
Escreva "Em quantas parcelas será feito o pagamento?"
Leia NumParcelas

Escreva "O débito será pago em ", NumParcelas, " parcela(s) de R$",
ValorAtual/NumParcelas
Enunciado:Dadas as variáveis A, B, C e D, numéricas, e os seguintes comandos de atribuição:
A <- 10
B <- 15
C <- 8
D <- 20
Avalie as expressões abaixo e descubra se são falsas ou verdadeiras.
1. A = D / 2
2. B * 2 = A + D
3. B >= A
4. A * ( C + 2 ) <> D * 5
5. A + B + C + D >= 43
Resposta: 1) Verdadeiro; 2) Verdadeiro; 3) Verdadeiro; 4) Falso; 5) Verdadeiro
Enunciado:Calcule o valor de K nas expressões lógicas abaixo de modo que sempre retornem
Verdadeiro como resultado (leve em consideração o valor das outras variáveis, I e J, atribuídos
da seguinte maneira):
I <- 18
J <- I / 2
1. 9 + K = 17
2. K = I + J
3. 3 * K = I
4. K + J = I + 10
5. (K / 2) = (I * 3) / ( J - 3 )
Resposta:
1. 8
9 + K = 17
9 + 8 = 17
2. 27
K = I + J
27 = 18 + 9
3. 6
3 * K = I
3 * 6 = 18
4. 1
K + J = I + 10
1 + 18 = 9 + 10

5. 18
(K / 2) = ( I * 3) / ( J - 3 )
(K / 2) = (18 * 3) / ( 9 - 3 )
(K / 2) = 54 / 6
(K / 2) = 9
(18/ 2) = 9
Enunciado:Calcule o maior valor possível para K nas expressões lógicas abaixo de modo que
sempre retornem Verdadeiro como resultado (leve em consideração o valor das outras
variáveis, I e J, atribuídos da seguinte maneira):
I <- 25
J <- I - 13
1. 12
K <= I - J
12 <= 25 - 13
(12 é o maior valor possível, porque se K valer 13 por exemplo,
teremos 13 <= 12, o que retornaria Falso)
2. 11
K < I - J
11 < 25 - 13
(11 é o maior valor possível, porque se K valer 12 por exemplo,
teremos 12 < 12, o que retornaria Falso)
3. 3
K * I <= (J + 8) * 4
K * 25 <= (12 + 8) * 4
K * 25 <= 20 * 4
K * 25 <= 80
3 * 25 <= 80
(se K valer 3, K * 35 é 75, que ainda é menor ou igual a que 80;
se K valer 4, K * 25 é 100, o que nos dá 100 <= 80 como Falso)
4. 1
K * I <= I
1 * I <= I
Como Funciona o Algoritmo do Problema 4
Vamos seguir o algoritmo do Problema 4 passo a passo, como se fôssemos o computador. A
linha em vermelho indica o comando que está sendo realizado a cada momento. A
declaração da variável Dinheiro não é realmente um comando a ser executado, portanto já
começaremos como o primeiro comando Escreva. Ele vai colocar o título do programa na tela
do computador.
Leia Dinheiro
Senao
Fim se

Logo depois o segundo comando Escreva vai colocar a outra mensagem na tela (para orientar
o usuário).
Leia Dinheiro
Senao
Fim se
Depois, o comando Leia vai esperar que o usuário forneça um valor e tecle Enter.
Leia Dinheiro
Senao
Fim se
Vamor supor que o valor digitado seja 20. No comando Se...Então o programa vai testar se
o valor armazenado na variável Dinheiro é maior ou igual a 10.
Leia Dinheiro
Senao
Fim se
Sabemos que o valor da variável Dinheiro é 20. Logo a avaliação da condição Dinheiro >=
10 tem o mesmo resultado que 20 >= 10, isto é, Verdadeiro. Assim, a parte antes do Senão
será executada. A mensagem "Vá ao cinema hoje à noite" será colocada na tela do computador
Leia Dinheiro
Senao
Fim se
Agora o program pula a parte do Senão, pois ela só seria executada caso o resultado de
Dinheiro >= 10 fosse Falso, e se dirige ao primeiro comando após o Fim se (daí a
importãncia desta parte do comando) e imprime a mensagem "Obrigado e volte sempre". Logo
depois, o programa termina.

Leia Dinheiro
Senao
Fim se
Refaça agora o processo, usando os valores 10 e depois 8 para a variável Dinheiro. Veja
como o programa se comporta, e que comandos foram executados.

Lição 9 - Mais Algoritmos com Decisões
Problema 5 - Posso Entrar na Boate?
Enunciado
Faça um programa que peça o ano de nascimento de uma pessoa, e diga, se for maior de
idade, que pode entrar na boate, e se não for, não pode.
Declare AnoNascimento, Idade: Numerico
Escreva "Checagem de Idade da Boate Noites Cariocas"
Escreva "Em que ano você nasceu?"
Leia AnoNascimento
Idade <- 2002 - AnoNascimento
Se Idade >= 18 entao
Escreva "Você pode entrar na boate."
senao
Escreva "Infelizmente, você não pode entrar."
fim se
Neste algoritmo criamos uma variável "rascunho", que chamamos Idade, para conter o
resultado do cálculo da idade da pessoa (que é o ano atual menos o ano em que a pessoa
nasceu - Nota: este algoritmo foi escrito em Janeiro de 2002). Como você já deve ter notado,
ela é dispensável. Veja o algoritmo abaixo.
Declare AnoNascimento: Numerico
Leia AnoNascimento
Se (2002 - AnoNascimento) >= 18 entao
senao
fim se
A partir de 2003, este algoritmo não vai mais funcionar corretamente. Portanto, vamos
melhorá-lo de modo a que possa funcionar em qualquer ano.
Declare AnoAtual, AnoNascimento: Numerico
Escreva "Qual é o ano atual?"
Leia AnoAtual
Leia AnoNascimento
Se (AnoAtual - AnoNascimento) >= 18 entao
senao
fim se
Exercício 9

Faça um programa que receba o valor do salário de uma pessoa e o valor de um financiamento
pretendido. Caso o financiamento seja menor ou igual a 5 vezes o salário da pessoa, o
programa deverá escrevar "Financiamento Concedido"; senão, escreverá "Financiamento
Negado". Independente de conceder ou não o financiamento, o programa escreverá depois a
frase "Obrigado por nos consultar."
Resposta
Exercício 10
Em uma escola, o aluno faz duas provas por período, com as notas variando de 0 a 10. Caso a
média aritmética das duas notas seja 5 ou mais, ele passa de ano; senão, ele é reprovado. Faça
um programa que receba as duas notas de um aluno e escreva se ele passou ou não de ano.
Resposta
Exercício 11
Dois carros percorreram diferentes distâncias em diferentes tempos. Sabendo que a velocidade
média é a razão entre a distância percorrida e o tempo levado para percorrê-la, faça um
programa que leias as distâncias que cada carro percorreu e o tempo que cada um levou, e
indique o carro que teve maior velocidade média.
Resposta
Exercício 12
Faça um programa que leia o nome e idade de duas pessoas e imprima o nome da pessoa mais
nova, e seu ano de nascimento (o programa deve funcionar corretamente para qualquer que
seja o ano atual).
Resposta

RESPOSTAS ATÉ O EXERCÍCIO 12
Enunciado: Faça um programa que receba o valor do salário de uma pessoa e o valor de um
financiamento pretendido. Caso o financiamento seja menor ou igual a 5 vezes o salário da
pessoa, o programa deverá escrevar "Financiamento Concedido"; senão, escreverá
"Financiamento Negado". Independente de conceder ou não o financiamento, o programa
escreverá depois a frase "Obrigado por nos consultar."
Declare Salario,Financiamento : Numerico
// Apresentacao do Programa
Escreva "Programa para Aprovação de Financiamento"
// Leitura dos dados necessarios para o calculo
Escreva "Qual o valor do seu salário?"
Leia Salario
Escreva "Qual o valor do financiamento pretendido?"
Leia Financiamento
// Realizando os cálculos
Se Financiamento <= (Salario * 5) entao
Escreva "Financiamento Concedido"
Senao
Escreva "Financiamento Negado"
Fimse
// Concedendo ou não o financiamento, agradece...
Escreva "Obrigado por nos consultar"
Enunciado:Em uma escola, o aluno faz duas provas por período, com as notas variando de 0 a
10. Caso a média aritmética das duas notas seja 5 ou mais, ele passa de ano; senão, ele é
reprovado. Faça um programa que receba as duas notas de um aluno e escreva se ele passou
ou não de ano.
Declare Nota1, Nota2, Media : Numerico
Escreva "Digite a Nota 1:"
Leia Nota1
Leia Nota2
Media <- (Nota1 + Nota2) /2
Se Media >=5 entao
Escreva "Aluno aprovado"
Senao
Escreva "Aluno reprovado"
Fimse
Refinamento: Podemos fazer os mesmos cálculos sem utilizar a variável Media. Preste
atenção no uso dos parênteses.

Declare Nota1, Nota2 : Numerico
Leia Nota1
Leia Nota2
Se ((Nota1 + Nota2) /2) >=5 entao
Senao
Fimse
Enunciado:Dois carros percorreram diferentes distâncias em diferentes tempos. Sabendo que
a velocidade média é a razão entre a distância percorrida e o tempo levado para percorrê-la,
faça um programa que leias as distâncias que cada carro percorreu e o tempo que cada um
levou, e indique o carro que teve maior velocidade média.
// Distância percorrida, tempo gasto e velocidade media de cada carro
Declare Distancia1, Distancia2, Tempo1, Tempo2, VelMed1, VelMed2 :
Numerico
// Leitura dos dados
Escreva "Distância percorrida pelo Carro 1:"
Leia Distancia1
Escreva "Tempo gasto pelo Carro 1:"
Leia Tempo1
Leia Distancia2
Leia Tempo2
// Cálculo e exibição das velocidades médias
VelMed1 <- Distancia1 / Tempo1
Escreva "Velocidade média do Carro 1:", VelMed1
// Resultado
Se VelMed1 > VelMed2 entao
Escreva "O Carro 1 teve maior velocidade média."
Senao
Fimse
Você deve estar se perguntando: "E se os dois carros tiverem a mesma velocidade média?"
Neste caso, nosso programa vai dar uma informação errada, dizendo que o Carro 2 foi mais
rápido! Você consegue ver por quê?
Enunciado: Faça um programa que leia o nome e idade de duas pessoas e imprima o nome da
pessoa mais nova, e seu ano de nascimento (o programa deve funcionar corretamente para
qualquer que seja o ano atual).

(Bom, todas as linguagens de programação têm comandos que permitem ao programa obter a
data do relógio do computador, mas como nosso algoritmo não é realmente feito em uma
destas linguagens, teremos que pedir ao usuário para fornecer o ano em que estamos e fazer
nossos cálculos a partir deste valor.)
// Ano Atual, Idades e Nomes das duas pessoas
Declare AnoAtual, Idade1, Idade2 : Numerico
Declare Nome1, Nome2 : Numerico
Escreva "Qual o ano atual ?"
Leia AnoAtual
Escreva "Nome da 1a Pessoa :"
Leia Nome1
Escreva "Idade da 1a Pessoa :"
Leia Idade1
Escreva "Nome da 2a Pessoa :"
Leia Nome2
Escreva "Idade da 2a Pessoa :"
Leia Idade2
// Resultado
Se Idade1 < Idade2 entao
Escreva "A pessoa mais jovem é : ", Nome1, "Ela nasceu em ",
AnoAtual - Idade1
Senao
Escreva "A pessoa mais jovem é : ", Nome2, "Ela nasceu em ",
AnoAtual - Idade2
Fimse
Assim como no problema anterior, você deve estar se perguntando: "E se as duas pessoas
tiverem a mesma idade?" Neste caso, nosso programa vai dar uma informação errada, do
mesmo modo que no problema acima...

Lição 10 - Refinando Nossas Decisões
Nem sempre as respostas aos testes feitos nos programas são simples como "Sim" "Não",
"Falso" ou "Verdadeiro". Quando perguntamos por exemplo se A é igual a B, é claro que a
resposta é "Sim"ou "Não"; às vezes, no entanto, estamos interessados em saber a relação
entre duas quantidades, isto é, queremos saber por exemplo se A é maior que B, se B é maior
que A, ou se os dois valores são iguais. Neste caso, um teste apenas não é suficiente, pois
temos três possibilidades e ele vai eliminar apenas uma delas, sendo necessário um outro
teste para verificar entre as duas restantes qual a possibilidade correta. Vejamos estes
exemplos:
Problema 6 - Qual o Carro mais Rápido?
Enunciado
Dois carros percorreram diferentes distâncias em diferentes tempos. Sabendo que a velocidade
média é a razão entre a distância percorrida e o tempo levado para percorrê-la, faça um
programa que leias as distâncias que cada carro percorreu e o tempo que cada um levou, e
indique o carro que teve maior velocidade média. Este problema é a versão final (e correta) do
exercício 11.
// Distância percorrida, tempo gasto e velocidade media de cada carro
Declare Distancia1, Distancia2, Tempo1, Tempo2, VelMed1, VelMed2 :
Numerico
Leia Distancia1
Leia Tempo1
Leia Distancia2
Leia Tempo2
// Cálculo e exibição das velocidades médias
// Resultado (Note que há dois testes)
Senao
// Eliminamos a primeira possibilidade (de o carro 1 ser mais
rápido)
// Agora vamos ver entre as duas restantes
Senao
// Eliminamos também a segunda possibilidade (de o carro 2 ser
mais rápido)
// Então, so resta a terceira (os dois carros tiveram a mesma
velocidade média)
Escreva "Os dois carros tiveram a mesma velocidade média."

Fimse
Fimse
Neste problema estamos vendo também como se coloca uma estrutura de teste
(se...então...senao...fimse) dentro de outra. A indentação não é obrigatória, mas note
como ela facilita o entendimento do algoritmo.
Problema 7 - Passei de Ano?
Enunciado
Em uma escola, um aluno passa direto se obtiver média final maior que ou igual a 7. Se a
média for inferior a 4, ele está reprovado direto, sem direito a prova final. Em outro caso, ele
vai à final, e a nota que ele precisa para passar é o que falta à média final para completar 10.
Faça um programa que receba as duas notas parciais, calcule a média final e informe ao aluno
sua situação, inclusive informando a ele quanto precisa tirar na final, se este for o seu caso.
Este problema é uma variação (um pouco mais complicada...) do exercício 10.
Declare Nota1, Nota2, Media : Numerico
Leia Nota1
Leia Nota2
// Cálculo
Media <- (Nota1 + Nota2) /2
// Exibição dos resultados
Escreva "Sua média final é :", Media
// Vamos eliminar a primeira possibilidade
Se Media >= 7 entao
Senao
// Ele pode ter sido reprovado ou ficado em final
// Primeiro, eliminamos a possibilidade de ele ter sido reprovado
direto
Se Media < 4 entao
Senao
// Então, ficou em final...
Escreva "Você está na final, e precisa de ", 10 - Media
Fimse
Fimse

Lição 11 - Trabalhando com Tabelas (1)
Uma das aplicações mais comuns em programação é a pesquisa de um valor em uma tabela,
quer para saber se um dado está ou não em uma lista de valores, ou para saber em que faixa
de uma tabela um valor se enquadra, entre outras. Neste exemplo vamos analisar este
segundo caso.
Problema 8 - Qual o Conceito do Aluno?
Enunciado
Em uma escola o conceito de um aluno é dado baseado em sua média final, de acordo com a
seguinte tabela:
Nota de... Até... Conceito
0 3.9 Fraco
4 6.9 Regular
7 8.9 Bom
9 10 Excelente
Faça um programa que receba a média final de um aluno e imprima o conceito correspondente.
De acordo com o que vimos na resolução dos problemas da lição anterior, um teste apenas ou
dois não vão resolver nosso problema. De uma forma geral, se temos n possibilidades, temos
que ter n-1 testes para cobrir todas as respostas possíveis. Vamos fazer uma primeira
abordagem para resolver este problema, e depois vamos refiná-la.
Declare Media : Numerico
Escreva "Qual a média do aluno?"
Leia Media
Se (Media >=0) e (Media<=3.9) entao
Escreva "Conceito : Fraco"
Senao
Escreva "Conceito : Regular"
Senao
Escreva "Conceito : Bom"
Senao
Se (Media >=9) e (Media<=10) entao
Escreva "Conceito : Excelente"
Fimse
Fimse
Fimse
Fimse
Refinamento 1: Analisando a tabela, vemos que as notas variam de 0 a 10, o que significa que
os testes (Media>=0) e (Media<=10) são desnecessários pois sempre vão resultar em
"Verdadeiro", e não colaboram para a resolução do problema. Por outro lado, se uma nota não
passa pelo teste (Media>=0) e (Media <=3.9), é claro que ela é maior ou igual a 4, e o teste
(Media >=4) também é desnecessário. Do mesmo modo, então, os testes (Media>=7) e
(Media>=9) também são dispensáveis nos pontos onde se encontram no algoritmo. Sendo
assim, chegamos a uma segunda versão do programa, bem mais simplificada.

Leia Media
Se Media <= 3.9 entao
Escreva "Conceito : Fraco"
Senao
Escreva "Conceito : Regular"
Senao
Escreva "Conceito : Bom"
Senao
Escreva "Conceito : Excelente"
Fimse
Fimse
Fimse
Note que temos 4 possibilidades de conceitos e realizamos 3 testes, eliminando uma
possibilidade de cada vez. Note também que não usamos os valores da coluna "Nota de.." para
nenhum teste, apenas os valores da coluna "Até...". Mesmo assim, o último valor (10) não foi
usado, pois se enquadrou no último senao, isto é, se um aluno não é Fraco, Regular ou Bom
só pode ser Excelente.
Refinamento 2: Note que a expressão "Conceito :" aparece quatro vezes no algoritmo.
Podemos melhorá-lo se guardarmos o conceito do aluno em uma variável para usá-la uma vez
só no fim do programa.
Declare Conceito : Caracter
Leia Media
Conceito <- "Fraco"
Senao
Conceito <- "Regular"
Senao
Conceito <- "Bom"
Senao
Conceito <- "Excelente"
Fimse
Fimse
Fimse
Escreva "Conceito do Aluno : ", Conceito
Em um programa simples como este a utilidade desta técnica não fica evidente, mas no
próximo problema você poderá ver como ela melhora o entendimento e otimiza o algoritmo.

Lição 12 - Trabalhando com Tabelas (2)
Problema 9 - Quanto Ganhará o Vendedor?
Enunciado
Em uma empresa o salário final de um vendedor é composto de um valor fixo mais um
percentual sobre suas vendas, de acordo com a seguinte tabela:
Vendas
de...
Até... Percentual
R$ 0,00 R$ 1.500,00 2%
R$ 1.500,01 R$ 3.000,00 3%
R$ 3.000,01 R$ 6.000,00 5%
R$ 6.000,01 Sem Limite 6%
Além disso, ele é descontado em R$ 5,00 por cada dia de falta ao serviço. Faça um programa
que receba o valor da parte fixa do salário, o total de vendas no período e o número de faltas
de um vendedor e imprima o o seu salário final.
Declare Fixo, Vendas, Faltas, Percentual, Comissao, Desconto, Salario
: Numerico
Escreva "Qual o valor fixo?"
Leia Fixo
Escreva "Qual o total de vendas?"
Leia Vendas
Escreva "Qual o número de faltas?"
Leia Faltas
// Primeiro, vamos achar o percentual para o cálculo das comissões
Se Vendas <= 1500 entao
Percentual <- 2
Senao
Percentual <- 3
Senao
Percentual <- 5
Senao
Percentual <- 6
Fimse
Fimse
Fimse
// Agora calculamos o valor da comissão variável (observe a divisão
por 100 - é o percentual...)
Comissao <- Vendas * Percentual / 100
// Então calculamos o desconto por faltas (R$5,00 por falta)
Desconto <- Faltas * 5
// E descobrimos o salario final...
Salario <- Fixo + Comissao - Desconto
Escreva "O salário final do vendedor é :", Salario

Refinamento: Vamos eliminar todas as variáveis "desnecessárias" e escrever um algoritmo
mais "enxuto". Note que sempre que fazemos isso, o programa se torna mais difícil de analisar,
principalmente para um principiante; portanto se não conseguir entender o que foi feito não se
preocupe, pois a solução acima está 100% correta. Quando estiver mais confiante volte aqui e
analise esta outra solução. Por outro lado, lembre-se que na maioria dos casos a legibilidade é
uma característica tão importante dos programas quanto a eficiência ou economia de
memória.
Declare Fixo, Vendas, Faltas, Percentual : Numerico
Escreva "Qual o valor fixo?"
Leia Fixo
Escreva "Qual o total de vendas?"
Leia Vendas
Escreva "Qual o número de faltas?"
Leia Faltas
// Primeiro, vamos achar o percentual para o cálculo das comissões
Percentual <- 2
Senao
Percentual <- 3
Senao
Percentual <- 5
Senao
Percentual <- 6
Fimse
Fimse
Fimse
Escreva "O salário final do vendedor é :", Fixo + (Vendas * Percentual
/ 100) - (Faltas * 5)
Exercício 13
Faça um programa que calcule o imposto de renda a ser descontado de um funcionário de
acordo com a seguinte tabela:
Salário de... Até... Percentual
R$ 0,00 R$ 1.000,00 0%
R$ 1.000,01 R$ 2.500,00 15%
R$ 2.500,01 R$ 5.000,00 25%
R$ 5.000,01 Sem Limite 27%
O programa deverá receber o valor do salário, calcular o imposto devido e imprimir:
1 - o salário bruto;
2 - o percentual encontrado para o desconto;
3 - o valor do imposto e ser descontado e
4 - o salário líquido (o valor efetivamente recebido).
Resposta
Exercício 14

Usando a mesma tabela do exercício anterior, faça um programa que calcule o salário de um
funcionário baseado em seu salário-dia. O programa receberá o salário-dia e o número de dias
que o funcionário faltou ao serviço (considera-se o mês completo como tendo 30 dias). O
funcionário tem direito ainda a um adicional de 6% de produtividade sobre o salário bruto
(depois do desconto das faltas). O valor do imposto será calculado sobre o salário + adicional.
Resposta

A Linguagem de Programação do
VisuAlg (5)
O VisuAlg implementa algumas extensões às linguagens "tradicionais" de programação, com o
intuito principal de ajudar o seu uso como ferramenta de ensino. Elas são mostradas a seguir.
Comando Aleatório
Muitas vezes a digitação de dados para o teste de um programa torna-se uma tarefa
entediante. Com o uso do comando aleatorio do VisuAlg, sempre que um comando leia
for encontrado, a digitação de valores numéricos e/ou caracteres é substituída por uma
geração aleatória. Este comando não afeta a leitura de variáveis lógicas: com certeza, uma
coisa pouco usual em programação...
Este comando tem as seguintes sintaxes:
aleatorio [on]
Ativa a geração de valores aleatórios que substituem a
digitação de dados. A palavra-chave on é opcional. A faixa
padrão de valores gerados é de 0 a 100 inclusive. Para a
geração de dados do tipo caractere, não há uma faixa pré-
estabelecida: os dados gerados serão sempre strings de 5
letras maiúsculas.
aleatorio <valor1 > [,
<valor2 > ]
Ativa a geração de dados numéricos aleatórios
estabelecendo uma faixa de valores mínimos e máximos. Se
apenas < valor1> for fornecido, a faixa será de 0 a
<valor1> inclusive; caso contrário, a faixa será de
<valor1> a <valor2> inclusive. Se <valor2> for menor
que <valor1>, o VisuAlg os trocará para que a faixa fique
correta.
Importante: <valor1> e <valor2> devem ser constantes
numéricas, e não expressões.
aleatorio off
Desativa a geração de valores aleatórios. A palavra-chave
off é obrigatória.
Comando Arquivo
Muitas vezes é necessário repetir os testes de um programa com uma série igual de dados.
Para casos como este, o VisuAlg permite o armazenamento de dados em um arquivo-texto,
obtendo deles os dados ao executar os comandos leia.
Esta característica funciona da seguinte maneira:
1) Se não existir o arquivo com nome especificado, o VisuAlg fará uma leitura de dados
através da digitação, armazenando os dados lidos neste arquivo, na ordem em que forem
fornecidos.
2) Se o arquivo existir, o VisuAlg obterá os dados deste arquivo até chegar ao seu fim. Daí
em diante, fará as leituras de dados através da digitação.
3) Somente um comando arquivo pode ser empregado em cada pseudocódigo, e ele
deverá estar na seção de declarações (dependendo do "sucesso" desta característica, em
futuras versões ela poderá ser melhorada...).

4) Caso não seja fornecido um caminho, o VisuAlg irá procurar este arquivo na pasta de
trabalho corrente (geralmente, é a pasta onde o programa VISUALG.EXE está). Este comando
não prevê uma extensão padrão; portanto, a especificação do nome do arquivo deve ser
completa, inclusive com sua extensão (por exemplo, .txt, .dat, etc.).
A sintaxe do comando é:
arquivo <nome-de-arquivo>
<nome-de-arquivo> é uma constante caractere (entre aspas duplas). Veja o exemplo a seguir:
algoritmo "lendo do arquivo"
arquivo "teste.txt"
var x,y: inteiro
inicio
para x de 1 ate 5 faca
leia (y)
fimpara
fimalgoritmo
Comando Timer
Embora o VisuAlg seja um interpretador de pseudocódigo, seu desempenho é muito bom: o
tempo gasto para interpretar cada linha digitada é apenas uma fração de segundo. Entretanto,
por motivos educacionais, pode ser conveniente exibir o fluxo de execução do pseudocódigo
comando por comando, em "câmera lenta". O comando timer serve para este propósito:
insere um atraso (que pode ser especificado) antes da execução de cada linha. Além disso,
realça em fundo azul o comando que está sendo executado, da mesma forma que na execução
passo a passo.
Sua sintaxe é a seguinte:
timer on Ativa o timer.
timer <tempo-de-
atraso>
Ativa o timer estabelecendo seu tempo de atraso em milissegundos.
O valor padrão é 500, que equivale a meio segundo. O argumento
<tempo-de-atraso> deve ser uma constante inteira com valor
entre 0 e 10000. Valores menores que 0 são corrigidos para 0, e
maiores que 10000 para 10000.
timer off Desativa o timer.
Ao longo do pseudocódigo, pode haver vários comandos timer. Todos eles devem estar na
seção de comandos. Uma vez ativado, o atraso na execução dos comandos será mantido até
se chegar ao final do pseudocódigo ou até ser encontrado um comando timer off.
Comandos de Depuração
Nenhum ambiente de desenvolvimento está completo se não houver a possibilidade de se
inserir pontos de interrupção (breakpoints) no pseudocódigo para fins de depuração. VisuAlg
implementa dois comandos que auxiliam a depuração ou análise de um pseudocódigo: o
comando pausa e o comando debug.
Comando Pausa
Sua sintaxe é simplesmente:
pausa

Este comando insere uma interrupção incondicional no pseudocódigo. Quando ele é
encontrado, o VisuAlg pára a execução do pseudocódigo e espera alguma ação do
programador. Neste momento, é possível: analisar os valores das variáveis ou das saídas
produzidas até o momento; executar o pseudocódigo passo a passo (com F8); prosseguir sua
execução normalmente (com F9); ou simplesmente terminá-lo (com Ctrl-F2). Com exceção da
alteração do texto do pseudocódigo, todas as funções do VisuAlg estão disponíveis.
Comando Debug
Sua sintaxe é:
debug <expressão-lógica>
Se a avaliação de <expressão-lógica> resultar em valor VERDADEIRO, a execução do
pseudocódigo será interrompida como no comando pausa. Dessa forma, é possível a inserção
de um breakpoint condicional no pseudocódigo.
Comando Eco
Sua sintaxe é:
eco on | off
Este comando ativa (eco on) ou desativa (eco off) a impressão dos dados de entrada na
saída-padrão do VisuAlg, ou seja, na área à direita da parte inferior da tela. Esta característica
pode ser útil quando houver uma grande quantidade de dados de entrada, e se deseja apenas
analisar a saída produzida. Convém utilizá-la também quando os dados de entrada provêm de
um arquivo já conhecido.
Comando Cronômetro
Sua sintaxe é:
cronometro on | off
Este comando ativa (cronometro on) ou desativa (cronometro off) o cronômetro interno
do VisuAlg. Quando o comando cronometro on é encontrado, o VisuAlg imprime na saída-
padrão a informação "Cronômetro iniciado.", e começa a contar o tempo em milissegundos.
Quando o comando cronometro off é encontrado, o VisuAlg imprime na saída-padrão a
informação "Cronômetro terminado. Tempo decorrido: xx segundo(s) e xx ms". Este comando é
útil na análise de desempenho de algoritmos (ordenação, busca, etc.).
Comando Limpatela
Sua sintaxe é
limpatela
Este comando simplesmente limpa a tela DOS do Visualg (a simulação da tela do computador).
Ele não afeta a "tela" que existe na parte inferior direita da janela principal do Visualg.

Operadores Aritméticos
+,-
Operadores unários, isto é, são aplicados a um único operando. São os operadores
aritméticos de maior precedência. Exemplos: -3, +x. Enquanto o operador unário -
inverte o sinal do seu operando, o operador + não altera o valor em nada o seu valor.

Operador de divisão inteira. Por exemplo, 5 2 = 2. Tem a mesma precedência do
operador de divisão tradicional.
+,-
,*,/
Operadores aritméticos tradicionais de adição, subtração, multiplicação e divisão. Por
convenção, * e / têm precedência sobre + e -. Para modificar a ordem de avaliação
das operações, é necessário usar parênteses como em qualquer expressão aritmética.
MOD
ou %
Operador de módulo (isto é, resto da divisão inteira). Por exemplo, 8 MOD 3 = 2. Tem
a mesma precedência do operador de divisão tradicional.
^
Operador de potenciação. Por exemplo, 5 ^ 2 = 25. Tem a maior precedência entre os
operadores aritméticos binários (aqueles que têm dois operandos).
Operadores de Caracteres
+
Operador de concatenação de strings (isto é, cadeias de caracteres), quando usado
com dois valores (variáveis ou constantes) do tipo "caractere". Por exemplo: "Rio " +
" de Janeiro" = "Rio de Janeiro".
Operadores Relacionais
=, <,
>,
<=,
>=,
<>
Respectivamente: igual, menor que, maior que, menor ou igual a, maior ou igual a,
diferente de. São utilizados em expressões lógicas para se testar a relação entre dois
valores do mesmo tipo. Exemplos: 3 = 3 ( 3 é igual a 3?) resulta em VERDADEIRO ;
"A" > "B" ("A" está depois de "B" na ordem alfabética?) resulta em FALSO.
Importante: No VisuAlg, as comparações entre strings não diferenciam as letras maiúsculas
das minúsculas. Assim, "ABC" é igual a "abc". Valores lógicos obedecem à seguinte ordem:
FALSO < VERDADEIRO.
Operadores Lógicos
nao
Operador unário de negação. nao VERDADEIRO = FALSO, e nao FALSO =
VERDADEIRO. Tem a maior precedência entre os operadores lógicos. Equivale ao NOT
do Pascal.
ou
Operador que resulta VERDADEIRO quando um dos seus operandos lógicos for
verdadeiro. Equivale ao OR do Pascal.
e
Operador que resulta VERDADEIRO somente se seus dois operandos lógicos forem
verdadeiros. Equivale ao AND do Pascal.
xou
Operador que resulta VERDADEIRO se seus dois operandos lógicos forem diferentes, e
FALSO se forem iguais. Equivale ao XOR do Pascal.
Comandos de Saída de Dados
escreva (<lista-de-expressões>)

Escreve no dispositivo de saída padrão (isto é, na área à direita da metade inferior da tela do
VisuAlg) o conteúdo de cada uma das expressões que compõem <lista-de-expressões>.
As expressões dentro desta lista devem estar separadas por vírgulas; depois de serem
avaliadas, seus resultados são impressos na ordem indicada. É equivalente ao comando write
do Pascal.
De modo semelhante a Pascal, é possível especificar o número de espaços no qual se deseja
escrever um determinado valor. Por exemplo, o comando escreva(x:5) escreve o valor da
variável x em 5 espaços, alinhado-o à direita. Para variáveis reais, pode-se também especificar
o número de casas fracionárias que serão exibidas. Por exemplo, considerando y como uma
variável real, o comando escreva(y:6:2)escreve seu valor em 6 espaços colocando 2 casas
decimais.
escreval (<lista-de-expressões>).
Idem ao anterior, com a única diferença que pula uma linha em seguida. É equivalente ao
writeln do Pascal.
Exemplos:
algoritmo "exemplo"
var x: real
y: inteiro
a: caractere
l: logico
inicio
x <- 2.5
y <- 6
a <- "teste"
l <- VERDADEIRO
escreval ("x", x:4:1, y+3:4) // Escreve: x 2.5 9
escreval (a, "ok") // Escreve: testeok (e depois pula linha)
escreval (a, " ok") // Escreve: teste ok (e depois pula
linha)
escreval (a + " ok") // Escreve: teste ok (e depois pula
linha)
escreva (l) // Escreve: VERDADEIRO
fimalgoritmo
Note que o VisuAlg separa expressões do tipo numérico e lógico com um espaço à esquerda,
mas não as expressões do tipo caractere, para que assim possa haver a concatenação.
Quando se deseja separar expressões do tipo caractere, é necessário acrescentar espaços
nos locais adequados.
Comando de Entrada de Dados
leia (<lista-de-variáveis>)
Recebe valores digitados pelos usuário, atribuindo-os às variáveis cujos nomes estão em
<lista-de-variáveis> (é respeitada a ordem especificada nesta lista). É análogo ao
comando read do Pascal.
Veja no exemplo abaixo o resultado:
algoritmo "exemplo 1"
var x: inteiro;
inicio
leia (x)

escreva (x)
fimalgoritmo
O comando de leitura acima irá
exibir uma janela como a que se vê
ao lado, com a mensagem padrão:
"Entre com o valor de
<nome-de-variável>"
Se você clicar em Cancelar ou teclar Esc durante a leitura de dados, o programa será
imediatamente interrompido.
Comando de Desvio Condicional
se <expressão-lógica> entao
<seqüência-de-comandos>
fimse
Ao encontrar este comando, o VisuAlg analisa a <expressão-lógica>. Se o seu resultado
for VERDADEIRO, todos os comandos da <seqüência-de-comandos> (entre esta linha e a
linha com fimse) são executados. Se o resultado for FALSO, estes comandos são
desprezados e a execução do algoritmo continua a partir da primeira linha depois do fimse.
se <expressão-lógica> entao
<seqüência-de-comandos-1>
senao
fimse
Nesta outra forma do comando, se o resultado da avaliação de <expressão-lógica> for
VERDADEIRO, todos os comandos da <seqüência-de-comandos-1> (entre esta linha e a
linha com senao) são executados, e a execução continua depois a partir da primeira linha
depois do fimse. Se o resultado for FALSO, estes comandos são desprezados e o algoritmo
continua a ser executado a partir da primeira linha depois do senao, executando todos os
comandos da <seqüência-de-comandos-2> (até a linha com fimse).
Estes comandos equivalem ao if...then e if...then...else do Pascal. Note que não há
necessidade de delimitadores de bloco (como begin e end), pois as seqüências de comandos
já estão delimitadas pelas palavras-chave senao e fimse. O VisuAlg permite o aninhamento
desses comandos de desvio condicional.
Comando de Seleção Múltipla
O VisuAlg implementa (com certas variações) o comando case do Pascal. A sintaxe é a
seguinte:
escolha <expressão-de-seleção>
caso <exp11>, <exp12>, ..., <exp1n>
caso <exp21>, <exp22>, ..., <exp2n>

...
outrocaso
<seqüência-de-comandos-extra>
fimescolha
Veja o exemplo a seguir, que ilustra bem o que faz este comando:
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", "Corínthians"
escreval ("É um time paulista.")
outrocaso
escreval ("É de outro estado.")
fimescolha
fimalgoritmo
Comandos de Repetição
O VisuAlg implementa as três estruturas de repetição usuais nas linguagens de programação:
o laço contado para...ate...faca (similar ao for...to...do do Pascal), e os laços
condicionados enquanto...faca (similar ao while...do) e repita...ate (similar ao
repeat...until). A sintaxe destes comandos é explicada a seguir.
Para ... faça
Esta estrutura repete uma seqüência de comandos um determinado número de vezes.
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. Na
versão atual, 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 inicialização 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, precedida pela palavra passo, é 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. Vale a pena ter em
conta que também é possível especificar valores negativos para
<incremento>. Por outro lado, se a avaliação da expressão
<incremento > resultar em valor nulo, a execução do algoritmo será
interrompida, com a impressão de uma mensagem de erro.
fimpara
Indica o fim da seqüê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 >. Se for
menor ou igual (ou maior ou igual, quando <incremento > for
negativo), a seqüência de comandos será executada mais uma vez;
caso contrário, a execução prosseguirá a partir do primeiro comando que
esteja após o fimpara.
<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:3)
fimpara
fimalgoritmo
Importante: Se, logo no início da primeira repetição, <valor-inicial > for maior que
<valor-limite > (ou menor, quando <incremento> for negativo), o laço não será
executado nenhuma vez. O exemplo a seguir não imprime nada.
algoritmo "Numeros de 10 a 1 (não funciona)"
var j: inteiro
inicio
para j de 10 ate 1 faca
escreva (j:3)
fimpara
fimalgoritmo
Este outro exempo, no entanto, funcionará por causa do passo -1:
algoritmo "Numeros de 10 a 1 (este funciona)"
var j: inteiro
inicio
para j de 10 ate 1 passo -1 faca
escreva (j:3)
fimpara
fimalgoritmo
Enquanto ... faça
Esta estrutura repete uma seqüência de comandos enquanto uma determinada condição
(especificada através de uma expressão lógica) for satisfeita.
enquanto <expressão-lógica> faca
fimenquanto
<expressão-lógica>
Esta expressão que é avaliada antes de cada repetição do laço.
Quando seu resultado for VERDADEIRO, <seqüência-de-
comandos> é executada.
fimenquanto Indica o fim da <seqüência-de-comandos> que será repetida.

Cada vez que a execução atinge este ponto, volta-se ao início do
laço para que <expressão-lógica> seja avaliada novamente.
Se o resultado desta avaliação for VERDADEIRO, a <seqüência-
de-comandos> será executada mais uma vez; caso contrário, a
execução prosseguirá a partir do primeiro 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...faca)"
var j: inteiro
inicio
j <- 1
enquanto j <= 10 faca
escreva (j:3)
j <- j + 1
fimenquanto
fimalgoritmo
Importante: Como o laço enquanto...faca testa sua condição de parada antes de executar
sua seqüência de comandos, esta seqüência poderá ser executada zero ou mais vezes.
Repita ... até
Esta estrutrura repete uma seqüência de comandos até que uma determinada condição
(especificada através de uma expressão lógica) seja satisfeita.
repita
ate <expressão-lógica>
repita Indica o início do laço.
ate <expressão-
lógica>
Indica o fim da <seqüência-de-comandos> a serem repetidos.
Cada vez que o programa chega neste ponto, <expressão-lógica>
é avaliada: se seu resultado for FALSO, os comandos presentes entre
esta linha e a linha repita são executados; caso contrário, a
execução prosseguirá a partir do primeiro comando após esta linha.
Considerando ainda o mesmo exemplo:
algoritmo "Números de 1 a 10 (com repita)"
var j: inteiro
inicio
j <- 1
repita
escreva (j:3)
j <- j + 1
ate j > 10
fimalgoritmo
Importante: Como o laço repita...ate testa sua condição de parada depois de executar
sua seqüência de comandos, esta seqüência poderá ser executada uma ou mais vezes.
Comando Interrompa

As três estruturas de repetição acima permitem o uso do comando interrompa, que causa
uma saída imediata do laço. Embora esta técnica esteja de certa forma em desacordo com os
princípios da programação estruturada, o comando interrompa foi incluído no VisuAlg por ser
encontrado na literatura de introdução à programação e mesmo em linguagens como o Object
Pascal (Delphi/Kylix), Clipper, VB, etc. 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:3)
se x = 10 entao
interrompa
fimse
ate falso
fimalgoritmo
O VisuAlg permite ainda uma forma alternativa do comando repita...ate, com a seguinte
sintaxe:
algoritmo "Números de 1 a 10 (com interrompa) II"
var x: inteiro
inicio
x <- 0
repita
x <- x + 1
escreva (x:3)
se x = 10 entao
interrompa
fimse
fimrepita
fimalgoritmo
Com esta sintaxe alternativa, o uso do interrompa é obrigatório, pois é a única maneira de se
sair do laço repita...fimrepita; caso contrário, este laço seria executado
indeterminadamente.
A Linguagem de Programação do VisuAlg (4)
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.
Há um caso particular de subprograma que recebe o nome de função. Uma função, além de
executar uma determinada tarefa, retorna um valor para quem a chamou, que é o resultado da
sua execução. Por este motivo, a chamada de uma função aparece no corpo do programa
principal como uma expressão, e não como um comando.
Cada subprograma, além de ter acesso às variáveis do programa que o chamou (são as
variáveis globais), pode ter suas próprias variáveis (são as variáveis locais), que existem
apenas durante sua chamada.

Ao se chamar um subprograma, também é possível passar-lhe determinadas informações que
recebem o nome de parâmetros (são valores que, na linha de chamada, ficam entre os
parênteses e que estão separados por vírgulas). A quantidade dos parâmetros, sua seqüência
e respectivos tipos não podem mudar: devem estar de acordo com o que foi especificado na
sua correspondente declaração.
Para se criar subprogramas, é preciso descrevê-los após a declaração das variáveis e antes do
corpo do programa principal. O VisuAlg possibilita declaração e chamada de subprogramas nos
moldes da linguagem Pascal, ou seja, procedimentos e funções com passagem de parâmetros
por valor ou referência. Isso será explicado a seguir.
Procedimentos
Em VisuAlg, procedimento é um subprograma que não retorna nenhum valor (corresponde ao
procedure do Pascal). Sua declaração, que deve estar entre o final da declaração de variáveis
e a linha inicio do programa principal, segue a sintaxe abaixo:
procedimento <nome-de-procedimento> [(<seqüência-de-declarações-de-
parâmetros>)]
// Seção de Declarações Internas
inicio
fimprocedimento
O <nome-de-procedimento> obedece as mesmas regras de nomenclatura das variáveis.
Por outro lado, a <seqüência-de-declarações-de-parâmetros> é uma seqüência de
[var] <seqüência-de-parâmetros>: <tipo-de-dado>
separadas por ponto e vírgula. A presença (opcional) da palavra-chave var indica passagem
de parâmetros por referência; caso contrário, a passagem será por valor.
Por sua vez, <seqüência-de-parâmetros> é uma seqüência de nomes de parâmetros
(também obedecem a mesma regra de nomenclatura de variáveis) separados por vírgulas.
De modo análogo ao programa principal, a seção de declaração internas começa com a
palavra-chave var, e continua com a seguinte sintaxe:
Nos próximos exemplos, através de um subprograma soma, será calculada a soma entre os
valores 4 e –9 (ou seja, será obtido o resultado 13) que o programa principal imprimirá em
seguida. No primeiro caso, um procedimento sem parâmetros utiliza uma variável local aux
para armazenar provisoriamente o resultado deste cálculo (evidentemente, esta variável é
desnecessária, mas está aí apenas para ilustrar o exemplo), antes de atribuí-lo à variável
global res:
procedimento soma
var aux: inteiro
inicio
// n, m e res são variáveis globais
aux <- n + m
res <- aux
fimprocedimento
No programa principal deve haver os seguintes comandos:
n <- 4

m <- -9
soma
escreva(res)
A mesma tarefa poderia ser executada através de um procedimento com parâmetros, como
descrito abaixo:
procedimento soma (x,y: inteiro)
inicio
// res é variável global
res <- x + y
fimprocedimento
n <- 4
m <- -9
soma(n,m)
escreva(res)
A passagem de parâmetros do exemplo acima chama-se passagem por valor. Neste caso, o
subprograma simplesmente recebe um valor que utiliza durante sua execução. Durante essa
execução, os parâmetros passados por valor são análogos às suas variáveis locais, mas com
uma única diferença: receberam um valor inicial no momento em que o subprograma foi
chamado.
Funções
Em VisuAlg, função é um subprograma que retorna um valor (corresponde ao function do
Pascal). De modo análogo aos procedimentos, sua declaração deve estar entre o final da
declaração de variáveis e a linha inicio do programa principal, e segue a sintaxe abaixo:
funcao <nome-de-função> [(<seqüência-de-declarações-de-parâmetros>)]:
<tipo-de-dado>
// Seção de Declarações Internas
inicio
fimfuncao
O <nome-de-função> obedece as mesmas regras de nomenclatura das variáveis. Por outro
lado, a <seqüência-de-declarações-de-parâmetros> é uma seqüência de
[var] <seqüência-de-parâmetros>: <tipo-de-dado>
separadas por ponto e vírgula. A presença (opcional) da palavra-chave var indica passagem
de parâmetros por referência; caso contrário, a passagem será por valor.
Por sua vez, <seqüência-de-parâmetros> é uma seqüência de nomes de parâmetros
(também obedecem a mesma regra de nomenclatura de variáveis) separados por vírgulas.
O valor retornado pela função será do tipo especificado na sua declaração (logo após os dois
pontos). Em alguma parte da função (de modo geral, no seu final), este valor deve ser
retornado através do comando retorne.
De modo análogo ao programa principal, a seção de declaração internas começa com a
palavra-chave var, e continua com a seguinte sintaxe:

Voltando ao exemplo anterior, no qual calculamos e imprimimos a soma entre os valores 4 e –
9, vamos mostrar como isso poderia ser feito através de uma função sem parâmetros. Ela
também utiliza uma variável local aux para armazenar provisoriamente o resultado deste
cálculo, antes de atribuí-lo à variável global res:
funcao soma: inteiro
var aux: inteiro
inicio
// n, m e res são variáveis globais
aux <- n + m
retorne aux
fimfuncao
n <- 4
m <- -9
res <- soma
escreva(res)
Se realizássemos essa mesma tarefa com uma função com parâmetros passados por valor,
poderia ser do seguinte modo:
funcao soma (x,y: inteiro): inteiro
inicio
retorne x + y
fimfuncao
n <- 4
m <- -9
res <- soma(n,m)
escreva(res)
Passagem de Parâmetros por Referência
Há ainda uma outra forma de passagem de parâmetros para subprogramas: é a passagem por
referência. Neste caso, o subprograma não recebe apenas um valor, mas sim o endereço de
uma variável global. Portanto, qualquer modificação que for realizada no conteúdo deste
parâmetro afetará também a variável global que está associada a ele. Durante a execução do
subprograma, os parâmetros passados por referência são análogos às variáveis globais. No
VisuAlg, de forma análoga a Pascal, essa passagem é feita através da palavra var na
declaração do parâmetro.
Voltando ao exemplo da soma, o procedimento abaixo realiza a mesma tarefa utilizando
passagem de parâmetros por referência:
procedimento soma (x,y: inteiro; var result: inteiro)
inicio
result <- x + y
fimprocedimento
n <- 4
m <- -9
soma(n,m,res)
escreva(res)
Recursão e Aninhamento

A atual versão do VisuAlg permite recursão, isto é, a possibilidade de que um subprograma
possa chamar a si mesmo. A função do exemplo abaixo calcula recursivamente o fatorial do
número inteiro que recebe como parâmetro:
funcao fatorial (v: inteiro): inteiro
inicio
se v <= 2 entao
retorne v
senao
retorne v * fatorial(v-1)
fimse
fimfuncao
Em Pascal, é permitido o aninhamento de subprogramas, isto é, cada subprograma também
pode ter seus próprios subprogramas. No entanto, esta característica dificulta a elaboração dos
compiladores e, na prática, não é muito importante. Por este motivo, ela não é permitida na
maioria das linguagens de programação (como C, por exemplo), e o VisuAlg não a implementa.

Sumário
Objetivos........................................................................................................................... 2
Apresentação do VisuaAlg pelo prof. Cláudio Morgado de Souza.................................. 2
Instalação e Requerimentos de Hardware ................................................................ 2
Conheça o VisuAlg................................................................................................... 2
A Tela Principal do VisuAlg ............................................................................................ 3
A Barra de Tarefas.................................................................................................... 3
Quadro de Variáveis................................................................................................. 5
A Barra de Status...................................................................................................... 5
Menu do VisuAlg ............................................................................................................. 7
A Linguagem de Programação do VisuAlg (1)................................................................ 9
Introdução..................................................................................................................... 9
Formato Básico do Pseudocódigo e Inclusão de Comentários..................................... 9
Tipos de Dados........................................................................................................... 10
Nomes de Variáveis e sua Declaração........................................................................ 10
Constantes e Comando de Atribuição ........................................................................ 11
Referências da Linguagem de Programação do VisuAlg............................................... 12
Auto-digitação e Sugestão de Digitação......................................................................... 13
Auto-digitação ............................................................................................................ 13
Sugestão de Digitação ............................................................................................ 15
As Funções do Visualg Versão 2.0................................................................................. 16
Funções numéricas, algébricas e trigonométricas. ..................................................... 16
Funções para manipulação de cadeias de caracteres (strings).................................... 17
Curso de Algoritmos....................................................................................................... 19
Lição 1 - Introdução ................................................................................................... 19
Regras para a formação de nomes de variáveis...................................................... 20
Lição 2 - Comandos Básicos ...................................................................................... 21
Declarando Variáveis ............................................................................................. 21
Colocando Valores nas Variáveis........................................................................... 21
Exibindo o Valor de uma Variável......................................................................... 22
Obtendo Dados para o Programa............................................................................ 22
Lição 3 - Expressões Aritméticas............................................................................... 23
Lição 4 - Construindo os Primeiros Algoritmos......................................................... 25
Problema 1 - Cálculo de Média Aritmética............................................................ 25
Lição 5 - Mais Algoritmos Básicos............................................................................ 27
Problema 2 - Cálculo Simples de Velocidade Média............................................. 27
Problema 3 - Cálculo de Velocidade Média (mais complexo)........................ 27
RESPOSTAS – Lição 4 e 5........................................................................................ 29
Lição 6 - Comentários e Mais Algoritmos ................................................................. 33
Exercício 5 ............................................................................................................. 34
Lição 7 - Colocando mais Inteligência nos Programas .............................................. 35
Exercício 7 ............................................................................................................. 36
Exercício 8 ............................................................................................................. 37
Lição 8 - Ensinando o Computador a Decidir............................................................ 38

RESPOSTA LIÇÃO DA LIÇÃO 5 A LIÇÃO 8........................................................ 40
Resposta do Exercício 5....................................................................................... 40
Como Funciona o Algoritmo do Problema 4..................................................... 42
Lição 9 - Mais Algoritmos com Decisões .................................................................. 45
Exercício 9 ............................................................................................................. 45
Exercício 10........................................................................................................... 46
Exercício 11........................................................................................................... 46
Exercício 12........................................................................................................... 46
RESPOSTAS ATÉ O EXERCÍCIO 12...................................................................... 47
Resposta do Exercício 10..................................................................................... 47
Lição 10 - Refinando Nossas Decisões ...................................................................... 50
Lição 11 - Trabalhando com Tabelas (1).................................................................... 52
Lição 12 - Trabalhando com Tabelas (2).................................................................... 54
Exercício 13........................................................................................................... 55
Exercício 14........................................................................................................... 55
A Linguagem de Programação do VisuAlg (5).............................................................. 57

Lógica de programação com visu alg

Mais conteúdo relacionado

Destaque

Semelhante a Lógica de programação com visu alg

Lógica de programação com visu alg