Apostila - Algoritmos de Programação

Esta é uma pré-visualização de arquivo. Entre para ver o arquivo original

1 
 
 
 
 
Apostila Básica 
de 
Algoritmos e 
Programação 
 
 
 
 
 
 
 
 
 2 
FUNDAMENTOS DE ALGORITMOS E PROGRAMAÇÃO 
ÍNDICE 
 
Lição 1 - Introdução ....................................................................................... 3 
Lição 2 - Comandos e Expressões ................................................................... 5 
2.1. Declarando Variáveis .............................................................................................. 5 
2.2. Colocando Valores nas Variáveis .............................................................................. 6 
2.3. Exibindo o Valor de uma Variável ............................................................................. 6 
2.4. Obtendo Dados para o Programa ............................................................................. 7 
2.5. Expressões Aritméticas ........................................................................................... 7 
Lição 3 – Algoritmos Básicos – Problemas e Exercícios ...................................... 9 
Problema 3.1 - Cálculo de Média Aritmética ............................................................................ 9 
Problema 3.2 - Cálculo Simples de Velocidade Média ..............................................................10 
Problema 3.3 - Cálculo de Velocidade Média (mais complexo)..................................................11 
Exercício 3 ..........................................................................................................................11 
Exercício 4 ..........................................................................................................................11 
Uso de Comentários .............................................................................................................11 
Exercício 5 ..........................................................................................................................13 
Lição 4 – Algoritmos com Decisões ....................................................................13 
4.1- Análise de Expressões ....................................................................................13 
Exercício 6 ..........................................................................................................................14 
Exercício 7 ..........................................................................................................................15 
Exercício 8 ..........................................................................................................................15 
4.2- Ensinando o Computador a Decidir ................................................................15 
Exercício 9 ..........................................................................................................................19 
Exercício 10.........................................................................................................................19 
Exercício 11.........................................................................................................................19 
Exercício 12.........................................................................................................................20 
4.3- Decisões com maior complexidade ................................................................20 
4.4- Comando de Seleção Múltipla ........................................................................21 
Lição 5 - Trabalhando com Tabelas ...................................................................22 
Exercício 13.........................................................................................................................25 
Exercício 14.........................................................................................................................25 
Lição 6 - Estruturas de Repetição ......................................................................26 
6.1- Para ... faça ( laço contado ) ........................................................................................26 
6.2- Enquanto ... faça ( laço condicionado 1 ) ......................................................................27 
6.3- Repita ... até ( laço condicionado 2 ) ............................................................................28 
6.4- Comando Interrompa ....................................................................................................28 
Lição 7 - SubAlgoritmos .....................................................................................29 
7.1- Procedimentos ......................................................................................................29 
7.2- Funções ................................................................................................................30 
7.3- Passagem de Parâmetros por Referência .................................................................32 
7.4- Recursão e Aninhamento .......................................................................................32 
 3 
Algoritmos de Programação 
 
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. 
 
As variáveis que armazenam os dados numéricos podem ser de dois tipos: 
 
- tipo real : permite armazenar todos os números, inclusive com casas decimais. 
 
- tipo inteiro : permite armazenar apenas os números sem casas decimais. 
 
Exemplos: 
1.23 ; -3 ; 45657 ; 0.66 ; -897.06 ; etc. 
 4 
 
Dado Numérico Tipo(s) de variável(is) que pode conter o dado 
1.23 Real 
-3 Real ou Inteiro 
45657 Real ou Inteiro 
0.66 Real 
897.08 Real 
-15.7 Real 
0 Real ou Inteiro 
 
 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: "Ipatinga" "Computador" "A" "?" "Fora!" "1234" 
Nos nossos exemplos daremos a todas as variáveis que armazenam valores literais o tipo 
caractere. 
 Dados Lógicos - podem assumir apenas dois valores: Falso ou Verdadeiro. Também são 
