Você está na página 1de 35

Algoritmos

por Ricardo Dornelles e Carlos Campani (revisões: Carlos Michel Betemps)

“A ignorância é a mãe da industria e da superstição ... as manufaturas prosperam mais onde se dispensa o
espírito e onde a manufatura pode ... ser considerada uma máquina cujas partes são seres humanos”
 O Capital, K. Marx
PROGRAMA DA DISCIPLINA DE ALGORITMOS

1. Introdução aos algoritmos


2. Conceitos básicos
2.1. Definição de algoritmo
2.2. Variáveis e constantes
2.3. Comandos simples
2.4. Expressões aritméticas e lógicas
3. Algoritmos seqüenciais
4. Estrutura condicional
5. Estrutura de repetição
6. Refinamentos sucessivos
7. Matrizes e vetores
8. Subalgoritmos
9. Recursividade
BIBLIOGRAFIA

FARRER, H. et alii. Algoritmos Estruturados. Rio de Janeiro, Editora Guanabara, 1989.

WIRTH, N. Programação Sistemática. Rio de Janeiro, Ed. Campus, 1978.

SALVETTI, D. D. e BARBOSA, L. M.. Algoritmos. São Paulo: Makron Books, 1998.

CONCEITOS BÁSICOS

Algoritmo é a descrição de um conjunto de comandos que, efetuados, resultam numa


sucessão finita de ações.
Ou ainda, um algoritmo, intuitivamente, é uma seqüência finita de instruções ou
operações básicas (operações deefinidas sem ambigüidade e executáveis em tempo finito
dispondo-se apenas de lápis e papel) cuja execução, em tempo finito, resolve um problema
computacional, qualquer que seja sua instância.
Uma outra forma de definir seria: Algoritmo é uma lista de instruções (comandos)
ordenadas que tem por finalidade resolver um determinado problema.
Exemplos de algoritmos:
• Uma receita culinária
• Instruções para montar algo

Ex. Algoritmo para fritar um ovo


1. Colocar um ovo na frigideira
2. Esperar o ovo ficar frito
3. Tirar o ovo
O algoritmo acima não está detalhado e nem completo. Uma versão mais aceitável é
1. Retirar um ovo da geladeira
2. Colocar a frigideira no fogo
3. Colocar óleo
4. Esperar até o óleo ficar quente
5. Quebrar o ovo separando a casca
6. Colocar o conteúdo na frigideira
7. Esperar um minuto
8. Retirar o ovo da frigideira
9. Apagar o fogo
Esta versão é mais completa e detalhada que a anterior. Para que um algoritmo possa ser
executado é necessário que seu usuário conheça a terminologia nele utilizada. No exemplo
anterior, para que o algoritmo seja útil, é necessário que o usuário conheça o significado
dos verbos Retirar, Colocar, Esperar assim como dos substantivos utilizados.
Os algoritmos estudados em aula serão algoritmos computacionais, listas de comandos a
serem executados por um computador. Para que o computador consiga executa-los ele
tambem deve conhecer a terminologia utilizada. Ao conjunto de comandos que fazem parte
de uma linguagem de programação chama-se sintaxe da linguagem de programação.
Os algoritmos estudados na disciplina de Algoritmos serão desenvolvidos utilizando
uma sintaxe que será apresentada progressivamente ao longo do semestre. Esta sintaxe
pode ser chamada de português estruturado e os algoritmos nela desenvolvidos podem ser
facilmente adaptáveis as diversas linguagens de programação existentes.
A forma geral dos algoritmos a ser adotada em aula é:
Algoritmo
{ lista-de-comandos }
fim algoritmo
onde { lista-de-comandos } é uma lista com um ou mais comandos.
COMANDO DE ESCRITA

O comando de escrita é utilizado quando se deseja que o algoritmo escreva algo. Esta
'escrita' pode ser em uma impressora, um terminal de vídeo ou outra saída qualquer. O
formato do comando é:
Escreva { lista-de-expressões }

2
onde { lista-de-expressões } é uma lista de uma ou mais expressões e uma expressão
pode ser uma constante, uma expressão aritmética, variável ou chamada de função.
Ex:
Algoritmo
Escreva 'Joao',' ','Maria' Escreva '1'
Escreva 1 + 2
fim algoritmo
Ao ser executado este algoritmo o resultado será
Joao Maria
1
3
Os comandos como Algoritmo e fim algoritmo são chamados palavras reservadas da
linguagem. Na 'linguagem' utilizada em aula as palavras reservadas são sempre
sublinhadas. A linguagem trata maiúsculas e minúsculas como iguais.
O exemplo anterior é composto de três comandos de escrita. No primeiro o comando
deve escrever uma lista de três constantes, no segundo deve escrever uma constante e no
terceiro deve escrever o resultado de uma expressão aritmética. Quando um comando de
escrita tiver mais de um valor a ser escrito como no primeiro, os diversos valores são
separados por vírgula.
CONSTANTES

Uma constante é um valor que não se modifica com o tempo. As constantes com que
trabalharemos podem ser de três tipos diferentes, numéricas, lógicas ou literais.
Constantes numéricas podem conter quaisquer valores numéricos, reais ou inteiros,
positivos ou negativos, etc. Exemplos de constantes numéricas são:
25
3.14
-2.57
-0.0003
-10
Constantes literais podem conter um ou mais caracteres alfabéticos ou numéricos. São
delimitados por aspas. Exemplos de constantes literais são:
'Jose da Silva'
'1245'
'1 2 3 de oliveira'
Constantes lógicas podem conter somente dois valores, verdadeiro e falso. Normalmente
são utilizadas em testes em algoritmos.

VARIÁVEIS

Uma variável é um valor que pode ser alterado em um algoritmo. Cada variável tem um
nome associado a ela que a identifica. O identificador de uma variável deve começar por
uma letra e pode conter letras ou dígitos.
Ex:

