Algoritmos

Capítulo 1 – Introdução e Conceitos Fundamentais
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; desligue 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 .
Tipos de Dados
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 – representam 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. Usaremos dois subtipos: os valores inteiros, aqueles que por natureza não têm
parte fracionária (exemplos: número de alunos em uma turma, estoque de latas de Coca-Cola em um mercado,
etc.) , e os reais, que podem tê-la (exemplo: o peso de uma pessoa, o preço de uma mercadoria, etc.).
Exemplos: 7, 1.23, -3, 45657, 0.66, -1897.06, etc.
• Dados Caracter ou Literais – representam letras, nomes, sinais de pontuação, etc. Outros nome usado para este tipo
de dados é cadeia ou string (por causa do inglês “string of characters”, isto é, uma cadeia de caracteres). Nos
algoritmos são representados entre aspas.
Exemplos: “Rio de Janeiro”, “Computador”, “A”, “?”, “Fora!”
• Dados Lógicos – representam 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” aos programas de computador, mas neste momento podemos ficar só com esta pequena explicação.
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, ou armazenados em variáveis. Vamos fazer uma analogia com a álgebra da escola para
que você entenda melhor. Na equação y = x + 2, por exemplo, o valor 2 é uma constante (2 é sempre 2), enquanto que x e
y são variáveis (podemos achar muitos valores de x e y que satisfazem a equação). Então, x e y são como que nomes que
damos a um objeto que contém um determinado valor em um determinado momento, valor este que pode mudar – daí o
nome variável. Vamos agora estender este conceito ao mundo dos computadores.
Variáveis
Variáveis são locais de armazenamento temporário para os dados. Como você deve saber, os programas são executados na
memória de um computador, e tanto o código (as instruções) do programa quanto os dados que ele manipula ali residem.
Cada valor que um programa usa está armazenado em um local determinado da memória do computador, onde pode ser
examinado ou modificado, usado em cálculos, etc.
Embora seja possível se criar um algoritmo que não use variáveis, ele não seria capaz de fazer muita coisa… São rascunhos
que o programa (representado pelo algoritmo) usa para guardar os dados que são introduzidos pelo usuário (via digitação,
por exemplo), realizar seus cálculos e mostrar os resultados. É 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.
• Tipo: indica o tipo de dado que ela armazena. Assim, uma variável pode ser do tipo numérico, caracter (o mesmo
que 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”).
As Partes de um Algoritmo
Um algoritmo se compõe de duas partes básicas: a área de declaração das variáveis, onde informamos ao computador o
nome e tipo das variáveis que usaremos, e a parte de comandos, onde o “código” que fará o programa funcionar será
escrito.
Quase todas as linguagens de programação exigem a declaração das variáveis de um programa. Em algumas (bem poucas)
isto é facultativo, mas é sempre uma boa técnica declarar variáveis, por vários motivos. Portanto, para treinar as técnicas
corretas, vamos assumir que a declaração de variáveis é sempre “obrigatória”, mesmo que o nosso algoritmo não saia
nunca do papel. A seguir vemos um exemplo de “esqueleto” de um algoritmo:
algoritmo “exemplo”
var
inicio
fimalgoritmo
Neste exemplo vemos o uso de quatro palavras-chave que indicam as partes de um algoritmo:
• a primeira é a palavra algoritmo, que marca o início do algoritmo. Note que ela vem seguida do nome do
algoritmo, entre aspas. Este nome geralmente descreve o que algoritmo faz, de maneira bem sucinta;
• logo depois vemos a palavra-chave var, que indica o início da seção de declaração de variáveis. Esta palavra só
aparece uma vez no algoritmo;
• depois vem a palavra-chave inicio (note que está sem o acento…), que marca o começo da seção de comandos do
algoritmo;
• por último, temos a palavra-chave fimalgoritmo (assim mesmo, tudo junto), que marca naturalmente o fim do
código do algoritmo.
Conforme vimos anteriormente, toda variável tem um nome, e fica ao critério do programador dar os nomes que quiser às
variáveis de seus programas. Existem, porém, regras (e cada linguagem de programação tem as suas) para a sua formação.
Nós também as teremos: neste curso, os nomes de variáveis deverão começar com um sublinhado (“_”) ou 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. Também não usaremos nenhum tipo de acentuação, pontuação, til ou cedilha nos nomes.
Exemplos:
Nomes válidos: Valor1, Valor2, Nota_do_Aluno, Salario, _SOMA
Nomes inválidos: 1Valor, 2Valor, Salário, Nota.do.Aluno, Media-Aritmetica, Variação,
TOTAL GERAL, RESPOSTA?
Para terminar, lembramos que as palavras-chave não podem ser usadas como nome de variáveis. Assim, não é possível
haver uma variável chamada inicio, ou algoritmo.
Declarando Variáveis
Para declarar uma variável, colocamos, no início do algoritmo, seu nome, seguido por dois pontos, e seu tipo:
Salario : real
Nome : caracter
Se tivermos mais de uma variável do mesmo tipo, podemos colocar todas, separadas por vírgulas, na mesma declaração:
Peso, Altura: real
Idade : inteiro
Voltando ao exemplo visto acima, ele ficaria assim com a declaração destas variáveis:
algoritmo “exemplo2”
var
Nome : caracter
Peso, Altura : real
Idade : inteiro
Estrangeiro : logico
inicio
fimalgoritmo
Nota: Alguns autores usam o tipo de dados literal como um sinônimo para caracter. Note também que não
utilizamos acentos nos nomes dos tipos das variáveis, e que estas cinco palavras (inteiro, real, caracter,
literal e logico) são palavras-chave.
Atribuindo Valores a Variáveis
Quando declaramos uma variável, criamos uma área de armazenamento para os dados, mas ela ainda está sem valor. Para
que a variável seja útil, deve ter valores colocados por nós. A isto se chama “atribuir valores”. A atribuição de valores é
feita pelo operador de atribuição “<-” (uma seta apontando para a esquerda). Por exemplo:
Peso <- 78
Este comando atribui à variável Peso o valor 78. Diz-se no linguajar dos programadores que “Peso recebe 78”.
Nome <- “João da Silva”
Este comando atribui à variável Nome o valor “João da Silva”, isto é, “Nome recebe ‘João da Silva’”.
É importante lembrar que só se podem atribuir a uma variável valores do mesmo tipo daquela variável. Nos exemplos
acima, Salario é do tipo real (um tipo numérico); então, o seguinte comando seria inválido:
Salario <- “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 a execução de um algoritmo ou programa.
As atribuições de valores são comandos, e por isso devem ficar depois da palavra-chave inicio.
algoritmo “exemplo3”
var
Salario : real
Nome : caracter
Peso, Altura : real
Idade : inteiro
Estrangeiro : logico
inicio
Peso <- 78
Nome <- “Joao da Silva”
fimalgoritmo
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… ) ou
escreval(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, variáveis ou mesmo expressões, que serão calculadas e terão seu valor final exibido. Caso a expressão seja uma
variável, será exibido o seu valor. Veja os exemplos a seguir (suponha que a variável Nome é do tipo literal ou caracter e
Idade é do tipo inteiro):
Comandos Resultado
(o que aparecerá na tela do computador)
escreva(“Alô, mundo!”) Alô, mundo!
escreva(20) 20
Nome <- “José”
Idade <- 40
escreva(Nome) José
escreva(“O meu nome é “, Nome) O meu nome é José
escreva(“Tenho “,Idade,” anos”) Tenho 40 anos
escreva(“Em 3 anos terei “,Idade+3,” anos”) Em 3 anos terei 43 anos
E qual a diferença entre escreva e escreval ? Bem, imagine a tela do computador como sendo composta de várias
linhas. Depois que o programa escreve algo na tela ele pode “pular” para a próxima linha, de modo que a próxima coisa a
ser escrita seja colocada no início desta nova linha, ou continuar na mesma, para que os próximos dados sejam colocados
na frente do que já está na tela. Esta é a diferença entre escreva e escreval. Com o comando escreva, o
computador não “pula de linha” ao terminar de colocar os dados na tela, e com escreval ele “pula”. Veja os exemplos a
seguir, considerando os mesmos valores para as variáveis Nome e Idade.:
Comandos Resultado
(o que aparecerá na tela do computador)
escreva(“O meu nome é “)
escreval(Nome)
escreva(“Tenho “,Idade)
O meu nome é José
Tenho 40 anos
Em 3 anos terei 43 anos
escreval(” anos”)
escreva(“Em 3 anos terei “)
escreva(Idade+3)
escreva(” 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(Variável1, Variável2, etc… )
Variável1, Variável2, etc. são as variáveis onde serão armazenados os dados digitados, na ordem em que forem
fornecidos. Veja este exemplo:
leia(Nome, 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.
Dica: não é uma boa idéia usar um comando leia com duas variáveis de uma vez, já que isto pode confundir o usuário.
Em seus programas sempre use um comando escreva, com a instrução sobre o que deve ser digitado, e um leia logo
depois. Use o comando escreva e não escreval para que o cursor fique parado exatamente no fim do texto de instrução,
esperando pelos dados do usuário. Veja este exemplo, e note como é bem mais fácil para o usuário entender o que se pede:
escreva(“Digite seu nome: “)
leia(Nome)
escreva(“Digite seu peso: “)
leia(Peso)
Capítulo 2 – 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
+ Adição 3 + 2 = 5
– Subtração 10 – 5 = 5
* Multiplicação 3 * 7 = 21
/ Divisão real 25 / 2 = 12,5
DIV Divisão inteira (despreza a parte fracionária) 25 DIV 2 = 12
MOD Resto da divisão inteira (ou módulo) 26 MOD 7 = 5 ( 26 DIV 7 = 3, resto 5)
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…
Da mesma maneira que estudamos na escola, algumas operações têm prioridade sobre as outras. 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 / 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 trechos de algoritmos a seguir:
Comandos Comentários
1) var A : inteiro 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 : inteiro Declaração das variáveis
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 : inteiro Declaração da variável
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 : inteiro Declaração da variável
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.
Funções Pré-Definidas
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 se dá 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.
Vamos agora examinar as funções algébricas e trigonométricas pré-definidas que usaremos em nossos algoritmos.
Abs( expressão) – Retorna o valor absoluto de uma expressão do tipo inteiro ou real. Equivale a | expressão |.
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 expressão, base e expoente, são os parametros, 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 das funções. Na medida em que forem necessárias para a resolução de
algum algoritmo, elas serão usadas com explicações mais detalhadas.
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
Exercícios
1. Calcule as seguintes expressões, tendo em vista as variáveis declaradas, seus tipo e valores, e diga o que o programa
imprimirá na tela :
algoritmo “exercicio1a”
var
a, b, c, d : real
inicio
a <- 5
b <- a * 2
c <- 8
d <- 28
escreval( 30 / ( a + b ) )
escreval( ( a + b ) / ( c – 5 ) + ( d / ( c – 1 ) ) )
escreval( a * c * 7 / d – 8 )
escreval( a * c * 7 / ( d – 8 ) )
escreval( log(100) * raizq(16) )
fimalgoritmo
algoritmo “exercicio1b”
var
a, b, c, d : inteiro
inicio
a <- 4
b <- a * 2
c <- 9
d <- 18
escreval( 37 div a + c )
escreval( 37 div ( a + c ) )
escreval( ( a + 2 * b ) div ( c mod 5 ) + ( d div ( c – 1 ) ) )
escreval( a * c * d div 6 mod 8 )
escreval( a * c * 7 div ( d – 8 ) )
fimalgoritmo
Capítulo 3 – Construindo os Primeiros Algoritmos
Basicamente a construção de um algoritmo se resume às seguintes etapas:
a) Análise e entendimento do problema;
b) 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;
c) Obtenção destes dados; alguns vêm do “exterior” do programa digitados pelo usuário, e outros são calculados no
próprio algoritmo;
d) Processamento em si;
e) 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.
Análise
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.
Definição dos dados
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.
Obtenção dos dados
A obtenção dos dados neste programa é simples e direta. Basta pedir ao usuário que digite os valores.
Processamento
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 Media.
Exibição
Basta exibir o conteúdo da variável Media.
Solução
Algoritmo “Media”
Var A,B,Media : real
Inicio
escreval(“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 )
fimalgoritmo
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.
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.
Análise e definição dos dados
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 do tipo real (distância e tempo), e um
caracter ou literal (o nome do piloto).
Obtenção dos dados
A obtenção dos dados neste programa é simples e direta. Basta pedir ao usuário que digite os valores.
Processamento e exibição
Usaremos as mesmas técnicas utilizadas no problema 1.
Solução
algoritmo “Media2”
var nome : caracter
distancia,tempo,velmedia : real
inicio
escreval(“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(distancia )
escreva(“Digite o tempo gasto para percorrê-la (em horas) : ” )
leia(tempo )
velmedia <- distancia/tempo
escreva(“A velocidade média de “,nome,” foi “, velmedia )
fimalgoritmo
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.
Análise
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.
Algoritmo “Media3”
Var Nome : caracter
DistTrecho1, DistTrecho2, DistTotal, Tempo, VelMedia : real
Inicio
escreval(“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 )
DistTotal <- DistTrecho1+DistTrecho2
VelMedia <- DistTotal/Tempo
escreva(“A velocidade média de “,Nome,” foi “, VelMedia)
fimalgoritmo
Inserindo Comentários em nossos Programas
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 palavrachave
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 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:
a) Identificar o autor e a data da criação de um programa.
b) 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.
c) Explicar (até para nós 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.
d) Identificar trechos críticos no algoritmo, alertando para os efeitos que alterações naquele ponto podem ter em outras
partes do programa.
e) Justificar porque certas técnicas foram utilizadas em certos pontos do programa, etc.
Para nossos propósitos, usaremos o mesmo esquema de comentários até o fim da linha da linguagem C. A seguir temos a
repetição da resposta do problema 2, comentada (os trechos 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
Algoritmo “Media2”
// Declaração das Variáveis
Var Nome : caracter
Distancia,Tempo,VelMedia : real
Inicio
// Apresentação do programa
escreval(“Programa que calcula a velocidade média de um piloto.” )
// Obtenção dos dados
escreva(“Digite o nome do piloto : “)
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 <- Distancia/Tempo
// Exibição dos resultados
escreva(“A velocidade média de “,Nome,” foi “, VelMedia )
fimalgoritmo
É óbvio que não se precisa colocar uma linha de comentário para cada linha de código, nem comentar aquilo que, de tão
trivial, nem precisa ser explicado. Entenda o exemplo acima como uma ilustração do uso de comentários, e não como uma
regra a ser seguida.
Exercícios
1. Faça um programa que receba um número e imprima o seu dobro.
2. Faça um programa que receba dois números e imprima o seu produto e a sua soma.
3. Dado o lado de um quadrado, calcular sua área e seu perímetro.
4. Dado o valor da aresta de um cubo, calcular sua área total.
5. Dados os valores do lado maior e do lado menor de um retângulo, calcular a sua área e o seu perímetro.
6. Dadas a altura e base de um triângulo, calcular a sua área.
7. Dados os valores do lado diferente e dos lados iguais de um triângulo isósceles, calcular o seu perímetro.
8. A área de um trapézio é dada pela multiplicação da altura pela média aritmética das bases. Faça um programa que leia
o valor da base menor, da base maior e da altura de um trapézio, e calcule e imprima sua área.
9. Faça um programa que, dado o raio de um círculo, calcule seu perímetro e sua área.
10. Dados 3 números quaisquer, calcular a sua média aritmética.
11. Dados 3 números quaisquer, calcular sua média harmônica. A média harmônica de três valores é dada por:
12. Dados o número de pessoas na mesa de uma pizzaria e o valor total da conta, calcular a parte de cada uma.
13. Escreva um programa que leia o nome de um funcionário, seu número de horas trabalhadas no mês, o valor que recebe
por hora e calcule seu salário mensal. A resposta deve estar no formato “O funcionário XXXX receberá um salário de
R$ 999999.99. “)
14. Escreva um programa que leia o valor de um empréstimo e calcule o valor de cada amortização (ou prestação)
considerando 24 amortizações a uma taxa de 48%. Use a fórmula abaixo:
15. No início de uma viagem anotei a marcação no velocímetro de meu carro, e no fim também. Sabendo que gastei certa
quantidade de gasolina na viagem, faça um programa que calcule o rendimento médio (em km/l) do carro.
16. Em um concurso, a prova de Português tem peso 3, e a de Matemática peso 2. Faça um programa que calcule a média
de um candidato, obtendo as notas nestas duas provas.
17. Dados o valor de uma compra, o valor da entrada e o número de parcelas, calcular o valor a ser financiado e também
valor de cada pagamento mensal.
18. Dados o valor da entrada, o número de parcelas e o valor de cada uma, calcular o valor total de uma compra.
19. Dados o valor de uma compra e o percentual de desconto, calcule o valor a ser pago pelo cliente.
20. O rendimento de um empregado em um ano é o seu salário mensal vezes 12, mais o décimo-terceiro, que tem o
mesmo valor do salário mensal. Entretanto, no mês em que ele tira férias ele recebe mais um terço de seu salário
mensal. Faça um programa que receba o salário de um funcionário e calcule o rendimento total anual baseado no que
foi descrito anteriormente.
21. Um professor de matemática quer saber o resultado da função y = 3x + 2 + x/2 para vários valores de x. Para não ter o
trabalho de calculá-los todos, precisa de um programa que receba o valor de x e mostre o valor de y correspondente.
Faça este programa.
22. Uma turma deseja realizar um churrasco em um sítio. O sítio cobra R$5,00 por pessoa, mais um adicional fixo de
R$50,00, por conta de despesas de manutenção. Faça um programa que peça quantas pessoas vão participar do
churrasco, calcule a despesa total ( R$5,00 por pessoa, mais sua parte no fixo) e imprima este valor.
23. Uma churrascaria só tem chopp, refrigerantes e rodízio. O chopp é R$1,50, o refrigerante R$1,00 e o rodízio R$ 8,00.
Faça um programa que leia quantos rodízios, refrigerantes e chopps foram consumidos em uma mesa, e calcule o total
da conta, não se esquecendo dos 10% do garçon!
24. O cálculo do peso ideal de um homem é dado pela seguinte fórmula: multiplique sua altura em metros por 72.7, e do
valor obtido subtraia 58. Baseado nesta fórmula, faça um programa que receba a altura de um homem e escreva o seu
peso ideal (se uma pessoa tem 1m e 80 de altura, o valor a ser digitado é 1.8, e assim por diante).
25. Escreva um algoritmo que leia três valores, respectivamente o 1° termo de uma progressão aritmética (a1) , o último
termo da progressão (an) e a razão desta progressão (r), e calcule e escreva a soma dos termos da progressão
aritmética.
26. Escreva um algoritmo que leia 3 valores a, b e c que são os lados de um triângulo e calcule a área deste triângulo,
segundo a fórmula abaixo (onde s representa o semi-perímetro, ou seja, a metade da soma dos lados):
27. Um sistema de equações lineares do tipo:
aX + bY = c
dX + eY = f
pode ser resolvido segundo mostrado abaixo:
Escreva um algoritmo que leia os coeficientes a, b, c, d, e, f e calcule e escreva os valores X e Y.
28. O custo ao consumidor, de um carro novo, é a soma do custo de fábrica com a percentagem do distribuidor e dos
impostos (aplicados ao custo de fábrica). Supondo que a percentagem do distribuidor seja de 28% e os impostos de
45%, escrever um algoritmo para ler o custo de fábrica de um carro e escrever o custo ao consumidor.
29. Considerando que o aumento dos funcionários é de 80% do INPC e mais um percentual de produtividade discutido
com a empresa. Escrever um algoritmo que lê o número do funcionário, seu salário atual, o valor do INPC e o índice
de produtividade conquistado e escreve o número do funcionário, seu aumento e o valor de seu novo salário.
30. Escrever um algoritmo que leia 2 valores e encontre e imprima o maior deles, usando a fórmula a seguir ( |a-b|
representa o valor absoluto de a-b) :
Capítulo 4 – Ensinando o Computador a Decidir
Até agora temos criado programas que são apenas uma seqüê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 seqüência normal dos comandos de um
programa baseados na resposta a uma pergunta, ou em um linguajar mais técnico, 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.
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, porque estabelecem uma relação entre valores (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, não são diferentes)
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 calculamos seu valor
primeiro para depois fazer as comparações. 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
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 e 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 5 – 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.
Algoritmo “Sugestao”
var Dinheiro: Real
Inicio
escreval(“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.”)
fimalgoritmo
Em relação ao que vimos até agora, apenas uma novidade: a expressão fimse ao final do comando de decisão. Ela
delimita o comando, isto é, mostra onde as ações da parte senao 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 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 fimse é fundamental, e todas as linguagens de programação têm algo que
cumpra esta função.
Problema 6 – 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.
Algoritmo “ChecaIdade”
Var AnoNascimento, Idade: inteiro
Inicio
escreval(“Checagem de Idade da Boate Noites Cariocas”)
escreva(“Em que ano você nasceu?”)
Leia(AnoNascimento)
Idade <- 2003 – AnoNascimento
Se Idade >= 18 então
escreva(“Você pode entrar na boate.”)
senao
escreva(“Infelizmente, você não pode entrar.”)
fimse
fimalgoritmo
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 Novembro de 2003).
Como você já deve ter notado, ela é dispensável. Veja o algoritmo abaixo.
Algoritmo “ChecaIdade2”
AnoNascimento: Inteiro
Inicio
escreval(“Checagem de Idade da Boate Noites Cariocas”)
escreva(“Em que ano você nasceu?”)
Leia(AnoNascimento)
Se (2003 – AnoNascimento) >= 18 entao
escreva(“Você pode entrar na boate.”)
senao
escreva(“Infelizmente, você não pode entrar.”)
fimse
fimalgoritmo
A partir de 2004, este algoritmo não vai mais funcionar corretamente, como você já deve ter notado. Portanto, vamos
melhorá-lo para que possa funcionar em qualquer ano.
Algoritmo “ChecaIdade3”
Var AnoAtual, AnoNascimento: Inteiro
Inicio
escreval(“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
fimalgoritmo
Exercícios
1. Dadas as variáveis A, B, C e D, do tipo real, e os comandos de atribuição a seguir, avalie as expressões abaixo e
descubra se seu resultado é FALSO ou VERDADEIRO.
A <- 10
B <- 15
C <- 8
D <- 20
a) A = D / 2
b) B * 2 = A + D
c) B = A
d) A * ( C + 2 ) < D * 5
e) A + B + C + D = 43
2. 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 do tipo real, atribuídos da seguinte maneira):
I <- 18
J <- I / 2
a) 9 + K = 17
b) K = I + J
c) 3 * K = I
d) K + J = I + 10
e) (K / 2) = (I * 3) / ( J – 3 )
3. 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
a) K <= I – J
b) K < I – J
c) K * I <= (J + 8) * 4
d) K * I <= I
4. Faça um programa que receba dois números e imprima “Os números são iguais” ou “Os números são diferentes” caso
sejam ou não iguais.
5. Faça um algoritmo que receba dois números inteiros e informe qual é o maior. Refaça depois o algoritmo, desta vez
para informar qual é o menor.
6. Faça um programa que receba três números do usuário e verifique se o terceiro é a soma dos outros dois: caso seja, o
programa emitirá a mensagem: “Operação correta!”; senão, a mensagem será “Você cometeu um engano…”.
7. Escrever um algoritmo que leia o nome e o sexo de uma pessoa (“M” ou “F”) e informe se ela é homem ou mulher,
com uma mensagem no formato “XXXX é homem”, ou “XXXX é mulher”, onde XXXX é o nome da pessoa.
8. Faça um programa que pergunte ao usuário se ele é estrangeiro (ele responderá com “S” ou “N”). Caso ele seja
estrangeiro, o programa perguntará em que país nasceu.
9. Faça um programa que pergunte ao usuário se ele é brasileiro (ele responderá com “S” ou “N”). Caso ele seja
estrangeiro, o programa perguntará em que país nasceu; se não for, perguntará em que estado nasceu. Em ambos os
casos o programa perguntará depois o ano de nascimento. Ao final, o programa imprimirá uma frase como : “O
usuário é ????, nasceu em XXXX e tem NN anos de idade”, onde ???? é BRASILEIRO ou ESTRANGEIRO,
conforme o caso.
10. Faça um programa que receba um número do usuário e diga se ele é par ou impar. DICA: Considere a divisão como
sendo inteira, isto é, 20 DIV 2=10, 17 DIV 2 = 8, 5 DIV 2=2, etc. Uma outra possibilidade é se usar o operador MOD,
ou ainda a funçao INT(). Lembre-se de declarar variáveis do tipo inteiro se for usar DIV ou MOD.
11. Escrever um algoritmo que lê o número do vendedor de uma empresa, seu salário fixo e o total de vendas por ele
efetuadas. Cada vendedor recebe um salário fixo, mais uma comissão proporcional às vendas por ele efetuadas. A
comissão é de 3% sobre o total de suas vendas até 1.000.000 e 5% sobre o que ultrapassar este valor. Escrever o
número do vendedor, o total de suas vendas seu salário fixo e o seu salário total.
Capítulo 5 – 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 ainda um outro, para verificar entre as duas restantes qual a
possibilidade correta. Vejamos estes exemplos:
Problema 7 – Qual o Maior Valor?
Enunciado
Faça um programa que leia dois valores e indique o maior deles, ou se são iguais.
Algoritmo “DescubraoMaior”
Var Valor1, Valor2 : Inteiro
Inicio
// Leitura dos dados
escreva(“Digite o primeiro valor :”)
Leia(Valor11)
escreva(“Digite o segundo valor:”)
Leia(Valor21)
// Resultado (Note que há dois testes, um “dentro” do outro…)
Se Valor1 > Valor2 entao
escreval(“O primeiro valor é o maior.”)
Senao
// Eliminamos a primeira possibilidade (de o primeiro valor ser o maior)
// Agora vamos ver entre as duas restantes
Se Valor2 > Valor1 entao
escreval(“O segundo valor é o maior.”)
Senao
// Eliminamos também a segunda possibilidade
// (de o segundo valor ser o maior).
// Então, so resta a terceira (eles são iguais)
escreval(“Os dois valores são iguais.”)
Fimse
Fimse
fimalgoritmo
Simples, não é? Agora veremos um problema em que antes de fazermos os testes, deveremos “processar” os dados um
pouco…
Problema 8 – 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 leia as distâncias que cada carro percorreu e
o tempo que cada um levou, e indique o carro que teve maior velocidade média.
Análise e Entendimento
Neste programa, temos que comparar as velocidades médias, mas vamos obter do usuário a distância percorrida e o tempo
gasto de cada carro. Com base nestes dados, primeiro calculamos as velocidades médias de cada um, e só então fazemos as
comparações.
Algoritmo “VelocidadeMedia1”
// Distância percorrida, tempo gasto e velocidade media de cada carro
Var Distancia1, Distancia2, Tempo1, Tempo2, VelMed1, VelMed2 : Real
Inicio
// 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, um “dentro” do outro…)
Se VelMed1 > VelMed2 entao
escreval(“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
escreval(“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, so resta a terceira (os dois carros tiveram a mesma
// velocidade média)
escreval(“Os dois carros tiveram a mesma velocidade média.”)
Fimse
Fimse
fimalgoritmo
Neste problema vemos como se coloca uma estrutura de teste (se … entao … senao … fimse) dentro de
outra. A indentação não é obrigatória, mas note como ela facilita o entendimento do algoritmo. A colocação de uma
estrutura dentro de outra em um programa é conhecida como “aninhamento”. Qualquer estrutura pode ficar contida dentro
de outra, de qualquer tipo (sim, há outros tipos de estruturas, nós os veremos à frente…). A única regra é : quando duas
estruturas são aninhadas, a mais interna deve ficar TOTALMENTE contida na mais externa. Veja a explicação a seguir,
baseada no algoritmo anterior (eliminamos os comentários para facilitar a leitura):
Se VelMed1 > VelMed2 entao
escreval(“O Carro 1 teve maior velocidade média.”)
Senao
// O segundo se…entao..senao…fimse fica
// TOTALMENTE contido neste ponto.
Se VelMed2 > VelMed1 entao
escreval(“O Carro 2 teve maior velocidade média.”)
Senao
escreval(“Os dois carros tiveram a mesma velocidade média.”)
Fimse
Fimse
Problema 9 – 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.
Algoritmo “ResultadoFinal”
Var Nota1, Nota2, Media : Real
Inicio
// 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
escreval(“Sua média final é :”, Media)
// Vamos eliminar a primeira possibilidade
Se Media >= 7 entao
escreval(“Você foi 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
escreval(“Você foi reprovado”)
Senao
// Então, ficou em final…
escreval(“Você está na final, e precisa de “, 10 – Media)
Fimse
Fimse
fimalgoritmo
Uma coisa interessante a se notar é que a ordem dos testes não faz diferença, desde que se cubram todas as possibilidades.
Entretanto, pode ser que se testarmos em uma determinada ordem o algoritmo fique mais “natural”, isto é, reflita a situação
sendo modelada com mais clareza, e fique mais fácil de se entender. É uma questão de estilo…
Exercícios
Saber interpretar um algoritmo é uma habilidade tão importante quanto fazê-lo. Por isso, seguem alguns exercícios sobre
esta habilidade. Você vai notar que alguns destes exercícios não fazem nada de útil; não se impressione, eles são apenas
para testar sua habilidade de “rodar o chinês” (gíria de programador para “interpretar o algoritmo”)…
1. Dados os algoritmos abaixo:
algoritmo “Teste1”
var a,b,c : inteiro
inicio
leia(a)
leia(b)
c <- (a*3) + 4
se c=b entao
a <- a + 5
escreva( 2 * a )
senao
se c > b entao
escreva( b+c )
senao
escreva( a + b + c )
fimse
fimse
fimalgoritmo
Teste-o com os seguintes valores para a e b:
a) a = 4, b = 16
b) a = 6, b = 20
c) a = 10, b = 11
e diga que valores serão escritos na tela do computador.
algoritmo “FolhaDePagamento”
var Salario, Rendimento, INSS, IR : real
inicio
IR <- 0
Leia( Salario )
se Salario >= 1200 entao
INSS <- Salario * 8 /100
senao
INSS <- Salario * 7 /100
fimse
Rendimento <- Salario – INSS
se Rendimento > 1500 entao
IR <- (Rendimento * 20/100) – 135
senao
se Rendimento > 900 entao
IR <- Rendimento * 15/100
fimse
fimse
Rendimento <- Rendimento – IR
escreva( Salario, IR, INSS, Rendimento )
fimalgoritmo
Teste o algoritmo com os seguintes valores de Salario: 500, 900, 1000, 1200 e 2000. Para cada caso, mostre o que será
escrito na tela.
2. 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, tendo como base o ano atual (este dado também deverá ser pedido pelo programa).
3. Faça um programa que receba dois números do usuário e diga se o primeiro é divisível pelo segundo. Use as mesmas

Técnicas do exercício 10 do capítulo anterior.
4. Um funcionário recebe 250 dólares por mês. Se este salário, depois de convertido em reais, for inferior a R$700,00, ele
recebe ainda uma ajuda de custo de R$80,00. Faça um programa que obtenha o valor do dólar e calcule e imprima seu
salário final.
5. Faça um programa que leia quantas aulas foram dadas em uma turma em um semestre. Depois o programa lerá o
número de faltas que um aluno teve. O programa deverá informar o percentual de presença, e caso ele tenha sido
menor que 25%, deve informar também que o aluno está reprovado por faltas.
6. Escrever um algoritmo que leia os dados de uma pessoa (nome, sexo, idade e saúde) e informe se ela está apta ou não
para cumprir o serviço militar. Se a pessoa não estiver apta, indique o motivo pelo qual a pessoa não está apta para
cumprir o serviço militar (Uma pessoa não é apta se é mulher, ou não tem idade suficiente, ou saúde não é ‘boa’).
7. Escrever um algoritmo que leia 2 valores inteiros e um caracter e realize uma das quatro operações aritméticas básicas
entre estes dois valores. A operação a ser realizada é dada pelo caracter (+, -, *, /).
Capítulo 6 – Trabalhando com Perguntas mais Complexas
Muitas vezes nossas decisões serão tomadas tendo em vista a resposta a mais de uma questão. Vamos tomar como exemplo
o problema visto anteriormente:
Se “tiver R$10,00 sobrando” então
“irei ao cinema”
senão
“ficarei vendo TV em casa”.
Ora, ir ao cinema sozinho não é muito agradável. Então faremos o seguinte: só iremos ao cinema se, além de ter o dinheiro,
um amigo (ou amiga) puder ir conosco. O problema então poderia ser colocado da seguinte forma:
Se “tiver R$10,00 sobrando” então
Se “meu amigo ou amiga puder ir comigo” então
“irei ao cinema”
senão
“ficarei vendo TV em casa (tenho dinheiro, mas não tenho companhia)”
senão
“ficarei vendo TV em casa (não tenho dinheiro)”.
Veja que a linha “irei ao cinema” só será “executada” se a resposta às suas duas perguntas for “sim”. Vamos agora traduzir
este exemplo para a linguagem de algoritmos.
algoritmo “Sugestao2”
var Dinheiro: real
TemCompanhia : caracter
inicio
escreval(“Serviço Informatizado de Sugestões”)
ecreva(“Quanto dinheiro você tem sobrando?”)
leia(Dinheiro)
escreva(“Você tem companhia (S/N)?”)
leia(TemCompanhia)
se Dinheiro >= 10 entao
se TemCompanhia = “S” entao
escreval(“Vá ao cinema hoje à noite.”)
senao
escreval(“Fique em casa vendo TV.”) // Sem companhia é chato…
fimse
senao
escreval(“Fique em casa vendo TV.”) // Você está sem dinheiro…
fimse
escreva(“Obrigado e volte sempre.”)
fimalgoritmo
Há vários detalhes interessantes neste algoritmo. Primeiro, veja como resolvemos o caso de o usuário ter ou não
companhia. Criamos uma variável do tipo caracter, TemCompanhia, e pedimos para digitar “S” ou “N”, caso ele tenha ou
não um acompanhante. Aí, testamos este conteúdo para saber se ele deve ou não ir ao cinema. Esta é uma situação similar
às que comumente encontramos em programação, e esta maneira de resolvê-la é simples e eficiente. Outra coisa que
notamos é que a linha escreval(“Fique em casa vendo TV.”)aparece duas vezes no algoritmo (com
comentários diferentes); do jeito com que os testes estão colocados, esta é a única maneira de se resolver o problema e se
apresentar a sugestão correta em cada caso. Só por curiosidade, retire uma das duas linhas e veja se o algoritmo será
executado corretamente…
Se só vamos ao cinema case a resposta às duas perguntas seja “SIM”, podemos juntá-las em um só teste. Veja como o
algoritmo fica agora:
algoritmo “Sugestao3”
var Dinheiro: real
TemCompanhia : caracter
inicio
escreval(“Serviço Informatizado de Sugestões”)
ecreva(“Quanto dinheiro você tem sobrando?”)
leia(Dinheiro)
escreva(“Você tem companhia (S/N)?”)
leia(TemCompanhia)
se (Dinheiro >= 10) e (TemCompanhia = “S”) entao
escreval(“Vá ao cinema hoje à noite.”)
senao
escreval(“Fique em casa vendo TV.”)
fimse
escreva(“Obrigado e volte sempre.”)
fimalgoritmo
O que fizemos foi usar a palavra reservada e para “unir” os dois testes em um só. Este é um recurso muito utilizado em
programação. De quebra, eliminamos aquele problema da linha que aparecia duas vezes. Analisando todos os resultados
possíveis das duas perguntas em separado e o resultado de sua “união” com a palavra e, temos:
Dinheiro >= 10 TemCompanhia = “S” (Dinheiro>=10) e (TemCompanhia=”S”)
FALSO FALSO FALSO
FALSO VERDADEIRO FALSO
VERDADEIRO FALSO FALSO
VERDADEIRO VERDADEIRO VERDADEIRO
Vemos que a única possibilidade de o teste composto resultar verdadeiro é se os resultados de todos os dois testes forem
verdadeiros também. A tabela acima é o que se chama de TABELA-VERDADE do operador e.
Agora vamos ver uma outra situação: suponha que você goste de rock, aprecie muito as bandas Paralamas do Sucesso e
Barão Vermelho, e seu amigo o convida para um show. Você só está interessado em ir se for de uma destas duas bandas;
ver qualquer outra não vale a pena o trabalho e a despesa… Colocando esta situaçao em forma estruturada, teremos:
Se “o show for do Paralamas” então
“irei ao show”
senão
Se “o show for do Barão” então
“irei ao show”
senão
“ficarei vendo em casa ”
Colocando o programa na linguagem do algoritmo, temos o seguinte:
algoritmo “Sugestao4”
var Banda : caracter
inicio
escreval(“Serviço Informatizado de Sugestões”)
ecreva(“Qual é a banda do show?”)
leia(Banda)
se Banda = “Paralamas” entao
escreval(“Vá ao show.”)
senao
se Banda = “Barão” entao
escreval(“Vá ao show.”)
senao
escreval(“Fique em casa vendo TV.”)
fimse
escreva(“Obrigado e volte sempre.”)
fimalgoritmo
Como você deve ter notado, temos de novo o problema da linha que aparece duas vezes. Como resolvê-lo? Observe
que existem duas possibilidades de você ir ao show: se a banda for Paralamas ou se a banda for o Barão. A palavra ou
não foi grifada por acaso, pois podemos juntar as duas perguntas em uma só usando este operador, o que vai
simplificar nosso “programa”.
algoritmo “Sugestao5”
var Banda : caracter
inicio
escreval(“Serviço Informatizado de Sugestões”)
ecreva(“Qual é a banda do show?”)
leia(Banda)
se (Banda = “Paralamas”) ou (Banda = “Barão”) entao
escreval(“Vá ao show.”)
senao
escreval(“Fique em casa vendo TV.”)
fimse
escreva(“Obrigado e volte sempre.”)
fimalgoritmo
Analisando todos os resultados possíveis das duas perguntas em separado e o resultado de sua “união” com a palavra ou,
temos:
Banda=”Paralamas” Banda=”Barão” (Banda=”Paralamas”) ou (Banda=”Barão”)
FALSO FALSO FALSO
FALSO VERDADEIRO VERDADEIRO
VERDADEIRO FALSO VERDADEIRO
VERDADEIRO VERDADEIRO VERDADEIRO
Vemos que basta um dos testes resultar verdadeiro (ou os dois – que seria um show com as duas bandas…) para que o teste
composto resulte verdadeiro também. A tabela acima é o que se chama de TABELA-VERDADE do operador ou.
Podemos criar expressões tão complexas quanto for necessário para resolver um dado problema, juntando várias perguntas
com os operadores e e ou. Vamos juntar nossos exemplos acima na seguinte situação: vai haver um show em sua cidade,
mas você só irá se for com uma daquelas bandas citadas anteriormente, e também se a entrada custar até 50 reais, que é o
que você tem no momento. O algoritmo ficaria assim:
algoritmo “Sugestao6”
var Entrada : real
Banda : caracter
inicio
escreval(“Serviço Informatizado de Sugestões”)
ecreva(“Qual é a banda do show?”)
leia(Banda)
ecreva(“Qual é o valor da entrada?”)
leia(Entrada)
se (Entrada<=50) e ( (Banda=”Paralamas”) ou (Banda=”Barão”) ) entao
escreval(“Vá ao show.”)
senao
escreval(“Fique em casa vendo TV.”)
fimse
escreva(“Obrigado e volte sempre.”)
fimalgoritmo
Uma coisa para ser analisada neste algoritmo é a grande quantidade de parênteses. Eles são necessários para que a ordem
de avaliação das perguntas seja correta de acordo com nossa necessidade. Entre os operadores lógicos existe a mesma
característica de precedência que há nos operadores aritméticos. Neste caso, o operador e é avaliado antes do operador ou.
O que nós queremos, no entanto é que a expressão com o ou seja avaliada ANTES da expressão com o e, e portanto
usamos os parênteses para indicar ao computador a ordem necessária. Só como curiosidade, vamos dar valores às variáveis
e analisar o resultado final da expressão.
Entrada Banda Entrada<=50 Banda=”Paralamas” ou Banda=”Barão” Resultado Final
R$ 30,00 Barão V V V
R$ 50,00 Raimundos V F F
R$ 60,00 Paralamas F V F
R$ 45,00 Paralamas V V V
R$ 50,00 Barão V V V
R$ 70,00 Raimundos F F F
Outra coisa importante a ser notada é que quando se juntam várias “perguntas” em uma só, é necessário que ela seja
repetida em sua totalidade; um erro comum em iniciantes de programação é fazer algo como:
Se (Entrada<=50) e (Banda=”Paralamas” ou “Barão”) entao // ERRADO!
Uma construção como esta pode até refletir o jeito com que falamos, mas é inaceitável para uma linguagem de
programação, e portanto não pode ser utilizada na construção de algoritmos. Para facilitar as coisas, a maioria das
linguagens tem uma ou mais estruturas que ajudam na solução de situações como esta, e as veremos mais adiante.
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 10 – 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 do capítulo 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.
Algoritmo “Conceito1”
Var Media : Real
Inicio
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
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
fimalgoritmo
Refinamento 1
Analisando a tabela, vemos que as notas variam de 0 a 10 (estamos assumindo, é claro, que o operador do programa não
vai digitar valores estranhos, como –1, 77, etc.) Isto 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.
Algoritmo “Conceito2”
Var Media : Real
Inicio
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
fimalgoritmo
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.
Algoritmo “Conceito3”
Var Media : Real
Conceito : Caracter
Inicio
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”
senao
Conceito <- “Excelente”
fimse
fimse
fimse
escreva(“Conceito : “,Conceito)
fimalgoritmo
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 11 – 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.
Algoritmo “Comissao1”
Var Fixo, Vendas, Faltas, Percentual : real
Comissao, Desconto, Salario : real
inicio
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)
Desconto <- Faltas * 5
// E descobrimos o salario final…
Salario <- Fixo + Comissao – Desconto
escreva(“O salário final do vendedor é :”, Salario)
fimalgoritmo
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 (isto é, economia no número de variáveis declaradas).
Algoritmo “Comissao2”
Var Fixo, Vendas, Faltas, Percentual : real
inicio
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 é :”)
escreva(Fixo + (Vendas * Percentual / 100) – (Faltas * 5))
fimalgoritmo
Exercícios
1. Elabore um algoritmo que leia o código de um determinado produto (numérico) e escreva a sua classificação, de
acordo com a seguinte tabela:
Código Classificação
1 Alimento Não-Perecível
2, 3, ou 4 Alimento Perecível
5 ou 6 Vestuário
7 Higiene Pessoal
8 até 15 Limpeza e Utensílios Domésticos
Qualquer Outro Código Inválido
2. Faça um programa que leia 3 valores numéricos informe qual é o menor deles.
3. Provavelmente você usou três variáveis para resolver o exercício acima. Consegue resolvê-lo usando apenas duas
variáveis?
4. Faça um programa que leia três valores digitados em qualquer ordem nas variáveis V1, V2 e V3, e os coloque em
ordem crescente, de modo que o menor valor fique em VI, o segundo menor em V2 e o maior em V3.
5. Faça um programa que leia dois valores, que serão o limite inferior e superior de um intervalo fechado. Assuma que o
primeiro valor é menor que o segundo. Depois o programa lerá um terceiro valor e informará se ele está dentro do
intervalo ou não.
6. Repita o exercício anterior, mas agora pense que o usuário pode errar e digitar um limite inferior maior ou igual ao
superior. Neste caso, o programa não deverá pedir o terceiro número, e informar o problema ao operador.
7. Faça um programa que leia o valor de uma mercadoria, e depois o modo de pagamento, que pode ser “V” (à vista) ou
“P” (a prazo). Se for “P”, o preço será acrescido de 10%, e o programa pedirá o número de prestações do
financiamento, dividindo o valor já com acréscimo por este número, para saber (e imprimir) o valor de cada prestação.
Se o modo de pagamento for “V”, haverá um desconto de 5%, e o programa vai mostrar o novo valor.
8. 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; senão, é reprovado. Faça um programa que receba as duas notas de um aluno e
escreva se ele passou ou não para o próximo período. O programa não deve aceitar notas fora da faixa permitida.
Qualquer erro do usuário fará com que o programa emita uma mensagem avisando o ocorrido, e termine.
9. Faça um programa que receba três valores que serão os lados de um triângulo, e indique o tipo de triângulo formado
por eles (eqüilátero, isósceles ou escaleno). Assuma que os lados sempre poderão formar um triângulo.
10. Repita o exercício anterior, prevendo que os lados podem não formar um triângulo. Caso não se lembre como isto é
feito, consulte um bom livro de geometria…
11. O cálculo do peso ideal de um homem (em quilos) é dado pela fórmula (72.7 * h) – 58, onde h é a altura em metros,
ou seja se uma pessoa tem 1m e 80 de altura, o valor de h é 1.8, e assim por diante. Baseado nesta fórmula, faça um
programa que receba a altura de um homem e seu peso. O programa vai calcular o peso ideal deste homem e comparar
com o peso fornecido pelo usuário, imprimindo “Você está com o peso correto.”, “Você está acima do peso ideal.”, ou
“Você está abaixo do peso ideal.” caso o peso fornecido seja respectivamente igual, maior ou menor que o peso ideal
calculado.
12. O peso ideal para uma mulher é dado pela fórmula (62.1 * h) – 44.7. Faça um programa que leia o sexo de uma pessoa
( “F” ou “M”), sua altura e seu peso, calcule seu peso ideal de acordo com o sexo e informe se a pessoa está dentro do
peso, acima ou abaixo.
13. Repita o exercício acima, dando uma tolerância de 3 quilos (abaixo ou acima do peso) para as mulheres e 5 quilos para
os homens. Isto significa que se o peso ideal de uma mulher for 54 quilos, por exemplo, se ela tiver entre 51 (54-3) e
57 (54+3) quilos, ainda assim o programa dirá que está dentro do peso ideal.
Capítulo 7 – Selecionando um entre muitos
Suponha que você tenha que fazer um programa onde o usuário fornece o nome de um time de futebol e o programa indica
o seu estado de origem, de acordo com a seguinte “base de dados”:
Time Origem
Fluminense
Vasco
Flamengo
Carioca
Santos
Palmeiras
São Paulo
Corínthians
Paulista
Santa Cruz
Náutico Pernambucano
Bahia
Vitória Baiano
Grêmio
Internacional Gaúcho
Bom, você já deve estar pensando na quantidade de “se … então … senão” que o programa vai ter, não é? Só por
curiosidade, vamos começar a resolver o problema desta maneira.
algoritmo “times1”
var time, origem : caracter
inicio
escreva(“Digite o nome de um time: “)
leia(time)
se time = “Fluminense” entao
origem = “Carioca”
senao
se time = “Vasco” entao
origem = “Carioca”
senao
se time = “Flamengo” entao
origem = “Carioca”
senao
se time = “Santos” entao
origem = “Paulista”
senao
se time = “Palmeiras” entao
….. etc., etc., etc…
fimse
fimse
fimse
fimse
fimse
escreva(“O time “, time , ” é “, origem)
fimalgoritmo
É claro que podemos fazer melhor do que isso! Pense bem: um time é carioca se seu nome for Vasco, Flamengo ou
Fluminense, paulista se seu nome for Santos, Palmeiras, São Paulo ou Corínthians, etc. Isto nos indica que podemos usar o
operador lógico ou para reunir várias perguntas em uma só, o que tornará o algoritmo bem mais “enxuto”. Vamos ver
como esta solução fica:
algoritmo “times2”
var time, origem : caracter
inicio
escreva(“Digite o nome de um time: “)
leia(time)
se (time=”Fluminense”) ou (time=”Vasco “) ou (time=”Flamengo”) entao
origem = “Carioca”
senao
se (time=”Santos “) ou (time=”Palmeiras”) ou ((time=”São Paulo”) ou
(time=”Corínthinas”) entao
origem = “Paulista”
senao
se (time=”Santa Cruz”) ou (time=”Náutico”) entao
origem = “Pernambucano”
senao
se (time=”Bahia”) ou (time=”Vitória”) entao
origem = “Bahiano”
senao
se (time=”Grêmio”) ou (time=”Internacional”) entao
origem = “Gaúcho”
senao
origem = “desconhecido”
fimse
fimse
fimse
fimse
fimse
escreva(“O time “, time , ” é “, origem)
fimalgoritmo
Como você viu, o algoritmo ficou menor a ponto de podermos fazê-lo todo, e até incluir uma pequena sofisticação com o
caso do time desconhecido. Mesmo assim algumas linhas ficaram muito grandes, com vários ou unindo vários testes.
Precisamos melhorá-lo ainda mais.
Uma coisa que podemos notar é que todas as perguntas se baseiam no valor da variável time. Quando você encontra uma
situação como esta onde vários testes que dependem da avaliação da mesma variável, ou expandindo o conceito, da
avaliação da mesma expressão, pode lançar mão de uma estrutura de seleção.
A sintaxe de uma estrutura de seleção (isto é, o modo como devemos usá-la) é a seguinte:
escolha < expressão-de-seleção >
caso < exp 1 > , < exp 2 >, … , < exp n >
< lista-de-comandos-1 >
caso < exp 1 > , < exp 2 >, … , < exp n >
< lista-de-comandos-2 >
caso < exp 1 > ate < exp 2 >, … , < exp n >
< lista-de-comandos-2 >
outrocaso
< lista-de-comandos-3 >
fimescolha
A expressão de seleção é avaliada uma só vez, no início do comando; então, seu resultado é comparado com cada valor da
lista que vem depois da primeira palavra-chave caso. Se for igual a algum deles a lista de comandos que vem a seguir é
executada, até se encontrar uma outra palavra caso ou outrocaso; senão a próxima lista é analisada e assim
sucessivamente. Caso não haja uma igualdade entre o valor da expressão e nenhum valor de nenhuma lista, os comandos
depois da palavra outrocaso, se houver algum, são realizados.
É importante notar que a seção outrocaso é opcional. Pode haver uma situação em que desejemos não fazer nada caso o
valor que estamos procurando não exista. Outro ponto importante é que podemos ter dois valores separados pela palavra
ate. Quando isto acontece, o programa testa se o valor da expressão de seleção está entre os dois valores fornecidos, ou
seja, se é maior que ou igual ao primeiro e menor que ou igual ao segundo. Os exemplos a seguir esclarecem todas estas
características.
algoritmo “nota1”
var nota : inteiro
inicio
escreva(“Entre com a nota do aluno: “)
leia(nota)
escolha nota
caso 0,1,2,3
escreval(“Aluno reprovado.”)
escreval(“Melhor sorte no próximo período…”)
caso 4,5,6
escreval(“Aluno em final.”)
caso 7,8,9,10
escreval(“Aluno aprovado.”)
escreval(“Parabéns!”)
fimescolha
escreval(“Fim do programa.”)
fimalgoritmo
Aqui vemos o comando escolha em sua forma mais simples. A nota fornecida é comparada com cada valor da primeira
lista: se o aluno tirou 0, 1, 2 ou 3 o programa escreverá as duas mensagens na tela e depois despreza todas as outras linhas
até a palavra fimescolha. Aí ele imprime a mensagem final e o programa termina.
Suponha que o aluno tenha tirado 8: o programa não encontra este valor na primeira lista, e despreza todos os comandos
até a segunda lista, na qual também não o encontra; do mesmo modo, ele despreza os comandos até a terceira lista, onde
vai encontrar o valor 8 e executar os comandos correspondentes.
E se o usuário digitar um valor menor que 0 ou maior que 10? Naturalmente, estas são notas inválidas e não estão em
nenhuma das listas. Neste caso, o programa não vai colocar nenhuma mensagem na tela sobre a situação do aluno,
escrevendo apenas a mensagem final. Analise agora a segunda versão deste programa:
algoritmo “nota2”
var nota : inteiro
inicio
escreva(“Entre com a nota do aluno: “)
leia(nota)
escolha nota
caso 0,1,2,3
escreval(“Aluno reprovado.”)
escreval(“Melhor sorte no próximo período…”)
caso 4,5,6
escreval(“Aluno em final.”)
caso 7,8,9,10
escreval(“Aluno aprovado.”)
escreval(“Parabéns!”)
outrocaso
escreval(“Nota inválida.”)
fimescolha
escreval(“Fim do programa.”)
fimalgoritmo
Incluímos a seção outrocaso, que vai tratar o caso de notas que não estejam entre 0 e 10, colocando a mensagem
correspondente na tela. Só para lembrar: os comandos da seção outrocaso são executados se e somente se o programa
não encontrar nas listas (linhas começando com a palavra caso) o valor da expressão de seleção.
Vamos melhorar mais um pouco este programa:
algoritmo “nota3”
var nota : inteiro
inicio
escreva(“Entre com a nota do aluno: “)
leia(nota)
escolha nota
caso 0 ate 3
escreval(“Aluno reprovado.”)
escreval(“Melhor sorte no próximo período…”)
caso 4,5,6
escreval(“Aluno em final.”)
caso 7 ate 9, 10
escreval(“Aluno aprovado.”)
escreval(“Parabéns!”)
outrocaso
escreval(“Nota inválida.”)
fimescolha
escreval(“Fim do programa.”)
fimalgoritmo
Como você deve ter notado, substituímos a linha caso 0,1,2,3 por caso 0 ate 3, e caso 7,8,9,10 por
caso 7 ate 9, 10 (poderíamos ter feito o mesmo com a linha caso 4,5,6, mas a deixamos como está para
comparação). Fizemos isto para ilustrar o uso da palavra ate numa lista de valores. Note que se a nota do aluno for 0, 1, 2
ou 3 (isto é, de 0 até 3) o programa escreverá “Aluno reprovado” na tela; na outra linha modificada, mostramos que a
palavra ate pode ser usada em conjunto com uma lista simples de valores: se a nota do aluno for 7,8 ou 9 (isto é, de 7 até
9), ou 10, o programa escreverá “Aluno aprovado.”
As listas de valores não precisam estar em nenhuma ordem específica, embora como técnica de programação adotar uma
seja uma boa idéia. A única obrigação é que a seção outrocaso seja a última do comando. Lembre-se também de que
para se usar a palavra ate o primeiro valor tem que ser menor que o segundo. A versão do programa a seguir é igualmente
correta, mas note que já fica um pouco mais difícil de se entender:
algoritmo “nota4”
var nota : inteiro
inicio
escreva(“Entre com a nota do aluno: “)
leia(nota)
escolha nota
caso 6, 4, 5
escreval(“Aluno em final.”)
caso 10, 7 ate 9
escreval(“Aluno aprovado.”)
escreval(“Parabéns!”)
caso 0 ate 3
escreval(“Aluno reprovado.”)
escreval(“Melhor sorte no próximo período…”)
outrocaso
escreval(“Nota inválida.”)
fimescolha
escreval(“Fim do programa.”)
fimalgoritmo
Quase todas as linguagens de programação têm uma estrutura parecida com esta, cada uma com suas características,
restrições ou facilidades específicas. A idéia básica, no entanto, é a mesma. O que você aprendeu aqui, com pequenas
adapatações, permitirá o uso desta estrutura quando for necessária.
Um dos usos mais comuns da estrutura de seleção é para se fazer algo em um programa baseado em uma opção fornecida
pelo usuário. O programa apresenta um menu para o operador, obtém sua resposta e realiza a tarefa escolhida. Veja o
programa a seguir:
Problema 11 – Cálculo da área de figuras geométricas
Enunciado
Faça um programa que calcule a área de um círculo, quadrado ou triângulo. O usuário informará a figura da qual deseja a
área, e baseado nesta escolha o programa pedirá os dados adequados e realizará o cálculo.
Análise
Nos exercícios do capítulo 1 vimos como se calculam as áreas das figuras pedidas. Podemos aproveitar o que foi visto ali.
Precisamos agora é de obter do usuário a figura da qual ele quer o cálculo, para saber que dados iremos pedir e que fórmula
usaremos.
Definição dos dados
Precisaremos da opção da figura, para a qual usaremos uma variável do tipo caracter chamada OPCAO, com os valores
“C” para o círculo, “Q” para o quadrado e “T” para o triângulo e “F” para finalizar o programa. Para qualquer outro valor,
o programa informará que a opção foi inválida. Usaremos também duas variáveis do tipo real, chamadas V1 e V2 para
obter os dados numéricos. As mesmas variáveis serão usadas em todos os cálculos, conforme necessário.
Obtenção dos dados
A obtenção dos dados neste programa é simples e direta. Basta pedirmos ao usuário que digite os valores.
Processamento
Segundo as fórmulas de cálculo para cada figura.
Exibição
Basta exibir o conteúdo da área calculada.
Solução
algoritmo “areas”
var opcao : caracter
v1,v2,v3 : real
inicio
escreval(“Programa para cálculo de áreas de figuras geométricas.”)
escreval
escreval(“Q – Área do quadrado”)
escreval(“C – Área do círculo”)
escreval(“T – Área do trapézio”)
escreval(“F – Fim”)
escreva(“Digite a sua opção:”)
leia(opcao)
escreval
escolha opcao
caso “Q”
escreval(“Digite o valor do lado:”)
leia(v1)
escreval(“A área do quadrado de lado “,v1,” é “, quad(v1) : 10: 3 )
caso “C”
escreva(“Digite o valor do raio:”)
leia(v1)
escreval(“A área do círculo de raio “,v1,” é “, quad(v1)*pi : 10: 3 )
caso “T”
escreva(“Digite o valor da base menor:”)
leia(v1)
escreva(“Digite o valor da base maior:”)
leia(v2)
escreva(“Digite o valor da altura:”)
leia(v3)
escreva(“A área do trapézio de bases “,v1)
escreval(” e “, v2,” e altura “,v3,” é “, (v1+v2)/2*v3 : 10: 3 )
caso “F”
escreval(“Obrigado por usar este programa.”)
outrocaso
escreval(“Opção inválida.”)
fimescolha
fimalgoritmo
A primeira coisa a comentar neste programa é como se constrói o menu. Coloca-se um título que indica o que o programa
faz, pula-se uma linha ( o comando escreval sem nada na frente faz justamente isto), listam-se as opções, pula-se outra
linha e se pede a escolha do usuário. Nos bons tempos da programação sem o modo gráfico do Windows, quase todo
programa funcionava desta maneira.
Uma vez que sabemos de que figura calcular a área, basta pedirmos os dados. Note que definimos três variáveis reais para
obter estes dados e que algumas delas são usadas em mais de um ponto do programa. Fizemos isto para “economizar” a
memória do computador, mas poderíamos ter declarados as variáveis lado, raio, basemenor, basemaior e
altura, por exemplo, para ler cada dado necessário com sua variável “exclusiva”. Em um programa pequeno como este
pode-se lançar mão do recurso das variáveis “genéricas” sem perda do entendimento; como o usuário não vê o nome das
variáveis e sim a instrução que colocamos na tela, para ele não faz diferença, mesmo. Em programas maiores, entretanto,
esta técnica não é aconselhada.
Também usamos neste programa duas funções pré-definidas, quad() e pi. Quad(x) retorna o valor de x elevado ao
quadrado, e pi retorna o famoso número 3.141592. Assim, as duas linhas abaixo são equivalentes:
escreval(“A área do círculo de raio “,v1,” é “, quad(v1)*pi : 10:3 )
escreval(“A área do círculo de raio “,v1,” é “, v1*v1*3.141592 : 10:3 )
E o que representam os números com dois pontos depois da expressão? São parâmetros de formatação para a impressão
dos valores na tela do computador. O primeiro número, 10, indica que o valor ocupará 10 colunas (espaços) na tela; o
segundo, 3, indica o número de casas decimais que serão exibidas. Valores numéricos são sempre alinhados à direita, o que
significa que se o número tiver menos de 10 dígitos o computador colocará espaçõs em branco à sua esquerda. Por outro
lado, se tiver menos de 3 casas decimais, as restantes serão completadas com zeros; se tiver mais de 3 casas, será
arredondado para as 3 da formatação.
Para terminar, note que a linha que informa a área do trapézio foi dividida em dois comandos: um escreva e um
escreval. Isto não acarreta nenhum problema, pois como sabemos o computador ao terminar o comando escreva
coloca o cursor (ponto onde a próxima leitura ou escrita será realizada) depois da última coisa escrita. Sendo assim, as
duas formas a seguir são equivalentes:
escreva(“Área do trapézio de medidas “,v1)
escreval(“,”, v2,” e “,v3,”:”, (v1+v2)/2*v3)
escreval(“Área do trapézio de medidas “,v1,”,”,v2,” e “,v3,”:”,(v1+v2)/2*v3)
Exercícios
1. Usando o comando escolha, elabore um algoritmo que leia o código de um determinado produto (numérico) e
escreva a sua classificação, de acordo com a seguinte tabela:
Código Classificação
1 Alimento Não-Perecível
2, 3, ou 4 Alimento Perecível
5 ou 6 Vestuário
7 Higiene Pessoal
8 até 15 Limpeza e Utensílios Domésticos
Qualquer Outro Código Inválido
2. Usando o comando escolha, faça um programa que peça um valor do tipo caracter para o usuário, composto de
apenas um caracter. O programa dirá se ele é um espaço, uma letra, número ou sinal de pontuação (consideraremos a
vírgula, ponto, exclamação, interrogação, dois pontos e ponto-e-vírgula); para um caracter que não se enquadre em
nenhum destes tipos, o programa informará que é um caracter desconhecido. DICA: Consulte a tabela ASCII em um
livro de informática para ver a ordem em que estes caracteres estão agrupados.
3. Repita o exercício anterior, agora informando se a letra é uma vogal ou consoante.
4. Melhore o problema 11 para incluir o cálculo da área de outras figuras, como o triângulo e retângulo.
Capítulo 8 – Trabalhando com repetições
O poder dos computadores vem do fato de eles poderem processar uma grande quantidade de dados com rapidez e
exatidão; entretanto, as estruturas que estudamos até agora não permitem que isto seja feito de uma maneira eficiente.
Imagine que você tivesse que fazer um programa que lesse três valores e calculasse o seu somatório. Provavelmente, o seu
programa seria mais ou menos assim:
algoritmo “somatorio1”
var v1,v2,v3,soma : real
inicio
escreval(“Programa para calcular o somatório de três valores.”)
escreval
escreva(“Digite o primeiro valor:”)
leia(v1)
escreva(“Digite o segundo valor:”)
leia(v2)
escreva(“Digite o terceiro valor:”)
leia(v3)
soma <- v1 + v2 + v3
escreval
escreval(“A soma dos valores é :” , soma : 10 : 3 )
fimalgoritmo
Perfeito. Para três valores apenas, esta solução é viável. Vamos melhorá-la um pouco e diminuir o número de variáveis. Na
verdade, só precisamos de duas. No exemplo a seguir as linhas são numeradas apenas para auxiliar a sua explicação.
1 algoritmo “somatorio2”
2 var v1, soma : real
3 inicio
4 // Inicializamos SOMA com zero
5 soma <- 0
6 escreval(“Programa para calcular o somatório de três valores.”)
7 escreval
8 escreva(“Digite o primeiro valor:”)
9 leia(v1)
10 soma <- soma + v1
11 escreva(“Digite o segundo valor:”)
12 leia(v1)
13 soma <- soma + v1
14 escreva(“Digite o terceiro valor:”)
15 leia(v1)
16 soma <- soma + v1
17 escreval
18 escreval(“A soma dos valores é :” , soma : 10 : 3 )
19 fimalgoritmo
Várias técnicas são usadas neste algoritmo:
Linha 5: Inicializamos a variável soma com zero, porque vamos utilizá-la para acumular os três valores digitados pelo
usuário. Qual o motivo disso? Lembre-se que quando declaramos uma variável, na verdade estamos reservando uma área
na memória do computador onde seu valor será armazenado. O que estava armazenado aí anteriormente é indeterminado, e
portanto devemos atribuir o valor zero à variável, para termos certeza da exatidão de nosso programa.
Linhas 9, 12 e 15: Lemos a variável v1 três vezes. Sabemos que quando lemos uma variável o valor digitado pelo usuário
é armazenado nela, substituindo o que estava ali anteriormente. Então, como vamos somar os três valores se ao ler o
segundo perdemos o primeiro, e assim por diante? Bem, note que na linha 10 acumulamos o primeiro valor, lido na linha
anterior, na variável soma, e só então lemos a variável v1 uma segunda vez. O primeiro valor então será perdido, mas não
tem problema porque já o utilizamos. A mesma coisa acontece nas linhas 13 e 16.
Linhas 10, 13 e 16: Usamos a palavra acumular várias vezes nesta explicação, mas o que realmente isto significa? Preste
atenção na linha 10: soma <- soma + v1.Ela indica que a variável soma recebe o valor que ela tem no momento
mais o valor da variável v1 no momento. Então, se soma vale 5 em um determinado momento, e v1 vale 3, se a linha 10
for executada, soma receberá 5 (o seu próprio valor agora) mais 3 (o valor de v1), ou seja, 8. Na prática o que foi feito foi
acrescentar à variável soma o valor de v1, e daí vem o termo acumular. Esta técnica é usada com muita freqüência em
programação, e você deverá estar bastante familiarizado com ela.
Realizando um teste de mesa
Para terminar, vamos estudar uma técnica que nos permitirá testar a exatidão de algoritmos, simulando o seu
funcionamento no computador. Alguns autores denominam a técnica de “teste de mesa”, e alguns programadores a
chamam informalmente de “rodar o chinês” (de donde vem esta expressão, ninguém sabe). Em um programa simples como
o que estamos analisando ela pode parecer um exagero, mas em outros mais complexos ela com certeza mostrará sua
utilidade.
Para “rodarmos o chinês” precisamos de um conjunto de dados de teste; este nome bonito significa que vamos supor o que
o usuário digitará quando utilizar o programa. No nosso caso, vamos assumir que ele digitará 10, 3 e 9 (nesta ordem)
quando o programa pedir. Então, nossos dados de teste são 10, 13 e 9. Depois, construimos uma espécie de planilha onde a
primeira coluna representa a linha de programa sendo executada e cada uma das outras representa uma variável.
Começamos então a simular a execução do programa, linha por linha. À medida em que um comando leia é executado
ou que uma atribuição é feita, escrevemos na coluna correspondente à variável o valor digitado ou calculado, naturalmente
“apagando” o valor que havia lá anteriormente. Se precisarmos do valor da variável para um cálculo ou para escrever na
tela, vamos de novo à coluna daquela variável e pegamos o último valor gravado, que é o seu valor atual.
A planilha para este algoritmo inicialmente ficará assim:
Linha SOMA V1
2 ? ?
Na linha 2 as variáveis foram declaradas, mas o seu valor é desconhecido. Ao se executar a linha 5, soma receberá 0, e a
planilha ficará assim (note que o valor de v1 não foi alterado, e continua indeterminado):
Linha SOMA V1
2 ? ?
5 0
Na linha 9, o usuário vai digitar o primeiro valor (10, segundo nossos dados de teste). A planilha então ficará assim:
Linha SOMA V1
2 ? ?
5 0
9 10
Neste ponto vale lembrar que embora haja mais de um valor nas colunas SOMA e V1, o que vale é sempre o último,
porque este é o valor da variável no momento. Quando a linha 10 é executada, soma receberá o seu valor no momento,
que é 0, mais 10, que é o valor de v1. Então, a planilha ficará assim:
Linha SOMA V1
2 ? ?
5 0
9 10
10 10
Quando as linhas 12 e 13 forem executadas, o usuário digitará 13 e este valor será acumulado em soma.
Linha SOMA V1
2 ? ?
5 0
9 10
10 10
12 13
13 23
Depois da execução das linhas 15 e 16, teremos os seguintes valores na planilha:
Linha SOMA V1
2 ? ?
5 0
9 10
10 10
12 13
13 23
15 9
16 32
Ao executar a linha 18, o computador exibirá o valor atual da variável soma, que é 32.
Esta é a técnica básica para se executar um teste de mesa. Saber interpretar um algoritmo é quase tão importante como
fazê-lo. Aliás, uma grande parte do trabalho de um programador é analisar algoritmos, para descobrir erros de lógica, para
entender o que um outro programador (que geralmente está de férias…) estava pensando ao criar um programa, ou até
mesmo para refrescar a memória revendo um algoritmo que ele mesmo fez.
O algoritmo que criamos é razoavelmente eficiente para somar três valores, mas e se tivéssemor que somar 30 valores?
Certamente poderíamos repetir as linhas 14, 15 e 16 um número qualquer de vezes para ler tantos valores quantos fossem
necessários, mas qual a eficiência disso?
Analisando o algoritmo, vemos que as linhas 8, 9 e 10 são quase iguais às linhas 11, 12 e 13 e 14, 15 e 16. Se pudermos
escrever estas três linhas (8, 9 e 10) uma só vez e pedir ao computador para executá-las 30 vezes poderemos ler os 30
valores com um algoritmo compacto e eficiente. É ai que entram os comandos de repetição.
Os comandos de repetição, também chamados de “loops”, laços ou malhas, são estruturas que delimitam um ou mais
comandos e podem fazer com que eles sejam executados repetidamente um certo número de vezes. Existem três comandos
deste tipo, e vamos começar pelo mais simples.
O comando para … faça
O comando para…faca (aasim mesmo, sem cedilha) faz com que um bloco de comandos seja executado certo número
de vezes. Este número de vezes é controlado por uma variável do tipo inteiro que fica contando quantas repetições já
aconteceram. Assim que a quantidade desejada é atingida, as repetições param e o programa continua a partir do primeiro
comando depois fim do bloco delimitado pelo para…faca. Vamos refazer o algoritmo anterior usando um comando
para…faca, e depois vamos realizar um teste de mesa.
1 algoritmo “somatorio3”
2 var v1, soma : real
3 j : inteiro
4 inicio
5 // Inicializamos SOMA com zero
6 soma <- 0
7 escreval(“Programa para calcular o somatório de três valores.”)
8 escreval
9 para j de 1 ate 3 faca
10 escreva(“Digite um valor:”)
11 leia(v1)
12 soma <- soma + v1
13 fimpara
14 escreval
15 escreval(“A soma dos valores é :” , soma : 10 : 3 )
16 fimalgoritmo
Logo de início notamos que o programa ficou um pouco menor, e que uma variável do tipo inteiro foi criada (é ela quem
vai controlar o número de repetições). Os comandos que serão repetidos estão nas linhas 10, 11 e 12, e são delimitados
pelos comandos para…faca e fimpara. Note que eles estão indentados; isto não é obrigatório e também não
influência na execução do programa, mas é uma boa prática pois dá uma indicação visual dos comandos que serão
repetidos.
O que significa a linha para j de 1 ate 3 faca ?
Quando esta linha é executada, a variável j recebe o valor 1 (chamado valor inicial), e este valor é comparado com 3
(chamado valor final). Se o valor inicial for menor ou igual ao valor final, uma repetição será executada até que se chegue
ao fimpara. Não ache estranha esta primeira comparação; o valor inicial pode ser maior que o final às vezes, como você
poderá ver…
Quando o programa atinge o comando fimpara na linha 13, a variável j é incrementada em um, passando então a valer
2, e novamente comparado ao valor final. Se for menor ou igual a ele, mais uma repetição será executada, começando na
linha 10. No nosso caso, 2 é menor que 3, e então temos mais uma repetição. Ao atingir a linha 13 novamente, j será
incrementado de novo, passando a ter o valor 3, e nova comparação com o valor final será feita. Naturalmente, como 3 é
igual a 3, outra repetição será executada a partir da linha 10. Bem, quando o programa executar a linha 13 de novo, j
passará a valer 4 (que não é menor ou igual a 3); então não haverá nova repetição, e o programa continuará da linha 14 em
diante. Se você prestar atenção, verá que houve três repetições, com j valendo 1, 2 e 3. Quando o valor de j atingiu 4, ele
ultrapassou o valor final, e cessaram as repetições.
Realizando o teste de mesa com os mesmos dados de teste do algoritmo anterior, teremos o seguinte resultado:
Linha V1 SOMA J Comentário
2 e 3 ? ? ? Declaração das variáveis
6 0 Inicialização de SOMA
9 1Início do comando para..faca
11 10 Primeira leitura de V1
12 10 Acumula V1 em SOMA
13 2 Comando fimpara. J é incrementado em 1
11 13 Segunda leitura de V1
12 23 Acumula V1 em SOMA
13 3 Comando fimpara. J é incrementado em 1
11 9 Terceira leitura de V1
12 32 Acumula V1 em SOMA
13 4 Comando fimpara. J é incrementado em 1 (fim das repetições)
É importante notar que a função da variável j é apenas contar o número de repetições; por isso, não se deve modificar o
seu valor diretamente dentro de um loop, seja por atribuição ou leitura. Deixe que o comando para..faca cuide dela.
Isto não nos impede, no entanto, de usar o valor de J se for interessante. Analise o algoritmo abaixo e veja o que acontece…
algoritmo “somatorio4”
var v1, soma : real
j : inteiro
inicio
// Inicializamos SOMA com zero
soma <- 0
escreval(“Programa para calcular o somatório de três valores.”)
escreval
para j de 1 ate 3 faca
escreva(“Digite o “, j , “o. valor:”)
leia(v1)
soma <- soma + v1
fimpara
escreval
escreval(“A soma dos valores é :” , soma : 10 : 3 )
fimalgoritmo
Você deve ter entendido a utilidade do para…faca agora. Se quisermos fazer com que o programa leia 30 valores,
basta mudar o 3 por 30 (ou 50, 500…) no comando de repetição, e o mesmo programa passará a ler a quantidade de valores
desejada. Isto nos traz a uma “limitação” deste comando. Ele só pode ser utilizado quando soubermos exatamente quantas
vezes o laço vai ser executado, no momento em que estivermos criando o algoritmo (como no exemplo acima), ou no
momento em que ele estiver sendo executado. Veja o exemplo a seguir:
algoritmo “somatorio5”
var v1, soma : real
qtde, j : inteiro
inicio
// Inicializamos SOMA com zero
soma <- 0
escreval(“Programa para calcular o somatório de uma série de valores.”)
escreval
escreva(“Quantos números você quer somar?”)
leia(qtde)
para j de 1 ate qtde faca
escreva(“Digite o “, j , “o. valor:”)
leia(v1)
soma <- soma + v1
fimpara
escreval
escreval(“A soma dos valores é :” , soma : 10 : 3 )
fimalgoritmo
Problema 12 – Escrever os pares de 2 a 20
Faça um programa que escreva os números pares de 2 a 20, inclusive, usando um comando para…faca..
Análise
Quem não sabe quais são os pares de 2 a 20? São 2, 4, 6, 8, …, 16, 18, 20. Isto é fácil, mas como usar um comando de
repetição para escrevê-los? Bem, todo número par é o dobro de um outro número, não é? Se pensarmos assim, veremos que
1 * 2 = 2, 2 * 2 = 4, 3 * 2 = 6, … , 9 * 2 = 18 e 10 * 2 = 20. Sendo assim, podemos fazer com que a variável de controle
varie entre 1 e 10, e a cada repetição escreveremos o seu dobro. O programa ficará assim:
algoritmo “pares1”
var j : inteiro
inicio
escreval(“Programa para escrever os números pares entre 2 e 20.”)
para j de 1 ate 10 faca
// Para cada valor de j, escreva o seu dobro.
escreval( j * 2 )
fimpara
fimalgoritmo
Esta solução está correta, mas há outras. Aliás, explorar outras soluções para um problema mesmo depois de já tê-lo
resolvido é um ótimo exercício. Por exemplo, não seria ótimo se j fosse incrementado de 2 em 2 ao invés de 1 em 1? Se
pudéssemos fazer isto, começaríamos com ele valendo 2, e de 2 em 2 escreveríamos os pares ate 20. A boa notícia é que
podemos fazer isto! O comando para..faca permite que se especifique o passo de incremento, ou seja, quanto será
somado à variável de controle no fim de cada repetição. Este valor pode ser qualquer inteiro diferente de zero, e pode ser
negativo ou positivo. Vamos explorar esta possibilidade:
algoritmo “pares2”
var j : inteiro
inicio
escreval(“Programa para escrever os números pares entre 2 e 20.”)
// Usando passo 2, faremos com que j só assuma valores pares
para j de 2 ate 20 passo 2 faca
escreval( j )
fimpara
fimalgoritmo
Como j é incrementado em 2 a cada repetição, de 2 ele passa para 4, 6, 8, etc., até chegar a 20.
Apresentaremos agora uma outra solução, menos eficiente que as duas anteriores, mas que serve para ilustrar vários
conceitos. Podemos gerar todos os números entre 2 e 20, mas só imprimir os pares. Mas como saber se um número é par?
No capítulo 2 estudamos o operador MOD, que fornece o resto da divisão inteira entre dois números. Sabemos que o resto
da divisão de todo par por 2 é 0, e de todo ímpar é 1, não é mesmo? Então, para cada valor de j testaremos j mod 2 e se
o resultado for zero imprimiremos o número, porque ele é par. O algoritmo ficará assim:
algoritmo “pares3”
var j : inteiro
inicio
escreval(“Programa para escrever os números pares entre 2 e 20.”)
para j de 2 ate 20 faca
se j mod 2 = 0 entao
escreval( j )
fimse
fimpara
fimalgoritmo

Deixe uma resposta

Preencha os seus dados abaixo ou clique em um ícone para log in:

Logotipo do WordPress.com

Você está comentando utilizando sua conta WordPress.com. Sair / Alterar )

Imagem do Twitter

Você está comentando utilizando sua conta Twitter. Sair / Alterar )

Foto do Facebook

Você está comentando utilizando sua conta Facebook. Sair / Alterar )

Foto do Google+

Você está comentando utilizando sua conta Google+. Sair / Alterar )

Conectando a %s

%d blogueiros gostam disto: