Algoritmos

maio 21, 2007

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

Anúncios

Iniciando em Bash – Condicionais, Loops, Funções, Debugando Scripts

maio 21, 2007

Introdução

É necessário aquele #!/bin/bash no início dos scripts? Não é obrigatório, mas é aconselhável, o script até consegue executar sem isso. Esta linha serve para duas coisas:

  • Definir o tipo do arquivo, se você executar:
file arquivo.sh

Ele irá retornar o seguinte:

arquivo.sh: Bourne-Again shell script text executable
  • Definir o tipo de shell que o script irá utilizar, no caso bash, mas poderia ser sh,ksh,etc..

Condicionais

A princípio veremos apenas o uso do if, com textos, números ou variáveis

IF … THEN

A sintaxe do IF no bash é um pouco diferente do que acontece nas outras linguagens, (apesar de bash não ser considerado uma linguaguem, porque ele é apenas interpretado e não compilado)

A sintaxe mais simples do IF no bash é a seguinte:

if [ variavel1 COMPARACAO variavel2 ]; then
   comandos
fi

ATENÇÃO Não se esqueça do espaço depois do “[” e antes do “]”, deixar eles encostados com as variáveis causa problemas.

PRINCIPAIS OPERADORES

Para Strings

[-n] STRING
     Tamanho da String é diferente de zero
-z STRING
     Tamanho da String é zero
STRING1 = STRING2
     Strings são iguais
STRING1 != STRING2
     Strings não são iguais

Para numeros [inteiros]

NUMERO1 -eq NUMERO2
     NUMERO1 igual a NUMERO2

NUMERO1 -ge NUMERO2
     NUMERO1 igual e/ou mair que NUMERO2

NUMERO1 -gt NUMERO2
     NUMERO1 maior que NUMERO2

NUMERO1 -le NUMERO2
     NUMERO1 menor e/ou igual a NUMERO2

NUMERO1 -lt NUMERO2
     NUMERO1 menor que NUMERO2

NUMERO1 -ne NUMERO2
     NUMERO1 diferente de NUMERO2

Exemplos

Exemplo 1 – comparando strings

if [ “texto” = “texto” ]; then
echo “o texto é igual”;
fi
Exemplo 2 – comparandos números

if [ 1 -gt 5 ]; then
echo “1 é maior que 5”;
fi
Simples não é? Basta saber a sintaxe, traduzindo o código para português ficaria:

se [ “texto” igual “texto” ]; então
imprima “o texto é igual”;
fimse

IF … THEN … ELSE

Aqui a sintaxe continua a mesma, mas podemos incluir “mais” condições em nossos IFs

Exemplos

Exemplo 1

if [ "texto" = "texto" ]; then
    echo "o texto é igual";
else
    echo "o texto NÃO é igual";
fi

Exemplo 2

if [ 1 -gt 5 ]; then
    echo "1 é maior que 5";
else
    echo "1 não é maior que 5";
fi

Exemplo 3

Além do else, podemos utilizar o elif (que seria o elseif em outras lingaguens), que serve para criar uma nova condição dentro do if que somente será executada se o if inicial ‘falhar’.

if [ "a" = "3" ] || [ "a" = "b" ]; then
   echo "a não é igual a 3 ou c";
elif [ "a" = "c" ]  || [ "a" = "d" ]; then

   echo "a não é igual a c ou d";
else
   echo "A é diferente de 3,c,b,d";
fi

Exemplo 4

if [ 3 -lt 10 ] && [ 3 -gt 7 ]; then
   echo "3 é menor que 10 e maior que 7";
elif [ 3 -lt 10 ] && [ 3 -gt 5 ]; then
   echo "3 é menor que 10 e maior que 5";
else

   echo "3 é menor que 10 e menor que 5";
fi


Loops – While, For, Until

While

O exemplo abaixo é apenas um contador, mas você pode utilizar o while em outras condições, por exemplo, ficar executando comandos enquanto a expressão for verdadeira.

#!/bin/bash 
CONTADOR=0
while [  $CONTADOR -lt 10 ]; do
      echo "Contador em: $CONTADOR";
      let CONTADOR=CONTADOR+1; 
done

Traduzindo

enquanto [ $CONTADOR menor que 10 ]; faça
   imprima "Contador em: $CONTADOR";
   imcremente 1 no $CONTADOR;
feito

For

O exemplo abaixo pode ser útil em várias ocasiões

#!/bin/bash
for i in $( ls ); do
  echo item: $i
done

Neste caso ele irá executar o comando ls, pegará seu resultado, e imprimirá na tela arquivo por arquivo, a saída seria algo do tipo:

item: 12dicts-4.0.zip
item: aim
item: aim-proto.zip
item: c++
item: chec.pl
item: concurso
item: d2_backup.sh
item: d2.sh
item: Desktop
item: docs
item: dsniff-2.3
item: dsniff-2.3.tar.gz

item: Firefox_wallpaper.png
item: fotos
item: fwgen.sh
item: gbox_applet-0.7.4
item: gbox_applet-0.7.4.tar.gz
item: hacked.jpg
item: hlbr-0.1-final
item: hlbr-0.1-final.tar.gz
item: IA
item: MHear-1.0
item: IMHear-1.0.tar.gz
item: InThisWorld
item: libicq-0.33
item: libicq-0.33.tar.gz
item: libnet
item: libnet.tar.gz
item: libnids-1.20
item: libnids-1.20.tar.gz
item: logs
item: mbox

item: MD5SUMS
item: NVIDIA-Linux-x86_64-1.0-8178-pkg2.run
item: openssh-2.2.0-exp.tgz
item: ossec-hids-0.6.tar.gz
item: password
item: propostas
item: resultados
item: resultados.txt
item: root

item: Screenshot1.png
item: senhas_descobertas
item: SHA1SUMS
item: sniffex
item: sniffex.c
item: sorteios.sh
item: ssh-brute.sh
item: wordlist
item: wordlist.php

Until

O until é praticamente igual ao while, se você traduzir, while = enquanto, until = até que. Veja o exemplo:

#!/bin/bash 
CONTADOR=20
until [  $CONTADOR -lt 10 ]; do
       echo CONTADOR $CONTADOR
       let CONTADOR-=1
done

Traduzindo

CONTADOR=20
até que [ $CONTADOR menor 10 ]; faça
   imprimita "CONTADOR $CONTADOR"
   decremente 1 do CONTADOR
feito

O script será executado até o momento que o contador chegar a ter um valor menor que 10, veja a seção abaixo, Debugando Scripts.

Debugando Scripts

Esta é uma dica que muita gente não conhece, mas que é muito útil para encontrar erros em scripts bash, principalmente aqueles beeeeem longos em que ficar dando echo na tela se torna inviável:

Como exemplo vou utilizar o último exemplo do until:

#!/bin/bash 
CONTADOR=20
until [  $CONTADOR -lt 10 ]; do
       echo CONTADOR $CONTADOR
       let CONTADOR-=1
done

Para debugar o script você faz o seguinte:

bash -x arquivo.sh

No nosso caso a saída deve ser:

+ CONTADOR=20
+ '[' 20 -lt 10 ']'
+ echo CONTADOR 20
CONTADOR 20
+ let CONTADOR-=1
+ '[' 19 -lt 10 ']'
+ echo CONTADOR 19
CONTADOR 19
+ let CONTADOR-=1
+ '[' 18 -lt 10 ']'

+ echo CONTADOR 18
CONTADOR 18
+ let CONTADOR-=1
+ '[' 17 -lt 10 ']'
+ echo CONTADOR 17
CONTADOR 17
+ let CONTADOR-=1
+ '[' 16 -lt 10 ']'
+ echo CONTADOR 16
CONTADOR 16

+ let CONTADOR-=1
+ '[' 15 -lt 10 ']'
+ echo CONTADOR 15
CONTADOR 15
+ let CONTADOR-=1
+ '[' 14 -lt 10 ']'
+ echo CONTADOR 14
CONTADOR 14
+ let CONTADOR-=1
+ '[' 13 -lt 10 ']'

+ echo CONTADOR 13
CONTADOR 13
+ let CONTADOR-=1
+ '[' 12 -lt 10 ']'
+ echo CONTADOR 12
CONTADOR 12
+ let CONTADOR-=1
+ '[' 11 -lt 10 ']'
+ echo CONTADOR 11
CONTADOR 11

+ let CONTADOR-=1
+ '[' 10 -lt 10 ']'
+ echo CONTADOR 10
CONTADOR 10
+ let CONTADOR-=1
+ '[' 9 -lt 10 ']'

Os sinais + indicam as instruções que são executadas internamente, onde não tem o sinal é o echo do script. No nosso caso ele executa o loop até que o contador seja menor que 10 (iniciando de 20 e decrementando 1 em cada loop executado)

Funções

Antes de dar alguns exemplos de funções, precisamos entender para que elas são utilizadas, alguns bons motivos são esses:

  • Facilidade de manutenção
  • Redução do tamanho do script
  • Reutilização

Onde utilizar funções

Um excelente lugar para se utilizar funções é um lugares do script onde o mesmo código é repetido várias vezes. Colocando este código em uma função diminui consideravelmente o tamanho do script, além de facilitar manutenções, já que você só vai precisar alterar o código em um lugar.

Neste artigo vou mostrar apenas a sintaxe de funções e dar alguns simples exemplos, futuramente veremos coisas mais sofisticadas.

Exemplos

Exemplo 1. Neste exemplo teremos 2 funções (quit e hello), a função quit executa apenas o comando exit para sair do script, e a função hello imprime na tela a palavra Hello!

#!/bin/bash 
function quit {
  exit
}
function hello {
   echo Hello!
}
hello
quit

Como podemos ver no exemplo acima, basta utilizar o nome da função para “chamá-la”

Exemplo 2. Este exemplo temos a utilização de parâmetros (no caso 1 só)

#!/bin/bash 
function quit {
  exit
}  
function e {
  echo $1 
}  
e Hello
e World
quit

Neste exemplo estamos executando a função “e”, duas vezes, na primeira com o parâmetro Hello e na segunda com World, em seguida a função quit é executada e o script termina.

O $1 indica que o primeiro parâmetro passado para a função será utilizado no lugar de $1, no caso, imprimindo Hello e depois World


Introdução a Shell Script

maio 21, 2007

CyberPunk – cyberpunk@matrix.mailbr.com.br – Criou este artigo bem bacana sobre básico em programação Shell Script. Confiram.

ShellScript é uma linguagem de programação de Scripts do Linux. É bastante util para tarefas repetitivas e pode quebrar o galho legal.

O script é .sh e para que ele seja executado, mude a permissão do script com o commando

$ chmod +x arquivo.sh

O Script começa com a seguinte linha, para indicar que tipo de shel o script irá usar:

#!/bin/sh

Agora vem os comandos. Voce pode colocar ele para fazer tarefas simples com comandos:

#!/bin/sh
echo "Estou no diretorio" pwd /* pwd mostra o diretorio atual */
echo "Arquivos no meu diretorio" ls -l /* ls -l lista arquivos e detalhes */

Este é exemplo serve para demonstrar como os comandos são aplicados.

Com ShellScript voce pode atribuir variaveis. Como neste exemplo:

#!/bin/sh
LINUX=$(uname -r) /* uname -r exibe a versão atual do kernel */
echo $LINUX

Este script fará com que seja exibida a versão do kernel do sistema atual.

Vamos usar agora o esqueminha de condições (if, then, else). Observe este script traduzido para portugues:

  • Portugues

escrever “Digite seu nome” ler nome se [ $nome = tux ] ; faça escrever “O nome é tux”; senão escrever “O nome não é tux”;

  • ShellScript
#!/bin/sh

echo "Digite seu nome"
read nome
if [ $nome = tux ]; then
echo "O nome é tux";
else
echo "O nome não é tux";
fi

Bom, agora vamos conhecer um pouco do sisteminha de menu, bem simplizinho, usando o case in . Preste atenção neste exemplo, que fica facil de entender:

#!/bin/sh
clear
echo "Bem vindo ao meu Script"
echo "Escolha uma das opções abaixo"
echo
echo "[1] Listar as portas do seu computador"
echo "[2] Listar os arquivos do diretorio atual"

echo "[3] Sair"
echo -n "Digite a opção: "
read opcao
case $opcao in
1) nmap -sS localhost
sleep 3
;;
2) ls -l
sleep 3
;;
3) exit
clear
;;

Eh, deu p/ entender né? É facil. E pode ficar mais legal ainda se o menu executasse um loop depois que voce executasse a opção. Porque aí voce percebeu que depois que voce executou a opção escolhida o programa termina. Agora vamos aplicar o while do. Veja como fica. Vamos comentar para que voce possa entender melhor:

#!/bin/sh
while : /* Aqui inicia a repetição, com o
'while :' */
do
clear
echo "Este e meu Script Beta 0.1"
echo "Escolha uma das opções abaixo"
echo
echo "[1] Listar as portas do seu computador"

echo "[2] Listar os arquivos do diretorio atual"
echo "[3] Sair"
echo -n "Digite a opção: "
read opcao
case $opcao in
1) nmap -sS localhost
sleep 3
;;
2) ls -l

sleep 3
;;
3) exit
clear
;;
esac /* Bem, aqui termina a repetição */
done

Entendeu como funciona né? Não é tão dificil. O Básico é isso aí. Agora para voce melhorar seus scripts use awk, grep, cut, du, date e outros. Valeu =;)


Perl – Manual Básico

maio 21, 2007

IntroduçãoO objetivo desta documentação é introduzir o leitor na criação e execução de scripts em Perl em ambiente UNIX. Perl significa “Practical Extraction and Report Language” e foi originalmente desenvolvida para realizar tarefas de administração de sistema. O objetivo principal da linguagem é facilitar a extração de dados e emitir relatórios. Pode-se usar o Perl em tarefas relacionadas a relatório de informações sobre sistema ou pesquisa em arquivos de texto. O Perl é uma linguagem “interpiler”. Isto significa que um programa em Perl é primeiro compilado e em seguida interpretado (não gera código executável). Entretanto, é possível encontrar um compilador de Perl a partir da versão 5.005.

Programando

Para verificar qual o número da versão da linguagem Perl instalada, digite:

$ perl -v

Vejamos agora um exemplo simples de um script feito em Perl.

# arquivo: teste1.pl
print "Meu primeiro Script Perln";


Variáveis Matrizes

Uma matriz (ou vetor ou lista) é simplesmente um conjunto ordenado de valores escalares, texto ou números, ou ambos. Uma variável de matriz é indicada pelo símbolo @. Veja o exemplo abaixo.

# arquivo: teste5.pl
@teste = (1, 2, 3, “oi”);
print “@testen”;O script acima imprime

1 2 3 oiPara imprimir um elemento da matriz por linha, digite

# arquivo: teste6.pl
@teste = (1, 2, 3, “oi”);
print “teste[0] = @teste[0]n”;
print “teste[1] = @teste[1]n”;
print “teste[2] = @teste[2]n”;
print “teste[3] = @teste[3]n”;A execução do script acima mostra

teste[0] = 1
teste[1] = 2
teste[2] = 3
teste[3] = oiNote que a contagem dos índices da matriz começa com zero. Assim, o índice 1 representa o segundo elemento da matriz. É possível que um elemento da lista seja uma outra lista. Veja o exemplo abaixo.

# arquivo: teste7.pl
@lista1 = (1, 2, 3, “oi”);
@lista2 = (“a”, “b”, @lista1, “c”);
print “@lista1 = @lista1n”;
print “@lista2 = @lista2n”;A saída correspondente ao script teste7.pl é

@lista1 = 1 2 3 oi
@lista2 = a b 1 2 3 oi cPara acrescentar um ou mais elementos a lista, pode-se usar o comando push. Para remover o último elemento da lista usa-se o comando pop. A seguir temos um exemplo do uso destes dois comandos.

# arquivo: teste8.pl
@lista = (1, 2, 3);
print “1 – @lista = @listan”;
# acrescenta um item a @lista
push(@lista, “a”);
print “2 – @lista = @listan”;
# acrescenta vários itens a @lista
push(@lista, “b”, “c”, “d”);
print “3 – @lista = @listan”;
# acrescenta lista2 a @lista
@lista2 = (“e”, “f”);
push(@lista, @lista2);
print “4 – @lista = @listan”;
# remove o último elemento de @lista
pop(@lista);
print “5 – @lista = @listan”;
print ” @lista2 = @lista2n”;
# remove o último elemento de @lista e o armazena em $var
$var = pop(@lista);
print “6 – @lista = @listan”;
print ” $var = $varn”;A execução do script teste8.pl mostra a seguinte saída

1 – @lista = 1 2 3
2 – @lista = 1 2 3 a
3 – @lista = 1 2 3 a b c d
4 – @lista = 1 2 3 a b c d e f
5 – @lista = 1 2 3 a b c d e
@lista2 = e f
6 – @lista = 1 2 3 a b c d
$var = ePara determinar o número de elementos de uma matriz, basta atribuir (=) a matriz a uma variável escalar. Para determinar o índice do último elemento da matriz, pode-se usar $#nome_matriz. Naturalmente, temos que o número de elementos de uma matriz é igual ao índice do último elemento da matriz mais 1, pois o índice do primeiro elemento é zero. O script teste9.pl mostra um exemplo onde é apresentado o número de elementos e o índice do último elemento de uma matriz.

# arquivo: teste9.pl
@teste = (“a”, “b”, “c”);
$var = @teste;
print “@teste = @testen”;
print “número de elementos = $varn”;
print “índice do último elemento = $#testen”;A saída da execução do script acima é

@teste = a b c
número de elementos = 3
índice do último elemento = 2Existem outras operações interessantes que podemos fazer com as matrizes. A seguir, o script teste10.pl nos fornece alguns exemplos.

# arquivo: teste10.pl
@teste = (“a”, “b”, “c”, “d”, “e”);
print “@teste = @testen”;
# transforma a matriz em uma string com um espaço entre cada elemento
$var = “@teste”;
print “$var = $varn”;
# transforma a matriz em uma string com um * entre cada elemento
$” = ” * “;
$var = “@teste”;
print “$var = $varn”;
$” = ” “;
# $var1 recebe o primeiro elemento da matriz, enquanto que
# $var2 recebe o segundo elemento da matriz
($var1, $var2) = @teste;
print “$var1 = $var1n”;
print “$var2 = $var2n”;
# $var recebe o primeiro elemento da matriz, enquanto que
# @teste2 recebe os outros elementos da matriz
($var, @teste2) = @teste;
print “$var = $varn”;
print “$teste2 = @teste2n”;A saída correspondente à execução do script teste10.pl é mostrada abaixo.

@teste = a b c d e
$var = a b c d e
$var = a * b * c * d * e
$var1 = a
$var2 = b
$var = a
$teste2 = b c d eComo observação final, note que nos exemplos acima não especificamos o número de elementos na definição de uma variável matriz. Isto se deve ao fato deste tipo de estrutura ser dinâmico, ou seja, as matrizes crescem e diminuem de tamanho automaticamente para se ajustarem às definições do programador. As matrizes associativas, que veremos a seguir, também possuem esta característica. O perl usa o símbolo # como marca de comentário. Toda linha que começa com # é ignorada a partir do símbolo #. A instrução print é usada para imprimir dados em um script. O n significa uma nova linha. Note que o comando print termina com um ponto-e-vírgula. Digite os dados acima em um arquivo e salve-o como teste1.pl. Para executá-lo, digite na linha de comando

perl teste1.plCaso ocorra algum erro na execução do programa, você pode executar o programa com a depuração, basta digitar

perl -d teste1.plEntrando no depurador do Perl, basta digitar s para executar linha a linha. Para sair do depurador, e portanto cancelar a execução, basta digitar q. Digite h para ver outros comandos do depurador.

É também possível fornecer apenas o nome do script para executar um arquivo. Entretanto, precisamos introduzir duas alterações:

a) O script tem de ter permissão de execução. Para isto, digite na linha de comando

chmod u+x teste1.plO comando chmod é usado para alterar as permissões de acesso aos arquivos. O parâmetro u especifica que a autorização é para o dono do arquivo, o operador + manda adicionar esta nova permissão às permissões já existentes, e o parâmetro x especifica que a permissão é de execução.

b) Devemos especificar no script a localização do Perl. Para isto, deve-se adicionar no início do script (primeira linha) o seguinte

#!/usr/bin/perlA linha acima informa ao sistema para procurar o programa /usr/bin/perl e transmitir o resto do arquivo a esse programa. Note que o diretório onde se encontra o Perl varia de sistema para sistema. O diretório acima é válido para o Conectiva Linux 4.0.

Agora, para executar o programa, basta digitar na linha de comandos

# teste1.plVocê também pode especificar um pequeno script diretamente na linha de comandos. Por exemplo, digite

# perl -e ‘print “Teste de linha de comandosn”‘

Variáveis

As variáveis Perl permitem o armazenamento de texto, números ou listas de ambos e são de três tipos: escalares, matrizes e matrizes associativas.

Os nomes das variáveis Perl consistem de números, letras e o símbolo undescore (‘_’). É importante observar que o Perl é case sensitive, i.e., o Perl diferencia letras maiúsculas e minúsculas.

Variáveis Escalares

As variáveis escalares assumem um valor único, seja uma string de texto ou um número. Pode-se alternar, ajustando uma variável string para assumir um número e vice-versa.

As variáveis do tipo escalar são indicadas pelo símbolo $ antes do nome. Por exemplo, vejamos agora o script teste2.pl que recebe o nome do usuário, armazena-o na variável $nome e depois mostra o conteúdo da variável na tela.

# arquivo: teste2.pl
print "Digite o seu nome: n";
$nome = ;
print "Bom dia, $nomen";

O comando do exemplo acima recebe dados da entrada padrão (normalmente o teclado).

São exemplos de operações numéricas que podem ser definidas com as variáveis escalares: atribuição (=, +=, -=), soma (+), subtração (-), multiplicação (*), divisão (/), resto de divisão (%), expoente (**), incremento (++) e decremento (–). O script abaixo mostra um exemplo destas operações usando três variáveis: $var1,$var2 e $var3.

# arquivo: teste3.pl
$var1 = 200;
$var2 = 30;
print "nAtribuiçãon";
print "$var1 = $var1n";
print "$var2 = $var2n";
# soma variáveis $var1 e $var2 e armazena resultado em $var3

$var3 = $var1 + $var2;
print "nSoman";
print "$var1 = $var1n";
print "$var2 = $var2n";
print "$var3 = $var3n";
# subtrai $var1 de $var2 e armazena resultado em $var3

$var3 = $var2 - $var1;
print "nSubtraçãon";
print "$var1 = $var1n";
print "$var2 = $var2n";
print "$var3 = $var3n";
# divide $var1 por $var2 e armazena resultado em $var3

$var3 = $var1 / $var2;
# multiplica $var1 por $var2 e armazena resultado em $var3
$var3 = $var1 * $var2;
print "nMultiplicaçãon";
print "$var1 = $var1n";
print "$var2 = $var2n";

print "$var3 = $var3n";
print "nDivisãon";
print "$var1 = $var1n";
print "$var2 = $var2n";
print "$var3 = $var3n";
# calcula $var2 elevado a 2 e armazena resultado em $var3

$var3 = $var2 ** 2;
print "nExpoenten";
print "$var1 = $var1n";
print "$var2 = $var2n";
print "$var3 = $var3n";
# divide $var1 por $var2 e armazena o resto da divisão em $var3

$var3 = $var1 % $var2;
print "nResto de Divisãon";
print "$var1 = $var1n";
print "$var2 = $var2n";
print "$var3 = $var3n";
# incrementa $var1 e armazena valor de $var1 em $var3

$var3 = ++$var1;
print "nIncrementa primeiron";
print "$var1 = $var1n";
print "$var2 = $var2n";
print "$var3 = $var3n";
# armazena valor de $var1 em $var3 e depois incrementa valor de $var1

$var3 = $var1++;
print "nIncrementa depoisn";
print "$var1 = $var1n";
print "$var2 = $var2n";
print "$var3 = $var3n";
# decrementa $var2 e armazena valor de $var2 em $var3

$var3 = --$var2;
print "nDecrementa primeiron";
print "$var1 = $var1n";
print "$var2 = $var2n";
print "$var3 = $var3n";
# armazena valor de $var2 em $var3 e depois decrementa valor de $var1

$var3 = $var2--;
print "nDecrementa depoisn";
print "$var1 = $var1n";
print "$var2 = $var2n";
print "$var3 = $var3n";

Note que no início do string de alguns comandos print do exemplo acima usamos “” antes do símbolo $, isto indica que o Perl deve tratar $ como um símbolo qualquer, sem nenhum significado especial. Portanto, $ será apenas impresso na tela e não será interpretado pelo Perl. O resultado da execução do teste3.pl é

  • Atribuição
$var1 = 200
$var2 = 30
  • Soma
$var1 = 200
$var2 = 30
$var3 = 230
  • Subtração
$var1 = 200
$var2 = 30
$var3 = -170
  • Multiplicação
$var1 = 200
$var2 = 30
$var3 = 6000
  • Divisão
$var1 = 200
$var2 = 30
$var3 = 6.66666666666667
  • Expoente
$var1 = 200
$var2 = 30
$var3 = 900
  • Resto de Divisão
$var1 = 200
$var2 = 30
$var3 = 20
  • Incrementa primeiro
$var1 = 201
$var2 = 30
$var3 = 201
  • Incrementa depois
$var1 = 202
$var2 = 30
$var3 = 201
  • Decrementa primeiro
$var1 = 202
$var2 = 29
$var3 = 29
  • Decrementa depois
$var1 = 202
$var2 = 28
$var3 = 29

São exemplos de operações com caracteres que podem ser definidas com as variáveis escalares: atribuição (=), concatenação (.) e repetição (x). O script abaixo mostra um exemplo destas operações.

# arquivo: teste4.pl
$var1 = 'Universidade';
$var2 = 'Castelo Branco';
# junta os strings de $var1 e $var2 e armazena o resultado em $var3
$var3 = $var1 . $var2;
print "$var1 = $var1n";

print "$var2 = $var2n";
print "$var3 = $var3n";
# adiciona um espaço em branco entre os valores de $var1 e $var2
$var3 = $var1 . ' ' . $var2;
print "$var3 = $var3n";

# imprime conteúdo das variáveis sem precisar concatenar
print "$var1 $var2n";
# repete o conteúdo de $var1 2 vezes
$num = 2;
$var3 = $var1 x $num;
print "$var3 = $var3n";
# adiciona espaço ao final de $var2 e depois repete o conteúdo 3 vezes

$var3 = $var2 . ' ';
$var3 = $var3 x 3;
print "$var3 = $var3n";

O resultado do script acima é

$var1 = Universidade
$var2 = Castelo Branco
$var3 = UniversidadeCastelo Branco
$var3 = Universidade Castelo Branco
Universidade Castelo Branco
$var3 = UniversidadeUniversidade
$var3 = Castelo Branco Castelo Branco Castelo Branco

Para ver outros operadores que podem ser usados com as variáveis escalares, digite na linha de comandos

# man perlop


Variáveis Matrizes

Uma matriz (ou vetor ou lista) é simplesmente um conjunto ordenado de valores escalares, texto ou números, ou ambos. Uma variável de matriz é indicada pelo símbolo @. Veja o exemplo abaixo.

# arquivo: teste5.pl
@teste = (1, 2, 3, “oi”);
print “@testen”;O script acima imprime

1 2 3 oiPara imprimir um elemento da matriz por linha, digite

# arquivo: teste6.pl
@teste = (1, 2, 3, “oi”);
print “teste[0] = @teste[0]n”;
print “teste[1] = @teste[1]n”;
print “teste[2] = @teste[2]n”;
print “teste[3] = @teste[3]n”;A execução do script acima mostra

teste[0] = 1
teste[1] = 2
teste[2] = 3
teste[3] = oiNote que a contagem dos índices da matriz começa com zero. Assim, o índice 1 representa o segundo elemento da matriz. É possível que um elemento da lista seja uma outra lista. Veja o exemplo abaixo.

# arquivo: teste7.pl
@lista1 = (1, 2, 3, “oi”);
@lista2 = (“a”, “b”, @lista1, “c”);
print “@lista1 = @lista1n”;
print “@lista2 = @lista2n”;A saída correspondente ao script teste7.pl é

@lista1 = 1 2 3 oi
@lista2 = a b 1 2 3 oi cPara acrescentar um ou mais elementos a lista, pode-se usar o comando push. Para remover o último elemento da lista usa-se o comando pop. A seguir temos um exemplo do uso destes dois comandos.

# arquivo: teste8.pl
@lista = (1, 2, 3);
print “1 – @lista = @listan”;
# acrescenta um item a @lista
push(@lista, “a”);
print “2 – @lista = @listan”;
# acrescenta vários itens a @lista
push(@lista, “b”, “c”, “d”);
print “3 – @lista = @listan”;
# acrescenta lista2 a @lista
@lista2 = (“e”, “f”);
push(@lista, @lista2);
print “4 – @lista = @listan”;
# remove o último elemento de @lista
pop(@lista);
print “5 – @lista = @listan”;
print ” @lista2 = @lista2n”;
# remove o último elemento de @lista e o armazena em $var
$var = pop(@lista);
print “6 – @lista = @listan”;
print ” $var = $varn”;A execução do script teste8.pl mostra a seguinte saída

1 – @lista = 1 2 3
2 – @lista = 1 2 3 a
3 – @lista = 1 2 3 a b c d
4 – @lista = 1 2 3 a b c d e f
5 – @lista = 1 2 3 a b c d e
@lista2 = e f
6 – @lista = 1 2 3 a b c d
$var = ePara determinar o número de elementos de uma matriz, basta atribuir (=) a matriz a uma variável escalar. Para determinar o índice do último elemento da matriz, pode-se usar $#nome_matriz. Naturalmente, temos que o número de elementos de uma matriz é igual ao índice do último elemento da matriz mais 1, pois o índice do primeiro elemento é zero. O script teste9.pl mostra um exemplo onde é apresentado o número de elementos e o índice do último elemento de uma matriz.

# arquivo: teste9.pl
@teste = (“a”, “b”, “c”);
$var = @teste;
print “@teste = @testen”;
print “número de elementos = $varn”;
print “índice do último elemento = $#testen”;A saída da execução do script acima é

@teste = a b c
número de elementos = 3
índice do último elemento = 2Existem outras operações interessantes que podemos fazer com as matrizes. A seguir, o script teste10.pl nos fornece alguns exemplos.

# arquivo: teste10.pl
@teste = (“a”, “b”, “c”, “d”, “e”);
print “@teste = @testen”;
# transforma a matriz em uma string com um espaço entre cada elemento
$var = “@teste”;
print “$var = $varn”;
# transforma a matriz em uma string com um * entre cada elemento
$” = ” * “;
$var = “@teste”;
print “$var = $varn”;
$” = ” “;
# $var1 recebe o primeiro elemento da matriz, enquanto que
# $var2 recebe o segundo elemento da matriz
($var1, $var2) = @teste;
print “$var1 = $var1n”;
print “$var2 = $var2n”;
# $var recebe o primeiro elemento da matriz, enquanto que
# @teste2 recebe os outros elementos da matriz
($var, @teste2) = @teste;
print “$var = $varn”;
print “$teste2 = @teste2n”;A saída correspondente à execução do script teste10.pl é mostrada abaixo.

@teste = a b c d e
$var = a b c d e
$var = a * b * c * d * e
$var1 = a
$var2 = b
$var = a
$teste2 = b c d eComo observação final, note que nos exemplos acima não especificamos o número de elementos na definição de uma variável matriz. Isto se deve ao fato deste tipo de estrutura ser dinâmico, ou seja, as matrizes crescem e diminuem de tamanho automaticamente para se ajustarem às definições do programador. As matrizes associativas, que veremos a seguir, também possuem esta característica.

Matrizes Associativas

Uma matriz associativa corresponde a uma lista onde cada elemento possui dois itens: chave e valor. Uma matriz associativa é definida usando o símbolo % e é acessada usando o símbolo $.

# arquivo: teste11.pl
%nota = ("Ana", 8.5, "João", 9.2,"Pedro", "faltou");
$nome = "Ana";
print "$nome teve nota igual a $nota{$nome}n";
print "João teve nota igual a ";

print $nota{"João"};
print "n";
$nome = "Pedro";
print "$nome $nota{$nome}n";
$nota{"Maria"} = 8.9;
$nome = "Maria";
print "$nome teve nota igual a $nota{$nome}n";

$nota{0} = 8.9;
print "$nota{0} é $nota{0}n";

A execução do programa teste11.pl tem a seguinte saída:

Ana teve nota igual a 8.5
João teve nota igual a 9.2
Pedro faltou
Maria teve nota igual a 8.9
$nota{0} é 8.9

Para apagar uma chave e o seu valor associado, usa-se a função “delete”. Por exemplo, suponha que queremos eliminar a chave “Pedro” do exemplo acima. Então, basta definirmos no programa

delete $nota{"Pedro"};

Para acessar a chave e o valor de cada elemento da matriz associativa pode-se usar a função each. Cada vez que a função é chamada, ela retorna um elemento diferente da matriz.

# arquivo: teste12.pl
%nota = ("Ana", 8.5, "João", 9.2, "Maria", 10.3, "Pedro", "faltou");
while (($aluno, $grau) = each(%nota))
{
print "Nota de $aluno é $graun";

}

A saída de teste12.pl é

Nota de Ana é 8.5
Nota de Pedro é faltou
Nota de Maria é 10.3
Nota de João é 9.2

Note que as informações não foram recuperadas na mesma ordem em que foram armazenadas. Por exemplo, “Pedro” foi a última chave definida no exemplo acima, entretanto, esta é a segunda chave listada. A explicação para isto é simples. Uma matriz associativa é na realidade uma tabela do tipo hash, ou seja, existe uma função (interna do perl) que calcula em cima do valor da chave um índice dentro da tabela onde o elemento é armazenado. A recuperação da informação usando a função “each” é feita de forma sequencial, pecorrendo a tabela, e portanto, diferente da ordem de armazenamento.

Para recuperar a chave ou o valor de um elemento da matriz associativa pode-se usar a estrutura “foreach” junto com os parâmetros “keys” e “values”.

# arquivo: teste13.pl
%nota = ("Ana", 8.5, "João", 9.2, "Maria", 10.3, "Pedro", "faltou");
foreach $aluno (keys %nota)
{
print "Aluno: $alunon";

}
foreach $grau (values %nota)
{
print "nota: $graun";
}

A execução de teste13.pl nos fornece o seguinte resultado:

Aluno: Ana
Aluno: Pedro
Aluno: Maria
Aluno: João
nota: 8.5
nota: faltou
nota: 10.3
nota: 9.2

É possível converter uma matriz associativa em uma matriz comum como mostra o exemplo abaixo.

# arquivo: teste14.pl
%nota = ("Ana", 8.5, "João", 9.2, "Maria", 10.3, "Pedro", "faltou");
@lista = %nota;
print "@listan";

A saída de teste14.pl é

Ana 8.5 Pedro faltou Maria 10.3 João 9.2

O Perl possui uma matriz associativa especial chamada %ENV. Esta matriz guarda as variáveis de ambiente utilizadas pelo UNIX. Para ver o valor dessas variáveis, basta digitar o programa abaixo.

# arquivo: teste15.pl
while (($chave, $valor) = each(%ENV))
{
print "$chave = $valorn";
}


Estruturas de Controle

Operadores

a) Aritméticos

= atribuição
+= atribuição com soma
-= atribuição com subtração
+ soma
- subtração
* multiplicação
/ divisão
% resto de divisão
** expoente
++ incremento
-- decremento

b) Boolenanos (para números)

== igual a
!= diferente de
< menor que
<= menor que ou igual a
> maior que
>= maior que ou igual a
<=> retorna -1 se menor, 0 se igual, 1 se maior

c) Strings

= atribuição
. concatenação
x repetição
eq igual a
ne diferente de
lt menor que
le menor que ou igual a
gt maior que
ge maior que ou igual a
cmp retorna -1 se menor, 0 se igual, 1 se maior

d) Lógicos

&& e (AND lógigo)
|| ou (OR lógico)
! não (NOT lógico)


if

Este comando possui a seguinte estrutura

if (condição)
{
comandos
}
else
{
comandos
}O comando “if” permite testes condicionais, ou seja, um conjunto de comandos só é executado se a condição explicitada for verdadeira. Caso a condição seja falsa, são executados os comandos do “else” (se existir “else”). Além disso, é possível definir “if” dentro de um outro “if” ou dentro de um “else”.

O exemplo abaixo compara o nome fornecido pelo usuário com o nome do usuário que logou no sistema Linux.

# arquivo: teste16.pl
print “Digite o seu nome: n”; # pede que usuário digite nome
$nome = ; # recebe nome via teclado
chomp($nome); # remove caracter Enter
$nome_amb = $ENV{“USER”}; # usuário que logou a máquina
if ($nome ne $nome_amb) # compara nomes
{
print “Você não é usuário autorizadon”;
}
else
{
print “Como vai, $nome?n”;
}

for

Este comando possui a seguinte estrutura:

for (comandos iniciais; condições; incremento/decremento)
{
comandos do laço
}

onde

  • cmds.inic.: é usado para inicializar uma ou mais variáveis;
  • condições : os comandos do loop são executados enquanto estas
  • condições forem verdadeiras (testa condições e só então executa os comandos);
  • inc/dec : usado para incrementar/decrementar variáveis após cada execução dos comandos que estão dentro do laço.

O exemplo abaixo mostra três variáveis distintas: a primeira variável é incrementada em 1 a cada execução do laço, a segunda variável é decrementada em 1 e a terceira variável é incrementada em 2.

# arquivo: teste17.pl
for ($i=1,$j=3,$k=0;$i&lt;=10 && $j&gt;0 && $k&lt;10; $i++,$j--,$k+=2)
{
print "$i = $i, $j = $j, $k = $kn";
}

A saída do programa acima é

$i = 1, $j = 3, $k = 0
$i = 2, $j = 2, $k = 2
$i = 3, $j = 1, $k = 4

Note que após 3 execuções do laço, temos $i=4, $j = 0 e $k = 6, como isto não satisfaz a segunda condição ($j > 0), a execução do “for” é encerrada.

while

O comando while tem a seguinte estrutura

while (condições)
{
comandos
}

onde os comandos dentro das chaves são executados repetidamente enquanto as condições descritas pelo “while” forem verdadeiras. O exemplo abaixo solicita a identificação do usuário. Enquanto o nome fornecido não for igual ao do usuário que iniciou a sessão, o programa fica preso dentro do laço do “while”.

# arquivo: teste18.pl
$nome_amb = $ENV{"USER"};
$nome = "";
while ($nome ne $nome_amb)
{
print "Digite o seu nome: n";
$nome = ; # ler do teclado
chomp($nome); # remove caracter Enter

}
print"Como vai, $nome?n";


do while

Este comando tem a seguinte estrutura

do
{
comandos
}
while (condições)A diferença entre “do while” e “while” consiste que a primeira estrutura executa pelo menos uma vez (executa e testa), enquanto a segunda estrutura testa antes de executar a primeira vez (testa e executa). Abaixo mostramos o exemplo anterior usando a estrutura “do while”. Note que não precisamos inicializar a variável $nome neste exemplo, pois não é feito nenhum teste com esta variável antes que o usuário entre com o nome pela primeira vez.

# arquivo: teste19.pl
$nome_amb = $ENV{“USER”};
do
{
print “Digite o seu nome: n”;
$nome = ;
chomp($nome); # remove caracter Enter
}
while ($nome ne $nome_amb);
print”Como vai, $nome?n”;Podemos substituir o while do exemplo acima por um until. Neste caso, o laço é executado até que a condição se torne verdadeira. Para ver como isto funciona, experimente trocar o while acima por

until ($nome eq $nome_amb);Note que é necessário modificar a condição, pois o laço é agora executado até (until) que o nome digitado seja igual ao nome do usuário do sistema.

foreach

Este comando ler uma linha de uma matriz ou de um arquivo. No exemplo abaixo temos uma lista de filmes brasileiros e o comando é usado para imprimir esta lista. Note que a cada passo do laço, um elemento da lista é lido e armazenado na variável $nome. Se a lista fosse vazia, os comandos dentro do bloco não seriam executados.

# arquivo: teste20.pl
@filmes = ("Central do Brasil", "Gêmeas", "Bossa Nova", "Villa-Lobos");
$i = 1;
foreach $nome(@filmes)
{
print "$i - $nomen";

$i++;
}

O resultado da execução do script acima é

1 - Central do Brasil
2 - Gêmeas
3 - Bossa Nova
4 - Villa-Lobos


Arquivos

Abrir um arquivo

A sintaxe do comando é

open(nome interno, nome real)

Por exemplo,

open(ARQ,'/etc/passwd');

O comando acima abre o arquivo “/etc/passwd” para leitura e associa este arquivo ao nome ARQ. É possível substituir o segundo parâmetro por uma variável como mostramos a seguir.

$nome_arq = '/etc/passwd';
open(ARQ, $nome_arq);

Podemos também abrir um arquivo para gravação ou para adicionar no final do arquivo. Para isso, basta adicionarmos > ou >> antes do nome real do arquivo.

Ao abrir um arquivo para gravação, se este arquivo já existe, ele é destruído e criado novamente; se o arquivo não existe, ele é apenas criado. Para abrirmos o arquivo teste.txt para gravação, podemos digitar

$nome_arq = 'teste.txt';
open(ARQ, ">$nome_arq");

ou

open(ARQ, '>teste.txt');

Ao abrir um arquivo para adição, se o arquivo ainda não existe ele é criado. Para abrirmos o arquivo teste.txt para adição, podemos digitar

$nome_arq = 'teste.txt';
open(ARQ, ">>$nome_arq");

ou

open(ARQ, '>>teste.txt');

Para abrir a entrada ou a saída padrão (normalmente, teclado e tela), basta digitar

open(ARQ, '-'); # abre entrada padrão
open(ARQ, '>-'); # abre saída padrão


Ler e escrever em um arquivo

Para ler um arquivo texto, basta informar o nome do arquivo e direcionar a leitura para uma matriz.

@linhas_arq = ;Para escrever em um arquivo, usa-se o comando print seguido do nome do arquivo e da informação a ser gravada.

print ARQ “teste de gravaçãon”;

Fechar um arquivo

Para fechar um arquivo basta fornecer o nome interno (lógico) do arquivo.

close(ARQ);

Exemplos