3
A
X5
Joao
Assim como as constantes as variáveis também podem ser de três tipos : numéricas,
lógicas ou literais.
Uma variável pode armazenar qualquer valor e seu valor pode ser alterado a qualquer
momento no algoritmo. O comando utilizado para alterar o valor de uma variável é o
comando de atribuição. Sua forma geral é a seguinte:
<identificador de variável> ← <expressão>
onde <expressão> pode ser uma constante, expressão aritmética, variável ou chamada de
função. Por exemplo:
A←5
O comando acima (lê-se 'A recebe cinco') faz com que a variável A passe a valer 5. O
valor anterior da variável A é perdido e seu novo valor passa a ser 5.
Outros exemplos de atribuição são:
A←3+2
A←B
X5 ← A + 1
No primeiro exemplo a variável A recebe o resultado da expressão aritmética '3 + 2',
expressão esta que contém somente constantes. No segundo exemplo a variável A recebe o
conteúdo da variável B e no terceiro exemplo a variável X5 recebe o resultado da expressão
aritmética 'A+1', expressão esta que contém a variável A e a constante 1.
Para utilizar uma variável em um algoritmo é necessário que ela seja declarada no início
do algoritmo, ou seja, defina-se no início do algoritmo qual o tipo de valor com que a
variável irá trabalhar ( numérico, lógico ou literal ). O formato do comando de declaração é
Declare <lista de identificadores> <tipo das variáveis>
Ex:
Declare Nota,Codigo,X5 Numérico
Declare Teste,Sim Lógico
Declare Nome,End1,End2 Literal

COMANDO DE LEITURA

O comando de leitura é utilizado quando o algoritmo deve receber um valor externo, por
exemplo, de um teclado. Seu formato geral é:
Leia <lista-de-variáveis>
Este comando faz com que a primeira variável da lista receba o primeiro valor digitado
no teclado, a segunda variável receba o segundo valor e assim por diante.
Ex:
Leia A,B

4
Ao executar este comando o computador esperará que sejam digitados dois valores no
teclado ( p.ex: 10 e 20 ). A variável A receberá então o primeiro valor (10) e a variável B
receberá o segundo valor (20).
Ex 2.8 - Escrever um algoritmo que lê três números, calcula as médias aritmética,
harmônica e geométrica e escreve os números lidos e as médias calculadas.
A+ B +C
MA =
3
MG = 3
A .B .C
3
MH =
1 1 1
+ +
A B C
Ex 2.9 - Escrever um algoritmo que lê o nome de um funcionário, o número do
funcionário, seu número de horas trabalhadas, o valor que recebe por hora, o número de
filhos com idade menor que 14 anos e calcula o salário deste funcionário.
Ex 2.10 - Escrever um algoritmo que calcula o fatorial de 5.
Ex 2.11 - Escrever um algoritmo que lê três valores, a, b e c e calcula:
a) A área do triângulo que tem a por base e b por altura.
b) A área do círculo de raio c.
c) A área do trapézio que tem a e b por bases e c por altura.
d) A área do quadrado de lado b.
e) A área do retângulo de lados a e b.
f) A área da superfície de um cubo que tem c por aresta.
Ex 2.12 - Escrever um algoritmo que escreve os números ímpares entre 10 e 20.
Ex 2.13 - Escrever um algoritmo que lê p, u e r, respectivamente o primeiro termo de
uma progressão aritmética, o último termo da progressão e a razão desta progressão.
Determinar a soma dos termos desta

a − a
+ n= + 1
soma = a a n 1
n 1
×n r
2
progressão aritmética.

Ex 2.14 - Escrever um algoritmo que lê o código da peça 1, o número de peças 1, o valor


unitário da peça 1, o código da peça 2, o número de peças 2, o valor unitário da peça 2 e a
percentagem do IPI a ser acrescentado e calcula o valor total a ser pago.

5
Ex 2.15 - Um avião em linha reta, a uma altitude a passa sobre um ponto p num instante
t=0. Se a velocidade é v, calcular a distância d do avião ao ponto p no tempo t=30. Escrever
um algoritmo que lê v e a e calcula a distância ao ponto p após 30 segundos.
EXPRESSÕES ARITMÉTICAS

Para que uma expressão possa ser avaliada em um algoritmo ela deve seguir uma sintaxe
bem definida. As operações utilizadas nas expressões aritméticas em nossa 'linguagem' são
as seguintes:
Operação Símbolo Prioridade
Potenciação ** 1
Multiplicação * 2
Divisão / 2
Adição + 3
Subtração - 3

A prioridade da operação define qual a operação que será realizada em primeiro lugar.
Por exemplo, a avaliação da expressão 3 + 4 * 2 pode resultar 14 se a soma for efetuada em
primeiro lugar ou 11 se a multiplicação for efetuada em primeiro lugar. Para isto se define a
prioridade das operações. Ao avaliar uma expressão primeiro são efetuada as potenciações,
após são efetuadas as multiplicações e divisões e por fim as adições e subtrações. Quando
houverem duas operações de mesma prioridade para serem efetuadas, a ordem de execução
é da esquerda para a direita.
É possível alterar a ordem de execução das operações em uma expressão com o uso de
parênteses. Em uma expressão com parênteses em primeiro lugar são efetuadas as
operações entre parênteses.
Ex: Expressão para o cálculo das raízes de uma equação de segundo grau segundo a
fórmula de Bascara (usar o "-" unário).
X1 ← ( - B + ( B ** 2 - 4 * A * C ) ** ( 1 / 2 ) ) / ( 2 * A )
X2 ← ( - B - ( B ** 2 - 4 * A * C ) ** ( 1 / 2 ) ) / ( 2 * A )

Além das operações acima descritas a nossa 'linguagem' oferece as seguintes funções
pré-definidas:
LOG(x) logaritmo de x na base 10
LN(x) logaritmo natural de x
EXP(x) e elevado na x-ésima potência
ABS(x) módulo ( valor absoluto ) de x
TRUNCA(x) valor inteiro de x. Ex TRUNCA(3.48) = 3
ARREDONDA(x) inteiro mais próximo a x.