chamados de dados booleanos. 
Nos nossos exemplos daremos a todas as variáveis que armazenam valores lógicos o tipo logico 
(deve ser 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 
real, inteiro, caractere ou lógico. Quando se define uma variável para uso no programa (os 
 5 
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 probl..ema 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 e Expressões 
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". 
2.1. Declarando Variáveis 
Para declarar as variáveis, colocamos, no início do algoritmo, a palavra chave var seguida de um conjunto 
de declarações no formato <nome : tipo> , tal qual o exemplo a seguir. 
var Salario : Real 
 Nome : Caractere 
 AlunoAusente : Logico 
Se tivermos mais de uma variável do mesmo tipo, podemos colocar todas, separadas por vírgulas, na 
mesma declaração: 
 var Peso, Altura, Idade : Real 
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 caractere ou mensagens para o usuário, no entanto, serão escritos corretamente. 
O software VISUALG já sugere, ao iniciarmos um novo algoritmo, uma estrutura inicial para que o usuário 
escreva os demais comandos e declarações de variáveis. Esta estrutura já contém, grifados, os comandos 
que são inevitáveis em qualquer algoritmo: algoritmo, var, inicio e fimalgoritmo . Veja, 
a seguir: 
algoritmo "semnome" 
// Função : 
// Autor : 
// Data : 
// Seção de Declarações 
var 
 
inicio 
// Seção de Comandos 
fimalgoritmo 
 6 
2.2. 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; no Visualg a junção dos 
caracteres “ < ” e “ - “). 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. 
2.3. 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. No VISUALG, o 
conjunto de expressões deve estar entre parênteses. Veja os exemplos a seguir: 
Comandos Resultado 
 (o que aparecerá na tela do computador) 
Escreva ("Alô, mundo!" ) Alô, mundo! 
Escreva (20) 20 
 
var Nome : Caractere 
 Idade : Real 
Nome <- "José" 
Idade <- 40 
Escreva (Nome ) José 
Escreva ("O meu nome é ", Nome ) O meu nome é José 
Escreva ("Tenho ",Idade," anos") Tenho 40 anos 
 7 
2.4. Pedindo ao Usuário que digite 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 (<Nomes_De_Variáveis>) 
Substitua <Nomes_De_Variáveis> por um ou mais nomes de variável(separados por vírgula) onde serão 
armazenados os dados digitados. Veja este exemplo: 
 Leia (Nome) 
 Leia (Peso) 
 Leia (NomePai, NomeMae) 
Suponha que o usuário digitou "Paulo" e teclou ENTER, digitou 80 e teclou ENTER novamente, digitou 
"José" e teclou ENTER novamente, digitou "Maria" e teclou ENTER novamente. 
Nesta situação, o valor "Paulo" foi atribuído variável Nome, o valor 80 à variável Peso, o valor "José" à 
variável NomePai e o valor "Maria" à variável NomeMae. 
2.5. 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 linguagens 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: 
 8 
( 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. 
 
( 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 / 2 So há * e / - , então opera-se da esquerda para a 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) Var A : Real 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) Var A, B : Real 
 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) Var A : Real 
 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) Var 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) 
 9 
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 3 – Algoritmos Básicos – Problemas e Exercícios 
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 3.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 
Var A,B,Media : Real 
 10 
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. 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... 
 
Exercício 2 
Faça um programa que leia três valores numéricos, e calcule e exiba a sua média aritmética. 
 
Problema 3.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 
caractere (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 
Var Nome : Caractere 
 Distancia,Tempo,VelMedia : Real 
 11 
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 ) 
VelMedia <- Distancia/Tempo 
Escreva ("A velocidade média de ",Nome," foi ", VelMédia ) 
 
Problema 3.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órmula 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. 
Var Nome : Caractere 
 DistTrecho1, DistTrecho2, Tempo,VelMedia : Real 
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 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? 
 
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)... 
 
 
Uso de Comentários 
 12 
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 caracterees 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 caracterees apareça indicando o 
fim do comentário. Por curiosidade, mostramos abaixo alguns exemplos (os caracterees que delimitam os 
comentários estarão em negrito): 
 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 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. 
 
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 
Var Nome : Caractere 
 Distancia,Tempo,VelMedia : Real 
// Apresentação do programa 
Escreva "Programa que calcula a velocidade média de um piloto." 
// Obtenção dos dados 
Escreva "Digite o nome do piloto : " 
Leia Nome 
 13 
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. 
 
Lição 4 – Algoritmos com Decisões 
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. 
4.1- Análise de Expressões Lógicas 
Na Lição 1, quando falamos de tipos de dados, nos referimos ao tipo Logico, que poderia ter apenas um 
de dois valores:
Falso ou Verdadeiro. Estes valores se originam da análise de uma expressão lógica 
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 
 14 
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: 
 15 
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 
 
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 ) 
 
 
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 
 
4.2- 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. 
 16 
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.1 - 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. 
Var Dinheiro: Real 
Escreva "Serviço Informatizado de Sugestões" 
Escreva "Quanto dinheiro você tem sobrando?" 
Leia Dinheiro 
Se Dinheiro >= 10 entao 
 17 
 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 
Se Dinheiro >= 10 entao 
 Escreva "Vá ao cinema hoje à noite." 
senao 
 Escreva "Fique em casa vendo TV." 
Escreva "Obrigado e volte sempre." 
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 endentaçã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 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 (no software Visualg iremos juntar as duas palavras, 
escrevendo sempre: “fimse”). 
Quer saber como este algoritmo funciona? Veja a seguir. 
Como Funciona o Algoritmo do Problema 4.1 
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. 
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." 
Logo depois o segundo comando Escreva vai colocar a outra mensagem na tela (para orientar o usuário). 
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." 
Depois, o comando Leia vai esperar que o usuário forneça um valor e tecle Enter. 
 18 
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." 
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. 
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." 
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 
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." 
Agora o programa 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. 
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." 
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. 
 
Problema 4.2 - Posso Entrar na Boate? 
Enunciado 
 19 
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. 
Var AnoNascimento, Idade: Real 
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. 
Var AnoNascimento: Real 
Escreva "Checagem de Idade da Boate Noites Cariocas" 
Escreva "Em que ano você nasceu?" 
Leia AnoNascimento 
Se (2002 - AnoNascimento) >= 18 entao 
 Escreva "Você pode entrar na boate." 
senao 
 Escreva "Infelizmente, você não pode entrar." 
fimse 
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. 
Var AnoAtual, AnoNascimento: Real 
Escreva "Checagem de Idade da Boate Noites Cariocas" 
Escreva "Qual é o ano atual?" 
Leia AnoAtual 
Escreva "Em que ano você nasceu?" 
Leia AnoNascimento 
Se (AnoAtual - AnoNascimento) >= 18 entao 
 Escreva "Você pode entrar na boate." 
senao 
 Escreva "Infelizmente, você não pode entrar." 
fimse 
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á escrever 
"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." 
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. 
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 
 20 
distâncias que cada carro percorreu e o tempo que cada um levou, e indique o carro que teve maior 
velocidade média. 
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). 
 
4.3- Decisões com maior complexidade 
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 4.3 - 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 
Var Distancia1, Distancia2, Tempo1, Tempo2, VelMed1, VelMed2 : Real 
 
// Leitura dos dados 
Escreva "Distância percorrida pelo Carro 1:" 
Leia Distancia1 
Escreva "Tempo gasto pelo Carro 1:" 
Leia Tempo1 
 
Escreva "Distância percorrida pelo Carro 2:" 
Leia Distancia2 
Escreva "Tempo gasto pelo Carro 2:" 
Leia Tempo2 
 
// Cálculo e exibição
das velocidades médias 
VelMed1 <- Distancia1 / Tempo1 
VelMed2 <- Distancia2 / Tempo2 
 
Escreva "Velocidade média do Carro 1:", VelMed1 
Escreva "Velocidade média do Carro 2:", VelMed2 
 
// Resultado (Note que há dois testes) 
Se VelMed1 > VelMed2 entao 
 Escreva "O Carro 1 teve maior velocidade média." 
Senao 
 // Eliminamos a primeira possibilidade (de o carro 1 ser mais rápido) 
 // Agora vamos ver entre as duas restantes 
 Se VelMed2 > VelMed1 entao 
 Escreva "O Carro 2 teve maior velocidade média." 
 Senao 
 // Eliminamos também a segunda possibilidade (de o carro 2 ser mais 
rápido) 
 // Então, só resta a terceira (os dois carros tiveram a mesma 
velocidade média) 
 21 
 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 endentação não é obrigatória, mas note como ela 
facilita o entendimento do algoritmo. 
Problema 4.4 - 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. 
Var Nota1, Nota2, Media : Real 
 
// Leitura dos dados 
Escreva "Digite a Nota 1:" 
Leia Nota1 
Escreva "Digite a Nota 2:" 
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 
 Escreva "Aluno aprovado" 
Senao 
 // Ele pode ter sido reprovado ou ficado em final 
 // Primeiro, eliminamos a possibilidade de ele ter sido reprovado direto 
 Se Media < 4 entao 
 Escreva "Aluno reprovado" 
 Senao 
 // Então, ficou em final... 
 Escreva "Você está na final, e precisa de ", 10 - Media 
 Fimse 
Fimse 
4.4- Comando de Seleção Múltipla 
É possível definir uma expressão de seleção e fazer a escolha entre a execução de diversas sequências de 
comandos, baseado em várias opções de valor daquela expressão. Veja no exemplo a seguir: 
algoritmo "Futebol" 
var clube: caractere 
inicio 
escreva ("Entre com o nome de um clube de futebol: ") 
leia (clube) 
escolha clube 
caso "Flamengo", "Fluminense", "Vasco", "Botafogo" 
 escreva ("É um clube carioca.") 
caso "Flamengo", "Fluminense", "Vasco", "Botafogo" 
 22 
 escreva ("É um clube carioca.") 
caso "Atlético", "Cruzeiro", "Ipatinga" 
 escreva ("É um clube mineiro.") 
outrocaso 
 escreva ("É um clube de outro estado.") 
fimescolha 
fimalgoritmo 
Generalizando, a estrutura do comando de seleção múltipla, fica da seguinte forma : 
escolha <expressão-de-seleção> 
caso <valor11>, <valor12>, ..., < valor1n> 
 <seqüência-de-comandos-1> 
caso < valor21>, < valor22>, ..., < valor2n> 
 <seqüência-de-comandos-2> 
... 
outrocaso 
 <seqüência-de-comandos-extra> 
fimescolha 
 
Lição 5 - Trabalhando com Tabelas 
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 5.1 - 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. 
Var Media : Real 
Escreva "Qual a média do aluno?" 
Leia Media 
 
Se (Media >=0) e (Media<=3.9) entao 
 Escreva "Conceito : Fraco" 
Senao 
 Se (Media >=4) e (Media<=6.9) entao 
 23 
 Escreva "Conceito : Regular" 
 Senao 
 Se (Media >=7) e (Media<=8.9) entao 
 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. 
Var Media : Real 
Escreva "Qual a média do aluno?" 
Leia Media 
 
Se Media <= 3.9 entao 
 Escreva "Conceito : Fraco" 
Senao 
 Se Media <= 6.9 entao 
 Escreva "Conceito : Regular" 
 Senao 
 Se Media <= 8.9 entao 
 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. 
Var Media : Real 
 Conceito : Caractere 
Escreva "Qual a média do aluno?" 
Leia Media 
 
Se Media <= 3.9 entao 
 Conceito <- "Fraco" 
Senao 
 Se Media <= 6.9 entao 
 Conceito <- "Regular" 
 Senao 
 Se Media <= 8.9 entao 
 Conceito <- "Bom" 
 24 
 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. 
 
Problema 5.2 - 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. 
Var Fixo, Vendas, Faltas, Percentual, Comissao, Desconto, Salario : Real 
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 
 Se Vendas <= 3000 entao 
 Percentual <- 3 
 Senao 
 Se Vendas <= 6000 entao 
 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) 
 25 
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. 
Var Fixo, Vendas, Faltas, Percentual : Real 
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 
 Se Vendas <= 3000 entao 
 Percentual <- 3 
 Senao 
 Se Vendas <= 6000 entao 
 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). 
Exercício 14 
 26 
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. 
 
Lição 6 - Estruturas de Repetição 
Veremos 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. 
 
6.1- Para ... faça ( laço contado ) 
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 
 <seqüência-de-comandos> 
fimpara 
<variável > 
É a variável contadora que controla o número de repetições do laço; deve ser 
necessariamente uma variável do tipo inteiro, como todas as expressões deste 
comando. 
<valor-inicial> É uma expressão que especifica o valor de 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) 
 27 
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 exemplo, 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 
 
 
6.2- Enquanto ... faça ( laço condicionado 1 ) 
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 
 <seqüência-de-comandos> 
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 
 28 
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. 
 
 
 
6.3- Repita ... até ( laço condicionado 2 ) 
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 
 <seqüência-de-comandos> 
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. 
6.4- 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 
 29 
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. 
 
Lição 7 - SubAlgoritmos 
Subalgoritmo ou Subprograma é um bloco de instruções que auxilia o programa principal através da 
realização de uma determinada tarefa específica ( ou subtarefa). Também costuma receber os nomes de 
sub-rotina, método ou módulo. Os subalgoritmos 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, subprogrmas dos tipos procedimentos e funções com passagem de parâmetros 
por valor ou referência. Isso será explicado a seguir. 
7.1- 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 
// Seção de Comandos 
fimprocedimento 
 30 
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: 
<lista-de-variáveis> : <tipo-de-dado> 
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 
No programa principal deve haver os seguintes comandos: 
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. 
7.2- Funções 
 31 
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 
// Seção de Comandos 
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: 
<lista-de-variáveis> : <tipo-de-dado> 
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 
No programa principal deve haver os seguintes comandos: 
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 
 32 
No programa principal deve haver os seguintes comandos: 
n <- 4 
m <- -9 
res <- soma(n,m) 
escreva(res) 
7.3- 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 
No programa principal deve haver os seguintes comandos: 
n <- 4 
m <- -9 
soma(n,m,res) 
escreva(res) 
7.4- Recursão e Aninhamento 
Existe 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. 
_______________________