Veja agora o exemplo completo que abre, ler, fecha e imprime o conteúdo do arquivo “/etc/passwd”.

# arquivo: teste21.pl
$nome_arq = ‘/etc/passwd’;
open(ARQ, $nome_arq);
@linhas_arq = ;
close(ARQ);
print @linhas_arq;Abaixo temos um outro exemplo de manipulação de arquivos, onde é feita a gravação de uma string no arquivo teste.txt

# arquivo: teste22.pl
open(ARQ, ‘>teste.txt’);
print ARQ “teste de gravaçãon”;
close(ARQ);

Subrotinas

No Perl pode-se definir subrotinas (funções) no início ou no fim do programa. A estrutura básica de uma subrotina é a seguinte

sub nome_da_subrotina
{
comandos da subrotina
}<pre>

Para chamar uma subrotina é preciso colocar o caracter & antes do nome da subrotina. Se não existe passagem de parâmetros na chamada, basta digitar 

<pre>&nome_da_subrotina;

Caso haja passagem de parâmetros na chamada, digite

&nome_da_subrotina(parâmetro 1, parâmetro 2, ..., parâmetro n);

Note que na especificação da subrotina não existe definição de parâmetros, entretanto, quando chamamos uma subrotina podemos passar um ou mais parâmetros. Isto se deve ao fato do Perl assumir que os parâmetros são passados através da variável especial @_. Portanto, para imprimir os parâmetros recebidos em uma subrotina, basta incluir na respectiva subrotina o seguinte comando

print "@_n";

Para acessar o i-ésimo elemento de @_, usa-se a variável especial $_[i-1]. Logo, $_[0] é o primeiro elemento de @_,

$_[1] é o segundo elemento de @_, e assim por diante.

Uma observação importante sobre subrotinas diz respeito ao escopo das variáveis: as variáveis criadas nas funções são variáveis globais, ou seja, um variável criada dentro de uma subrotina, continua a existir após o término da subrotina e pode portanto, ainda ser manipulada. Para declarar variáveis locais (são destruídas após o término da subrotina) use o seguinte comando

local(variável 1, variável 2, ..., variável n);

Abaixo mostramos um exemplo com chamada de subrotina e passagem de parâmetro. O objetivo do script é calcular o fatorial de um número fornecido pelo usuário. No programa principal pedimos ao usuário que forneça um número e usamos para ler este número e armazená-lo na variável $num. Em seguida, chamamos a função chomp() que elimina o caracter Enter digitado pelo usuário após o número. O próximo passo do programa chama a subrotina fatorial tendo como parâmetro o número digitado ($num). Note que armazenamos o resultado da execução da subrotina fatorial na variável escalar $resultado. Por último, o programa principal imprime o valor do fatorial calculado. Na subrotina fatorial, definimos duas variáveis locais: $n e $fat. A primeira variável local é usada para armazenar o parâmetro recebido (esta atribuição não é necessária, pode-se usar @_[0] no corpo da subrotina) e a segunda variável local é utilizada no cálculo do fatorial. O fatorial de $num é calculado em seguida usando o comando “for”. A última linha de comando da subrotina (“$fat;”) retorna o resultado do cálculo ao programa principal. É importante observar que é possível usar a instruçâo “return” para retornar explicitamente um valor e encerrar a execução da subrotina. Por exemplo, você pode substituir “$fat;” na última linha da subrotina fatorial por “return $fat;”.

# arquivo: teste23.pl
sub fatorial
{
local($n, $fat);
$n = $_[0];
$fat = 1;
for ($i = 1; $i <= $n; $i++)
{
$fat *= $i;
}
$fat;
}
# programa principal
print "Digite um númeron";
$num = ;
chomp($num);
$resultado = &fatorial($num);
print "Fatorial de $num é $resultadon";

Note que a variável $i criada na subrotina fatorial do exemplo acima não foi definida como variável local. Portanto, ela continua a existir após a execução da subrotina. Você pode, por exemplo, incluir o seguinte comando no final do programa principal (após ou antes do último comando print)

print "$i = $in";

Neste caso, o programa irá imprimir o valor de $i que é igual ao valor da variável $num acrescido de 1 (esta é a condição de saída do laço “for”). Outra observação importante diz respeito ao escopo das variáveis especiais do script teste23.pl: se você alterar o valor de $_[0] dentro da subrotina fatorial, o valor de $num na rotina principal também será modificado pois eles correspondem a mesma variável no Perl. Isto significa que o Perl usa passagem implícita de parâmetros por referência, ou seja, o Perl sempre trabalha com endereço de variáveis na passagem de parâmetros. Assim, ao manipularmos a variável $_[0] em uma subrotina, estamos, na realidade, trabalhando com a primeira variável definida na chamada da subrotina, apenas com um nome diferente.

O exemplo teste24.pl mostra mais um exemplo de subrotina com passagem de parâmetros. Neste programa, é calculada a média das três avalições feitas pelo aluno e é verificado se o aluno deve ou não fazer a quarta avaliação.

# arquivo: teste24.pl
sub calcula_media
{
printf "Notas: @_ n";
local($a1, $a2, $a3) = @_;
if (($a1 + $a2 >= 14) || ($a1 + $a3 >= 14) || ($a2 + $a3 >= 14) ||
($a1 + $a2 + $a3 >=15))
{
print "Parabéns! Você já estar de férias.n";
}
else
{
print "Você precisa fazer A4.n";
}
}
print "Digite a nota de A1n";
$num1 = ;
chomp($num1);
print "Digite a nota de A2n";
$num2 = ;
chomp($num2);
print "Digite a nota de A3n";
$num3 = ;
chomp($num3);
&calcula_media($num1, $num2, $num3);

Podemos aqui fazer duas observações em relação ao exemplo acima. Primeiro, podemos juntar definição e inicialização de variáveis locais em um único comando como mostra a segunda linha da subrotina calcula_media. Segundo, a subrotina calcula_media retorna valor 1, embora este valor não seja nem armazenado e nem utilizado pelo programa principal.Isto ocorre porque o último comando executado na subrotina é o “print” que, quando funciona corretamente, retorna o valor 1.

Suponha que queremos passar como parâmetro uma matriz ao invés de um conjunto de variáveis escalares. Por exemplo, no script teste24.pl, poderíamos fazer a seguinte alteração na chamada da subrotina:

@lista = ($num1, $num2, $num3);
&calcula_media(@lista);

O Perl transforma a matriz, na passagem de parâmetros, em um conjunto de variáveis escalares. Portanto, para o exemplo acima temos: $_[0] = @lista[0], $_[1] = @lista[1] e $_[2] = @lista[2]. Se neste exemplo acrescentássemos uma escalar logo após a matriz, esta variável corresponderia a $_[3] na subrotina chamada. É fácil ver que a subrotina não identifica quais as estruturas de dados que está recebendo. Tudo é passado como um conjunto de variáveis escalares.

Caso seja importante identificar, dentro da subrotina chamada, os tipos de estruturas de dados (escalar, matriz ou matriz associativa), devemos passar explicitamente o endereço (referência) das estruturas Perl para a subrotina.

Para criar a referência de uma variável basta colocar uma barra invertida (“”) antes do nome da variável. Uma referência é um escalar e portanto, pode ser usado em qualquer situação onde um escalar pode ser usado. Por exemplo,