6
SINAL(x) -1 se x<0
0 se x=0
1 se x>0
QUOCIENTE(x,y) quociente inteiro da divisão de x por y
RESTO(x,y) resto da divisão inteira de x por y
Ex:
QUOCIENTE(3,2)=1
RESTO(5,2)=1
Ex 2.16 - Escrever um algoritmo para calcular os sucessivos valores de E usando a série
abaixo considerando primeiro 3 termos, depois 4 termos e finalmente 5 termos
1 1 1 1
E= + + +
1! 2! 3! 4!
Ex 2.17 - Escrever um algoritmo que lê o valor de um empréstimo e calcula o valor de
cada amortização considerando 24 amortizações a uma taxa de 48%. Depois fazer o mesmo
algoritmo lendo os valores da taxa e do número de amortizações.
Valor da amortização = Valor do empréstimo × taxa / número de amortizações
Ex 2.18 - Escrever um algoritmo que lê um valor em cruzeiros e calcula qual o menor
número possível de notas de 5000, 1000, 500, 200, 100, 50, 10, 5 e 1 em que o valor lido
pode ser decomposto. Escrever o valor lido e a relação de notas necessárias.
Ex 2.19 - Escrever um algoritmo que lê o número do vendedor, o seu salário fixo, o total
de vendas por ele efetuadas e o percentual que ganha sobre o total de vendas. Calcular o
salário total do vendedor. Escrever o número do vendedor e o salário total.
Ex 2.20 - Escrever um algoritmo que lê 3 valores a, b e c que são lados de um triângulo
e calcule a área deste triângulo.
área = s(s − a)(s − b)(s − c)
onde S = semi-perímetro

Ex 2.21 - Um sistema de equações lineares do tipo


ax + by = c

dx + ey = f
pode ser resolvido segundo mostrado abaixo:
c.e − b.f
x =
a.e − b.d
a.f − c.d
y =
a.e − b.d
Escrever um algoritmo que lê os coeficientes a, b, c, d, e, f e calcula e escreve os valores
de x e y.

7
Ex 2.22 - O custo ao consumidor, de um carro novo, é a soma do custo de fábrica com a
porcentagem 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. Depois fazer o
mesmo algoritmo lendo os valores da porcentagem do distribuidor e dos impostos.
Ex 2.23 - Uma revendedora de carros usados paga a seus funcionários vendedores, um
salário fixo por mês, mais uma comissão também fixa para cada carro vendido e mais 5%
do valor das vendas por ele efetuadas. Escrever um algoritmo que lê o nome do vendedor, o
número do vendedor, o número de carros por ele vendidos, o valor total de suas vendas, o
salário fixo e o valor que recebe por carro vendido e calcula o salário mensal do vendedor,
escrevendo-o juntamente com o seu nome e seu número de identificação.
Ex 2.24 - 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
nome do funcionário, o número do funcionário, seu salário atual, o valor do INPC e o
índice de produtividade conquistado e escreve o nome do funcionário, seu aumento e o
valor do novo salário.
Ex 2.25 - Escrever um algoritmo que lê 3 valores a, b e c e os escreve. Encontre a seguir
o maior dos três valores e o escreva com a mensagem: "É o maior".
a +b + a −b
Maior entre a e b =
2
EXPRESSÕES LÓGICAS

Expressões lógicas são expressões que avaliadas resultam em um valor lógico (


verdadeiro ou falso ). Assim como as expressões aritméticas elas também dispõem de um
conjunto de operadores, símbolos e prioridades. Os operadores são divididos em operadores
relacionais e operadores lógicos.
Operadores relacionais atuam sobre operandos numéricos mas resultam em valores
lógicos. São operadores de comparação entre dois operandos. São eles:

Igual a =
Diferente de <> ou ≠
Maior que >
Menor que <
Maior ou igual a >=
Menor ou igual a <=

Operadores lógicos atuam sobre valores lógicos e resultam em valores lógicos. São:

8
Não Inverte o valor lógico do operando
E Verdadeiro se e somente se os dois
operandos são verdaddeiros
Ou Verdadeiro se pelo menos um dos dois
operandos é verdadeiro

Exemplos de expressões lógicas:


A>0EB>3
Teste OU A * B > C
Prioridades:
1. Operadores Aritméticos
2. Operadores Relacionais
3. Nao
4. E
5. OU
Ex: Se A = 1, B = 2 e C = 2 qual o resultado da avaliação da expressão seguinte?
A + B = 0 E C <> 0
3 = 0 E C <> 0
Falso E Verdadeiro
Falso

ESTRUTURA CONDICIONAL

Utilizada quando um trecho de algoritmo só deve ser executado em determinadas


condições.
Formas Gerais:
a)
Se <condição> então
início
<lista-de-comandos>
fim
b)
Se <condição> então
início
<lista-de-comandos>
fim
senão
inicio
<lista-de-comandos>
fim
Onde:
<condição> é uma expressão lógica qualquer;

9
Início e Fim são palavras reservadas que definem o respectivos início e fim de um bloco
de comandos (ou lista-de-comandos). Podem ser chamadas delimitadoras de blocos.
Quando o bloco de comandos (lista-de-comandos) é formada por apenas um comando
simples, por exemplo: “Escreva a”, não é necessário se utilizar as palavras reservadas Início
e Fim, pois só existe um comando a ser executado. Por exemplo, se em um algoritmo está
se utilizando uma estrutura condicional Se, e, para o caso em que a <condição> for
Verdadeira, o algoritmo precisa executar apenas um comando, por exemplo, uma atribuição
a uma variável, não é neceessário utilizar início e fim. Entretanto, se no caso em que
<condição> for Falsa é necessário a execução de uma atribuição e uma escrita, será
necessário utilizar-se os delimitadores início e fim.
Ex.:
Se x > 5 então
x←0
senão
início
x ← x+1
Escreva x
fim

Ex :
Se a>b
então escreva a
senão escreva b

Ao ser executado este comando a expressão 'a > b' é avaliada e dependendo do resultado
da avaliação é executado o primeiro comando (escreva a) ou o segundo comando (escreva
b). Observe que as estruturas podem ser "aninhadas".

Ex : Algoritmo que calcula a raiz da equação y = ax + b


Algoritmo
Declare A,B,X numérico
Leia A,B
Se A = 0
então escreva 'Não há raizes'
senão
início
X ← -B / A
escreva 'Raiz',X
fim
fim algoritmo

Algoritmo que calcula as raizes da equação y = ax2+bx+c


Algoritmo
Declare A,B,C,Delta numérico
Leia A,B,C
Delta ← B ** 2 - 4 * A * C

10
Se Delta = 0
então escreva 'Só há uma raiz',- B / ( 2 * A )
Se Delta < 0
então
início
escreva 'ha duas raizes complexas'
escreva -B/(2*A),'+-',abs((-Delta)**0.5/(2*A)),'J'
fim
Se Delta > 0
então
início
escreva 'Ha duas raizes reais'
escreva (-B+Delta**0.5)/(2*A),' E ',(-B-(Delta**0.5))/(2*A)
fim
fim algoritmo

ESTRUTURAS DE REPETIÇÃO

São utilizadas quando um trecho de um algoritmo deve ser repetido um determinado


número de vezes.
Repetição com Variável de Controle:
Instrução Para de até (passo):
Para i de 1 até n faça
início
<lista-de-comandos>
fim
Aqui, como no restante desta apostila, também se aplica a regra dos delimitadores
Inícios e Fim.
Para i de n até 1 passo –1 faça início <lista-de-comandos> fim
Na forma acima, ao invés da variável de controle ser incrementada a cada iteração, a
mesma é decrementada. Para isto utiliza-se a palavra reservada passo, que define o valor
que deve ser somado a variável de controle a cada iteração. Observe que o mesmo poderia
ser utilizado no primeiro exemplo com o valor 1. Pode-se também utilizar uma valor
diferente para passo como: Para i de 1 até n passo 5 faça (em cada iteração da estrutura de
repetição a variável i é incrementada de 5).
Ex. :
Para i de 1 até n faça
início
Escreva i
Soma ← Soma + i
fim

Repetição Controlada por Condição


Instrução Enquanto Faça:

11
Enquanto <condição> faça
início <lista-de-comandos> fim

Ex.:
Leia a
Enquanto a > 0 faça
início
t←a*a
Escreva a
Leia a
fim

Instrução Repita Até:


Repita
Leia a
t←a*a
Escreva a
Até a <= 0

Esta estrutura faz com que todos os comandos entre o Repita e o Até a<=0 (<condição>
de saída do laço) sejam executados repetidamente até que a <condição> de saída do laço
seja Verdadeira (a<=0). Quando isto ocorrer o próximo comando a ser executado é o
comando após o Até <condição>.
Esta estrutura também é chamada de laço de repetição. Observe que para o caso da
instrução Repita Ate não é necessário utilizar-se os delimitadores Início e Fim, pois o
próprio “corpo” da instrução Repita Até já faz a delimitação dos comandos que devem ser
executados dentro do laço.
Ex: Escrever os números de 1 a 10.
Algoritmo
Declare I numérico
I←1
Repita
Escreva I
I←I+1
até I > 10
fim algoritmo

Obs : A variável I é quem controla o número de repetições do laço. É chamada variável


contadora. Uma variável contadora é uma variável que recebe um valor inicial, é
incrementada de um valor constante no laço e tem seu valor testado em algum ponto do
laço. Ao chegar a um determinado valor o laço é interrompido. A inicialização da variável
contadora deve ir, necessariamente, fora do laço.
Existem diversas maneiras de implementar o mesmo laço, mas todo laço com variável
de controle deve conter:

12
a) inicialização
b) incremento (ou decremento)
c) teste de valor final

Ex. 4.7 Escrever um algoritmo que gera e escreve os números impares entre 100 e 200.
Exerc. Escrever um algoritmo para calcular o fatorial de um número.

ALGORITMOS COM ACUMULADOR

Quando o algoritmo necessitar efetuar alguma totalização usa-se uma variável chamada
acumulador. A variável acumuladora também deve ser inicializada ( normalmente com zero
) e pode ser incrementada ou não de um valor variável no laço.
Ex. 4.6 - Escrever um algoritmo que lê 5 valores para a, um de cada vez, e conta quantos
destes valores são negativos, escrevendo esta informação.

Ex. 4.8 - Escrever um algoritmo que lê 10 valores, um de cada vez, e conta quantos deles
estão no intervalo [10,20] e quantos deles estão fora deste intervalo, escrevendo estas
informações.

Ex. 4.9 - Escrever um algoritmo que lê um número não conhecido de valores, um de


cada vez, e conta quantos deles estão em cada um dos intervalos [0,25], (25,50], (50,75],
(75,100].

Ex. 4.10 - Escrever um algoritmo semelhante ao anterior que calcula as médias


aritméticas de cada intervalo e as escreve, juntamente com o número de valores de cada
intervalo.

A série de Fibonacci é uma sequência de números em que os dois primeiros são 0 e 1 e a


partir daí cada número é a soma dos anteriores, ou seja
tn = tn-1 + tn-2
Escrever um algoritmo que escreve os 10 primeiros termos da série.
Ex. 4.11 - A série de Fibonacci tem como dados os 2 primeiros termos da série que são
respectivamente 0 e 1. A partir deles, os demais termos são construídos pela seguinte regra:
tn = tn-1 + tn-2
Escrever um algoritmo que gera os 10 primeiros termos da Série de Fibonacci e calcula e
escreve a soma destes termos.

Escrever um algoritmo que leia um número N e escreva o número de divisores de N.

13
Algoritmo
Declare N,acum,i numérico
leia N
acum ←0
i←1
Repita
Se Resto(N,i)=0
entao acum←acum+1
i←i+1
até i > N
escreva acum
fim algoritmo

Escrever um algoritmo que leia um número e escreva uma mensagem dizendo: "O
número é primo" ou "O número não é primo" conforme o caso.

Ex. 4.12 - Escrever um algoritmo que gera os 30 primeiros termos da série de Fibonacci
e escreve os termos gerados com a mensagem: "É primo" ou "Não é primo" conforme o
caso.
REFINAMENTOS SUCESSIVOS

É uma técnica para desenvolver um algoritmo em diversos passos aumentando o nível de


detalhamento a cada passo. A partir do problema gerar uma possível solução e detalhá-la
até um nível aceitável.
Ex: Escrever um algoritmo que leia um número e escreva a mensagem "É primo" ou
"Não é primo". Primeira Versão:

Algoritmo
Declare número
Leia número
{Verifica se número é primo}
Se {número é primo}
então escreva "número é primo"
senão escreva "número não é primo"
fim algoritmo

Detalhamentos:
{ Verifica se número é primo }
Um número é primo se é divisível somente por si e pela unidade ( 1 ). Uma maneira de
descobrir isto é contando o número de divisores do número. Se possuir apenas dois
divisores ( 1 e o próprio número ) ele é primo.
{ Verifica se número é primo } ð { Conta número de divisores }
{ Conta número de divisores }

14
acum ← 0
i←1
Repita
Se Resto(Numero,i)=0
então acum←acum+1
i←i+1
até i>número
{ Número é primo }
Se acum=2
então...

Segunda Versão:
Algoritmo
Declare número,i,acum numérico
Leia número
acum ←0
i←1
Repita
Se Resto(número,i)=0
então acum←acum+1
i←i+1
até i > número
Se acum=2
então escreva "número é primo"
senão escreva "número não é primo"
fim se
fim algoritmo

Usar refinamentos sucessivos:


Ex 1.12.30. Escrever um algoritmo para gerar e escrever uma tabela com os valores do
seno de um ângulo A em radianos, utilizando a série de Mac-Laurin truncada com 20
termos:
1 3 5 7

sen(A )= A−A+A−A ...


1! 3! 5! 7!
Os valores dos ângulos A devem variar de 0.0 a 6.3 de 0.1 em 0.1.
Ex. 1.12.40. Fazer um algoritmo que calcule e escreva o cosseno de A usando a série
truncada com 20 termos:
2 4 6 8

cosseno(A )= 1 − A + A − A + A ...
2! 4! 6! 8!
Ex. 1.12.32. O valor aproximado de π pode ser calculado usando-se a série:
1 1 1 1 1
S= 3 − 3 + 3 − 3 + 3 ...
1 3 5 7 9

15
sendo π = 3 S × 32
Fazer um algoritmo para calcular e escrever o valor de π com 51 termos.

ALGORITMOS DE MANIPULAÇÃO DE MATRIZES

Matriz é um conjunto de variáveis, cada uma podendo representar o valor de uma


constante, como se fossem variáveis simples, mas todas elas compartilhando um nome
comum. Índices são associados a este nome comum permitindo individualizar os elementos
do conjunto.
Ex.: conjunto de 5 elementos e nome a
a1 a2 a3 a4 a5

Qual é a utilidade dos matrizes?


Ex.: Deseja-se calcular a média de notas de 10 alunos e determinar quantos ficaram
acima da média. Portanto, deve-se calcular a média de 10 números lidos e determinar
quantos destes números estão acima da média.
Para calcular a média seria o seguinte algoritmo:

algoritmo
declare cont,soma,num numerico
cont ← 10
soma ← 0
repita
leia num
soma ← soma+num
cont ← cont-1
até cont = 0
escreva soma/10
fim algoritmo

Problema: Quando os números são lidos não conhecemos ainda o valor da média. Ao
final do programa anterior não temos mais acesso aos números lidos (pois já foram lidos).
Lê-los novamente seria perda de tempo.
Como fazer este algoritmo sem matrizes?
Resposta: Ler os 10 números e guarda-los em 10 variáveis para testar uma a uma após
obter a média.

Problema: E se fossem 1000 alunos?

16
DECLARAÇÃO DE MATRIZES

Deve-se definir nas declarações:


a) Quais variáveis do algoritmo são do tipo matriz.
b) Quantas dimensões possui cada uma delas.
c) Qual o tamanho de cada dimensão.
d) O tipo dos componentes individuais da matriz.
Notação:
declare <Nome> '(' <tamanho> ')' <tipo>
declare <Nome> '(' <tamanho> ',' <tamanho> ... ')' <tipo>
Ex.: declare a(5),m(6,8) numérico
Convenção: o primeiro índice representa a linha e o segundo a coluna.
Para ler uma matriz é necessário ler cada um dos seus componentes individuais.
Ex.: Ler 5 elementos da matriz a. (3 versões)
ª ª ª
1 Versão (Repita) 2 Versão (Enquanto) 3 Versão (Para)
algoritmo algoritmo algoritmo
declare i,a(5) numérico declare i,a(5) numérico declare i,a(5) numérico
i ←1 i ←1
repita enquanto i <= 5 faça Para i de 1 até 5 faça
leia a(i) início leia a(i)
i ←i+1 leia a(i)
fim algoritmo
até i > 5 i ←i+1
fim algoritmo fim
fim algoritmo
ª
Observe que foram apresentadas três maneiras de se implementar a leitura da matriz “a”. Na 3
versão, a qual utiliza a instrução Para de até faça, observe que não é necessário incrementar a
variável contadora i, pois a própria instrução faz o incremento automaticamente a cada iteração.

Ex.: Ler os 48 elementos da matriz m(6,8)


algoritmo
declare i,j,m(6,8) numérico
i ←1
j ←1
repita
leia m(j,i)
i ←i+1
se i>8 entao
início
i ←1
j ←j+1
fim
até j>6
fim algoritmo

17
Este algoritmo poderia ser feito usado-se dois laços aninhados.
algoritmo
declare i, j, m(6,8) numérico
Para i de 1 até 6 faça
Para j de 1 até 8 faça
leia a(i,j)
fim algoritmo

Ex.: Somar os elementos da diagonal principal de m(10,10), lendo a matriz antes e


escrevendo a soma ao final.
algoritmo
declare soma,i,j,m(10,10) numérico
i ←1
j ←1
repita
leia m(i,j)
i ←i+1
se i>10 entao
i ←1
j ←j+1
fim se
até j > 10
i ←1
soma ←0
repita
soma ←soma+m(i,i)
i ← i+1
até i > 10
escreva soma
fim algoritmo

Exerc.: Calcular a média de 10 alunos de uma disciplina, entrando a nota e o nome do


aluno. Determinar o número de alunos que tiveram nota superior a média e imprimir o
nome dos alunos que tiveram este feito.

Ex. 2.5.1.4. Dado um conjunto de 100 valores numéricos disponíveis na entrada, fazer
um algoritmo para armazená-los em uma matriz e calcular e imprimir o valor do somatório
dado a seguir:

S = (v1− v100) + (v 2 − v 99) + (v 3− v 98) +...+ (v50 − v51)


3 3 3 3

18
Determinar a posição, dentro de uma matriz quadrada, de um elemento pode ser muito
útil em alguns tipos de algoritmos. Por exemplo determinar se determinado elemento está
acima ou abaixo da diagonal principal da matriz.
Algumas relações são importantes para determinar a posição dos elementos de uma
matriz quadrada. Veremos estas relações sobre o seguinte esquema de matriz quadrada:
a11 a12 a13 … a1n
a21 a22 a23 … a2n
a31 a32 a33 … a3n
:
an1 an2 an3 … ann

Sendo i e j os índices dos elementos da matriz:


• Diagonal principal - i=j
• Diagonal secundária - i+j=n+1
• Abaixo da diagonal principal - i>j
• Acima da diagonal principal - i<j
• Acima da diagonal secundária - i+j<n+1
• Abaixo da diagonal secundária - i+j>n+1
Exerc. Escrever um algoritmo para ler um valor n e a seguir ler uma matriz n×n. Então,
determinar a soma de todos os elementos acima da diagonal principal e imprimi-lo.
Exerc. Escrever um algoritmo para ler uma matriz a de tamanho n×m e outra matriz b de
tamanho m×p. Então, determinar e imprimir a matriz produto c de tamanho n×p.

c = ∑a b
ij
k =1
ik kj

19
SUBALGORITMOS

São trechos de algoritmos que efetuam um ou mais cálculos determinados. Ao invés de


escrever-se um algoritmo grande, escrevem-se vários algoritmos menores, os quais, não
isoladamente, mas em conjunto, resolvem o problema proposto.
É conveniente usa-los quando uma determinada tarefa é efetuada em diversos lugares no
mesmo algoritmo.
Ao invés de escrever-se o mesmo trecho diversas vezes, escreve-se o subalgoritmo e o
mesmo é chamado diversas vezes.
As vantagens são:
• Eles reduzem o tamanho do algoritmo.
• Facilitam a compreensão e visualização do algoritmo
• São declarados no algoritmo e podem ser chamados em qualquer ponto após sua
declaração.
Exemplo: Um algoritmo para ordenar 4 valores em ordem crescente.
algoritmo
declare a,b,c,d,aux numerico
leia a,b,c,d
se d>a então
início
aux ←d
d ←a
a ←aux
fim
se d>b então
início
aux ←d
d ←b
b ←aux
fim
se d>c então
início
aux ←d
d ←c
c ←aux
fim
se c>a então
início
aux ←c
c ←a
a ←aux
fim
se c>b então
início
aux ←c

20
c ←b
b ←aux
fim
se b>a então
início
aux ←b
b ←a
a ←aux
fim
escreva a,' ',b,' ',c,' ',d
fim algoritmo

Com subalgoritmos:
1. Definindo troca(x,y)
algoritmo
declare a,b,c,d numerico

{ declaração do subalgoritmo troca}

leia a,b,c,d
se d>a então
troca(d,a)
se d>b então
troca(d,b)
se d>c então
troca(d,c)
se c>a então
troca(c,a)
se c>b então
troca(c,b)
se b>a então
troca(b,a)
escreva a,' ',b,' ',c,' ',d
fim algoritmo

2. Definindo comp_troca(x,y)
algoritmo
declare a,b,c,d numerico

{ declaração do subalgoritmo comp_troca }

leia a,b,c,d
comp_troca(d,a)
comp_troca(d,b)
comp_troca(d,c)
comp_troca(c,a)
comp_troca(c,b)
comp_troca(b,a)
escreva a,' ',b,' ',c,' ',d
fim algoritmo

21
O subalgoritmo é definido após as declarações do corpo principal.
Argumentos (ou parâmetros) são valores enviados ao subalgoritmo para serem
processados, e/ou recebidos do subalgoritmo como resultados do processamento.
Um subalgoritmo pode conter declarações de variáveis, mas as variáveis declaradas nele
(chamadas variáveis locais do subalgoritmo) só podem ser acessadas dentro dele. Além de
suas variáveis locais, um subalgoritmo pode acessar variáveis declaradas fora dele, no
algoritmo principal (chamadas variáveis globais).
Os parâmetros usados na definição do subalgoritmo são chamados parâmetros formais.
Ex.:
algoritmo
declare a,b numerico
subrotina y(c,d)
declare e,f numerico
{ comandos de y }
fim subrotina
subrotina z(e)
declare f numerico
{ comandos de z }
fim subrotina
{ comandos do algoritmo }
fim algoritmo

a,b - variáveis globais (acessadas pelo algoritmo e pelos dois subalgoritmos)


e,f - variáveis locais a y (acessadas apenas pelo subalgoritmo y)
c,d - parâmetros formais de y (usados na hora da chamada de y)
f - variavel local a z (acessada somente pelo subalgoritmo z, não possuindo qualquer
relação com a outra variavel f (local a y)
e - parâmetro formal de z

Os parâmetros usados na chamada de um subalgoritmo são chamados parâmetros reais.


Ex.: soma(10,20)
Existem vários tipos de passagem de parâmetros para subalgoritmo:
• Passagem por valor - envia um valor para o algoritmo e não retorna valores pelo
parâmetro formal (só entrada).
• Passagem Copia-restaura - envia e recebe valores do subalgoritmo (entrada e saída).
• Passagem por referência - envia e recebe valores do subalgoritmo (entrada e saída).
Nos nossos algoritmos usaremos passagem Copia-restaura e por valor.
Indicaremos o tipo copia-restaura antecedendo a palavra reservada CR aos parâmetros
deste tipo.

22
Existem dois tipos de subalgoritmos: subrotinas e funções
a) Subrotinas (ou procedimentos – procedures em inglês )
Retornam valores apenas pelos argumentos.
Declaração:
subrotina <nome>['('<lista de parâmetros formais>')']
{ declarações locais à subrotina }
{ comandos }
fim subrotina

Observe que é possível definir um subalgoritmo dentro de outro, pois não faremos
nenhuma restrição ao que pode ser declarado dentro de um subalgoritmo. Subalgoritmos
declarados dentro de outros são locais a estes.
Ex.: Subrotina troca
subrotina troca(x,y numérico)
declare aux numerico
aux ←x
x ←y
y ←aux
fim subrotina
Esta subrotina não funciona. Porque? (falta definir a passagem de parâmetros Copia-
restaura):
subrotina troca(CR x,y numérico)
declare aux numerico
aux ←x
x ←y
y ←aux
fim subrotina
Exerc.: subrotina comp_troca
b) Funções (Functions em inglês)
Retornam um valor pelo seu nome.
Ex.: ABS(x), TRUNCA(x)
Declaração:
função <tipo> <nome>['('<lista de parâmetros formais')']
{ declarações locais }
{ comandos }
fim função