$ref_a = $a;

faz com que $ref_a receba o endereço da variável $a. Da mesma forma, também podemos armazenar endereços de matrizes e de matrizes associativas.

Para recuperar o conteúdo de um endereço, basta colocar $, @ ou % diante da variável que contém o endereço, dependendo se a referência é de uma escalar, de uma matriz ou de uma matriz associativa, respectivamente. Podemos, então, digitar

$valor = $$ref_a;

para recuperar o valor de $a do exemplo acima.

A seguir, mostramos o exemplo teste25.pl onde uma subrotina é chamada duas vezes no mesmo programa. Na primeira chamada são passados dois parâmetros por referência (uma matriz e uma escalar) e na segunda chamada são passados três parâmetros (uma matriz e duas escalares). Note que, neste exemplo, temos alguns argumentos na definição da subrotina. Estes argumentos definem os tipos de parâmetros passados por referência. São possíveis símbolos que podemos usar como argumentos de subrotina

$ escalar
@ matriz
% matriz associativa

Além disso, o ponto-e-vírgula na lista de argumentos de teste25.pl separa os argumentos obrigatórios dos argumentos opcionais. Como última observação, note que os endereços recebidos estão entre chaves quando acessamos o conteúdo destes endereços. Isto é para evitar erro de interpretação por parte do Perl em relação à variável especial $_.

# arquivo: teste25.pl
sub imprime_lista(@$;$)
{
@letras = @{$_[0]};
$n1 = ${$_[1]};
if ($_[2])
{
$n2 = ${$_[2]};
print "@letras = @letras, $n1 = $n1, $n2 = $n2n";
}
else
{
 print "@letras = @letras, $n1 = $n1n";
}
}
# programa principal
@lista = ("a", "b");
$num1=100;
$num2=200;
print "Primeira chamada com dois parâmetrosn";
&imprime_lista(@lista,$num1);
print "Segunda chamada com três parâmetrosn";
&imprime_lista(@lista,$num1,$num2);

Manipulação de Strings

O PERL PERMITE verificar se existe uma determinada expressão dentro de uma string. A expressão a ser procurada é colocada entre duas barras para comparação. Existem dois operadores que podem ser utilizados: =~ e =!. O operador =~ retorna verdade se a expressão é encontrada e o operador =! retorna verdade se a expressão não é encontrada. O exemplo abaixo, verifica se existe a expressão ‘pensa’ na string armazenada na variável $frase.

# arquivo: teste26.pl
$frase = "Pense em si. Mas, procure pensar muito mais nos outros," .
" que precisam de você.";
if ($frase =~ /pensa/)
{
print "Encontroun";
}
 else
{
print "Não encontroun";}

Podemos substituir o operador =~ do exemplo acima pelo operador != e ainda assim, com uma pequena alteração no código do programa, obtermos o mesmo resultado.

# arquivo: teste26.pl
$frase = "Pense em si. Mas, procure pensar muito mais nos outros," .
" que precisam de você.";
if ($frase !~ /pensa/)
{
print "Não encontroun";
}
else
{
print "Encontroun";
}

Podemos também usar a variável especial $_ para armazenar a string que será usada na pesquisa. Neste caso, não há necessidade de especificar a variável na comparação pois $_ é a variável padrão do Perl. Veja abaixo uma nova versão para teste26.pl usando esta variável especial.

# arquivo: teste26.pl
$_ = "Pense em si. Mas, procure pensar muito mais nos outros," .
" que precisam de você.";
if (/pensa/)
{
print "Encontroun";
}
else
{
print "Não encontroun";
}

Existem alguns caracteres especiais que podem ser usados na comparação de strings. Por exemplo,

. : substitui qualquer caracter exceto newline
^ : o início da linha ou do caractere
$ : o fim da linha ou do caractere
* : nenhum, um ou mais de um do último caractere
+ : um ou mais de um do último caractere
? : nenhum ou o último caractere
[] : define um grupo de caracteres que pode estar na string (se
existir o caractere ^ antes dos caracteres significa que o grupo de caracteres não pode estar na string)
| : representa ou

Os seguintes testes serão verdadeiros se os incluirmos no programa teste26.pl visto acima:

$frase =~ /{Pp]ens.r/ # encontra 'pensar'
$frase =~ /pr[a-z]*re/ # encontra 'procure'
$frase =~ /[Mm]a[i]*s/ # encontra 'Mas' e 'mais'
$frase =~ /Ma[i]?s/ # encontra 'Mas'
$frase =~ /[Pp]ens[a-z]*/ # encontra 'Pense' e 'pensar'
$frase =~ /pr[a-z]+/ # encontra 'procure' e 'precisam'
$frase =~ /[Pp]ens[^a]+/ # encontra 'Pense'
$frase =~ /[Pp]ens[a|e]/ # encontra 'Pense' e 'pensa'

Podemos também substituir a expressão encontrada em uma string por outra ao invés de apenas verificar se ela existe. Para isso, basta usar a estrutura

s/expressão original/nova expressão/gi

onde

s : informa que é uma substituição
g : em todas as ocorrências (se este parâmetro não for informado, apenas
a primeira ocorrência encontrada na string é modificada)
i : ignora diferenças entre letras maiúsculas e letras minúsculas

Podemos, por exemplo, incluir no programa teste26.pl:

$frase =~ s/Mas/Porém/; # altera apenas a primeira ocorrência
$frase =~ s/Mas/Porém/i; # não é case sentive
$frase =~ s/Mas/Porém/g; # altera todas as ocorrências
$frase =~ s/Mas/Porém/gi; # altera todas as ocorrências e não é # case sensitive

Note que, nos exemplos acima, estamos modificando a string armazenada na variável $frase, mas podemos também utilizar a variável especial $_ como variável padrão. Neste caso, basta digitar, por exemplo

s/Mas/Porém/; # altera apenas a primeira ocorrência de $_

É possível também dividir uma string em strings menores e colocar o resultado em uma lista. Para isto basta usar a função split.

@lista = split(/separador/, $string);

onde

@lista : é a variável matriz que recebe o resultado da operação
separador: conjunto de caracteres que indica onde a string será dividida
$string : string a ser dividida, caso não seja informado este parâmetro,
é usada a variável especial $_.

Abaixo, mostramos um exemplo onde uma string é dividida em duas outras strings e o ponto (‘.’) é escolhido como caracter separador. Note que usamos a barra invertida () antes do ponto. O motivo é que o ponto tem função especial no Perl, ao usarmos a barra indicamos que o caracter seguinte (o ponto) não deve ser interpretado.

# arquivo: teste27.pl
$frase = "Pense em si. Mas, procure pensar muito mais nos outros," .
" que precisam de você.";
print "$frasen";
@lista = split(/. /, $frase);
print "@lista[0] = @lista[0]n";
print "@lista[1] = @lista[1]n";

A saída de teste27.pl é

Pense em si. Mas, procure pensar muito mais nos outros, que precisam de você.

Bibliografia

  • Perl – Guia Completo

Ellen Siever, Stephen Spainhour e Nathan Patwardhan Editora Ciência Moderna

  • Programando para Linux

Patrick Volkerding, Eric Foster-Johnson e Kevin Reichard Makron Books