Chamada:
a ← TRUNCA(3.5)
ou
se SINAL(x)<=0 ...
Retorno do valor pelo nome da função:

23
fatorial ← x
Ex.: função numérico fatorial(n)
função numérico fatorial(n numérico)
declare fat,cont numerico
cont ←1
fat ←1
repita
fat ←fat*cont
cont ←cont +1
até cont > n
fatorial ←fat
fim função

Usando subalgoritmos:
Ex 3.3: escrever um algoritmo que leia as medidas dos três lados a,b e c de um
paralelepípedo, calcule e escreva o valor de sua diagonal.
Ex 3.4: escrever uma função lógica que recebe uma variável unidimensional M de
numericos, o número N de elementos de M, e um valor X e retorne verdadeiro se X
pertence a M ou falso em caso contrário.
Como passar uma matriz? (nao indicar o seu tamanho: encontra(m(),n,x numérico)).
Ex 3.5: escrever uma função que calcule a distância entre dois pontos de um plano,
sendo fornecidas as coordenadas x1, y1 e x2,y2. Escrever, ainda, um algoritmo que leia 10
conjuntos de valores x1,y1,x2,y2 e x3,y3 coordenadas de 10 triangulos e calcule a área dos
10 triangulos.
Ex 3.6: escrever um algoritmo que:
• leia vários pares de números inteiros positivos, M e P.
• calcule e escreva o número de arranjos e combinações de M elementos P a P, dado
pelas fórmulas:
M!
=
P
A M
(M − P)!
M!
=
P
C M
P!(M − P)!
Se M<P, por definição:
=0
P
A M

=0
P
C M

Ao final de cada cálculo de um par é perguntado se deseja continuar. A resposta deve ser
'S' ou 'N'.
Exerc. Utilizando as seguintes séries, com 20 termos:

24
2 3

e = 1 + x + x2! + x3! +...


x

x −1 + 1 x −1 x −1 +...
1 2 3

ln(x)= ( ) 2( ) + 13 ( )
x x x
Faça um algoritmo que gere uma tabela de x, ex, e ln(x), para x variando entre 1 e 100
com intervalos de 0.5 (x=1, x=1.5, x=2, ..., x=100). Defina subalgoritmos onde for
necessário.
Solução: (observe as funções aninhadas e seu escopo)
algoritmo
declare x numérico
{ declarações das funções }
x←1
repita
escreva x,' ',exp2(x),' ',ln2(x)
x ← x+0.5
até x>100
fim algoritmo

Funções:
função numérico exp2(x numérico)
declare soma,ind numérico
função numérico fatorial(n numérico)
declare fat numérico
fat ← 1
repita
fat ← fat*n
n ← n-1
até n = 0
fatorial ← fat
fim função
soma ← 1
ind ← 1
repita
soma ← soma (x**ind)/fatorial(ind)
ind ← ind+1
até ind>19
exp2 ← soma
fim função
função numérico ln2(x numérico)
declare soma,ind numérico
soma ← 0
ind ← 1
repita
soma ← soma+(((x-1)/x)**ind)/ind
ind ← ind+1
até ind > 20
ln2 ← soma
fim função

25
Observe que o laço da função exp2 tem como condição de parada ind>19, pois serão
somados 20 termos e o primeiro é 1 e já foi somado (soma ← 1).
Exerc. A partir das seguintes séries do seno e cosseno, e usando funções, escreva um
algoritmo que gere uma tabela de x, seno, cosseno, tangente, cotangente, secante, e
cossecante para x variando de 0.5 a 1.5 em intervalos de 0.1. Calcule os valores do seno e
do cosseno com erro máximo de 0.0001 (módulo do último termo).
3 5 7

sen(x)= x − x +x −x ...
3! 5! 7!
2 4 6 8

cos seno(x)= 1 − x +x −x +x ...


2! 4! 6! 8!

Relações:

tan(x)= sen(x) cos(x )

cot(x)= 1 tan(x)

sec(x)= 1 cos(x )

cosec(x )= 1 sen(x)

Solução:
algoritmo
declare x numérico
{ declarações de funções }
x ← 0.5
repita
escreva x,' ',sen(x),' ',cos(x),' ',sen(x)/cos(x),' ',cos(x)/sen(x),' ',1/cos(x),
' ',1/sen(x)
x ← x+0.1
até x>1.5
fim algoritmo
Funções:
função numérico fatorial(n numérico)
declare fat,cont numérico
cont ← 1
fat ← 1
repita
fat ← fat*cont
cont ← cont+1
até cont>n
fatorial ← fat
fim função
função numérico sen(x numérico)
declare acum,soma,ind,termo,sinal numérico
acum ← 0
ind ← 1

26
sinal ← 1
repita
termo ← (x**ind)/fatorial(ind)
acum ← acum+termo*sinal
sinal ← -sinal
ind ← ind+2
até abs(termo) < 0.0001
sen ← acum
fim função
função numérico cos(x numérico)
declare acum,ind,termo,sinal numérico
acum ← 1
ind ← 2
sinal ← -1
repita
termo ← (x**ind)/fatorial(ind)
acum ← acum+termo*sinal
ind ← ind+2
sinal ← -sinal
até abs(termo) < 0.0001
cos ← acum
fim função

27
RECURSIVIDADE

Uma função é dita recursiva quando contém, em seu corpo, uma chamada a si mesma
(este tipo de recursividade é chamada recursividade direta). São utilizadas quando é
possível decompor o problema a ser resolvido em problemas menores, um dos quais é
semelhante ao problema inicial.
Ex.: fatorial
n!= n.(n − 1).(n − 2)...3.2.1
n!= n.((n − 1)!)
Uma forma recursiva de definir o fatorial é:
fat(n)=1 para n=0 ou n=1

fat(n)=n.fat(n-1) para n>1


Outro ex.: A soma dos números de 1 a n pode ser definida de forma recursiva como:
soma(1)=1

soma(n)=n+soma(n-1) para n>1


A soma dos números ímpares de 1 a n pode ser definida de forma recursiva por:
somaimp(1)=1

somaimp(n)=n+somaimp(n-1) para n impar e n > 1

somaimp(n)=somaimp(n-1) para n par e n > 1


Algoritmo da função fatorial definida recursivamente:
função numérico fatorial(n numérico)
declare aux numérico
se n=0 OU n=1
então aux ← 1
senão aux ← n*fatorial(n-1)
fatorial ← aux
fim função

Clausulas:
Fatorial(n) = 1 à se n = 0 ou n = 1 - esta é a clausula básica (ou condição de
parada) da função recursiva.
Fatorial(n) = n * Fatorial(n-1) à se n > 1 - esta é a clausula recursiva (que
provoca uma chamada da função recursiva)

28
A execução desta função para uma chamada fatorial(3) é a seguinte:
fatorial(3)

aux=3*fatorial(2) 3*2=6 fatorial=6

aux=2*fatorial(1) 2*1=2 fatorial=2

aux=1

fatorial=1

Exerc.: Definir recursivamente a função que devolve a soma dos números ímpares de 1 a
n. (dica: escrever funções lógicas auxiliares par(n) e impar(n)).
Exerc.: Definir recursivamente a função que determina o n-ésimo termo da série de
fibonacci.
0 1 2 3 4 5 6
0 1 1 2 3 5 8

Solução:
função numérico fibonacci(n numérico)
declare aux numérico
se n=0 OU n=1
então aux ← n
senão aux ← fibonacci(n-1)+fibonacci(n-2)
fim se
fibonacci ← aux
fim função

29
Exerc.: Considere uma seqüência de números onde cada termo é dado pela combinação
dos 4 termos anteriores An=An-4+2.An-3 +3.An-2+4.An-1 e os 4 primeiros termos são:
A1=1 A2 =2 A3=3 A4=4
Escreva uma função recursiva SEQ que receba um número n e retorne o termo An .
Solução:
função numérico seq(n numérico)
declare aux numérico
se n<=4
então aux ← n
senão aux ← seq(n-4)+2*seq(n-3)+3*seq(n-2)+4*seq(n-1)
fim se
seq ← aux
fim função

Exerc.: Dois números são amigos entre si, se a soma dos divisores de cada um deles é
igual ao outro. Exemplo 220 e 284:
Divisores de 220 Divisores de 284
1 1
2 2
4 4
5 71
10 142
11 soma 220
20
22
44
55
110
Soma 284

Faça um algoritmo que leia dois números e verifique se são amigos.


Solução:
algoritmo
declare a,b numérico
{ declaração de funções }
leia a,b
se a=soma(b) E b=soma(a)
entao escreva 'São amigos'
senão escreva 'Não são amigos'
fim algoritmo

30
Funções com solução não recursiva:
função numérico soma(n numérico)
declare aux,ind numérico
ind ← 1
aux ← 0
repita
se resto(n,ind)=0
então aux ← aux+ind
ind ← ind+1
até ind = n
soma ← aux
fim função

Solução recursiva (chamar soma(n,n-1)):


função numérico soma(num,cont numérico)
declare aux numérico
se cont=1
então aux ← 1
senão
se resto(num,cont)=0
então aux ← cont+soma(num,cont-1)
senão aux ← soma(num,cont-1)
soma ← aux
fim função

31
Exemplo: Torre de Hanoi

A B C
Mover 3 discos de A para C=
Mover 2 discos de A para B=
Mover 1 de A para C
Mover 1 de A para B
Mover 1 de C para B
Mover 1 disco de A para C=
Mover 1 de A para C
Mover 2 discos de B para C=
Mover 1 de B para A
Mover 1 de B para C
Mover 1 de A para C
Algoritmo (chamar move(3,1,3,2)):

subrotina move(num,origem,destino,interm numérico)


se num=1
então escreva 'move de ',origem,' para ',destino
senão
início
move(num-1,origem,interm,destino)
move(1,origem,destino,interm)
move(num-1,interm,destino,origem)
fim
fim subrotina

Exemplo: O problema do cavalo.


Exemplo: O problema das oito rainhas.

32
ALGORITMOS DE ORDENAÇÃO

Os algoritmos de ordenação (ou classificação) permitem ordenar os dados em alguma


ordem (crescente ou decrescente). Podem ser aplicados sobre dados numéricos ou
alfabéticos (neste caso deve-se associar uma ordem entre os simbolos alfabéticos).
1. BUBBLE SORT (Método da Bolha)
É um tipo de algoritmo de ordenação por troca com tempo de ordenação proporcional a
N2 trocas.
10 19 13 12 7

10 13 12 7.19

10 12 7.13 19

10 7.12 13 19

7.10 12 13 19
2. SELEÇÃO DIRETA
É um tipo de algoritmo de ordenação por seleção com tempo de ordenação proporcional
a N2 comparações.
10 19 13 12 7

7.19 13 12 10

7 10.13 12 19

7 10 12.13 19

7 10 12 13.19
subrotina selec(CR vet(),inic,fim numérico)
declare elem,pos numérico
se inic<>fim então
início
pos ← menor(vet,inic,fim)
elem ← vet(pos)
vet(pos) ← vet(inic)
vet(inic) ← elem
selec(vet,inic+1,fim)
fim
fim subrotina

33
3. QUICK SORT
É um tipo de algoritmo de ordenação por troca e partição com tempo de ordenação
proporcional a n.log2 n. Baseia-se no princípio que é mais rápido ordenar dois vetores de
n/2 elementos do que um vetor com n elementos.
60 83 25 98 94 36 99 73 45 15 22 10
10 60
60 83
22 60
60 98
15 60
60 94
45 60
60 99
10 22 25 15 45 36 60 73 99 94 98 83

Algoritmo (se x é o vetor e n é o tamanho do vetor, chamar com quick(x,1,n)):

subrotina quick(x(),li,lf numérico)


declare l numérico
se li<lf então
início
partic(x,li,lf,l)
quick(x,li,l-1)
quick(x,l+1,lf)
fim
fim subrotina

34
subrotina partic(x,li,lf,CR l numérico)
declare l1,l2,t numérico
esq lógico
l1 ← li
l2 ← lf
t ← x(l1)
esq ← verdadeiro
repita
se esq então
se t>x(l2) então
início
x(l1) ← x(l2)
l1 ← l1+1
esq ← falso
fim
senão l2 ← l2-1
senão
se t<x(l1) então
início
x(l1) ← x(l2)
l2 ← l2-1
esq ← verdadeiro
fim
senão l1 ← l1+1
até l1>=l2
l ← l1
x(l) ← t
fim subrotina

35