ALGORITMOS

Orientações gerais
O crescimento dos Cursos Tecnológicos específicos e com curta duração (dois a três
anos) gerou uma demanda de livros que tratam diretamente o assunto de maneira clara e
eficiente.
Assim, o livro é indicado aos Cursos Tecnológicos para estudantes e profissionais que
precisam dominar os conceitos e os algoritmos de forma rápida e precisa. O material foi
preparado com a experiência do autor em lecionar a disciplina, somada à sua experiência
profissional e destina-se ao aprendizado da lógica de programação com algoritmos.
O livro utiliza a notação de algoritmos conhecida como Portugol associado ao uso de
fluxogramas (representação lógica por meio de diagramas).
A obra aborda conceitos de programação, estruturas condicionais e de repetição, ve-
tores, matrizes, funções e procedimentos. Os conceitos são acompanhados de exemplos de-
talhados e exercícios propostos para a prática.

Objetivos do material didático

• Apresentar os conceitos básicos sobre lógica.
• Aprender formalizar algoritmos.
• Conhecer operadores e variáveis
• Saber sobre estruturas condicionais.
• Identificar estruturas de repetição.
• Saber manipular Strings e funções matemáticas.
• Conhecer dados homogêneos e heterogêneos.
• Identificar funções, procedimentos e recursividade.
• Saber pesquisar e entender ordenação.

Princípios pedagógicos
O livro Algoritmos é indicado aos cursos tecnológicos para estudantes e profissionais
que precisam dominar os conceitos e os algoritmos de forma rápida e precisa. O material foi
preparado com a experiência do autor em lecionar a disciplina, somada à sua experiência
profissional e destina-se ao aprendizado da lógica de programação com algoritmos.

Articulação do conteúdo
O docente pode recorrer a outras disciplinas para contextualizar as situações apre-
sentadas em sala de aula. As disciplinas do eixo de Gestão e Negócios são adequadas para
promover a interdisciplinaridade que pertence a algoritmos.

12
Atividades complementares
Além das atividades propostas no livro, sugerimos o desenvolvimento de atividades
práticas que possa permitir que o aluno extrapole os conhecimentos adquiridos com o uso
de pesquisa em outros materiais, como internet e livros para a resolução dos problemas já
apresentados, mas com novas técnicas.

Sugestão de leitura
Azevedo, Eduardo e Conci, Aura. Computação gráfica – Teoria e prática. Elsevier. 2003.
KNUTH, D. E. The Art of Computer Programming: Fundamental Algorithms. 3. ed. Addison-
-Wesley, 1997. v. 3.
LAUREANO, M. Estrutura de dados com algoritmos e C. Rio de Janeiro: Editora Brasport, 2007.
_____. Lógica de programação uma abordagem em Pascal. Rio de Janeiro: Editoria Ciência
Moderna, 2010.
SALVETTI, D. D.; BARBOSA, L. M. Algoritmos. Pearson Makron Books, 1998.
VELOSO, P. et al. Estrutura de dados.  Rio de Janeiro: Editora Campus, 1983.

Sugestão de Planejamento
O livro Algoritmos é composto por nove capítulos e apresenta suas respectivas contex-
tualizações técnicas, direcionadas a aprimorar as competências básicas do curso.
O professor pode adequar o conteúdo em função da carga horária disponível para o
curso, que normalmente é de 80 horas (dois semestres), e inserir atividades complementa-
res nos momentos em que perceber essa necessidade.
Quanto à sequência do conteúdo não há uma regra rígida que deva ser seguida, em-
bora seja interessante dar continuidade aos assuntos expostos para melhor aprendizagem.

Semestre 1
Primeiro bimestre
Capítulo 1 – Introdução
Capítulo 2 – Formalizando os algoritmos
Capítulo 3 – Operadores e variáveis
Objetivos
• Conhecer os conceitos básicos sobre lógica; algoritmos.
• Saber sobre o nome do algoritmo.
• Entender comentários; sequência e fluxograma de uma sequência de instrução.
• Identificar operadores aritméticos.
• Utilizar a memória do computador.
13
 Atividades
Iniciar com os conceitos básicos sobre lógica, e enfatizar que o aprendizado da lógica
é essencial para a formação de um bom programador, pois esse aprendizado serve de base
para todas as linguagens de programação, estruturas ou não. Aplicar trabalhos individuais:
“meu primeiro algoritmo” e “primeiras operações matemáticas”.

Segundo bimestre
Capítulo 4 – Estruturas condicionais
Capítulo 5 – Estruturas de repetição
Capítulo 6 – Manipulação de string e funções matemáticas
Objetivos
• Conhecer o comando de seleção se.
• Utilizar o comando senao.
• Entender a verdade encadeada.
• Usar o comando de seleção múltipla – estrutura caso.
• Identificar algoritmos.
• Saber estruturas de repetição com contagem definida; com fim indefinido – verifica-
ção da condição no início.
• Saber sobre variáveis contadoras, somadoras ou acumuladoras – verificação com fim
indefinido e verificação da condição final.
• Manipular caracteres/strings.
• Conhecer recursos matemáticos.

Atividades
As atividades para o Capítulo 4 são dadas sobre os valores verdadeiro e falso, que es-
tão associados a comparações, para tanto, é necessário usar os operadores relacionais, mas
é fundamental conhecê-los bem para a elaboração de um algoritmo. Já para o Capítulo 5,
torna-se necessário repetir um trecho de um programa um determinado número de vezes,
portanto pode ser criado um laço de repetição que efetue o processamento de determinado
trecho tantas vezes quantas forem necessárias. Quanto ao Capítulo 6 é visto que o termo
string serve para identificar uma sequência de caracteres.

Semestre 2
Primeiro bimestre
Capítulo 7 – Dados homogêneos e heterogêneos
Capítulo 8 – Funções, procedimentos e recursividade
14
Objetivos
• Conhecer dados homogêneos – conhecer vetores; registro; combinado registros e ve-
tores.
• Trabalhar com matrizes.
• Conhecer funções, procedimentos e recursividade: escopo de variáveis; procedimen-
tos.

Atividades
No Capítulo 7: uma estrutura de dados, que utiliza somente um tipo de dado em sua
definição é conhecida como dados homogêneos. Variáveis compostas homogêneas corres-
pondem a posições de memória, identificadas por um mesmo nome, individualizado por
índices, e cujo conteúdo é composto do mesmo tipo. Os vetores (também conhecidos como
estrutura de dados unidimensional) e as matrizes (estruturas de dados bidimensionais) são
os representantes dos dados homogêneos. Uma estrutura de dados é chamada de hetero-
gênea quando envolve a utilização de mais de um tipo básico de dado (inteiro ou caractere,
por exemplo) para representar uma estrutura de dados. Normalmente, esse tipo de dado
é chamado de registro. Um registro é uma estrutura de dados que agrupa dados de tipos
distintos ou, mais raramente, do mesmo tipo. Um registro de dados é composto por certo
número de campos de dados, que são itens de dados individuais.
Para o Capítulo 8: um algoritmo é uma sequência de instruções. À medida que cresce,
ele pode tornar-se complexo e pouco legível. Além disso, certas sequências de comandos
podem ser usadas com frequência em diversos pontos do algoritmo, tendo de ser inteira-
mente reescritas em cada um desses pontos, o que certamente é redundante e uma fonte de
erros. Para enfrentar essa situação podemos dividir nosso programa em módulos, separan-
do logicamente as diferentes etapas do programa. A programação modular é uma técnica
que tem por objetivo simplificar o desenvolvimento de programas por meio de sua divisão
em partes. Cada uma dessas partes pode ser mais facilmente entendida, programada, testa-
da e modificada, pois o problema que está sendo resolvido é menor. Além disso, podemos
agrupar trechos de código frequentemente usados em um módulo separado, que pode ser
ativado a partir de diversos pontos de um algoritmo. Logo, um módulo, é um conjunto de
comandos, constituindo um trecho de algoritmo, com uma função bem definida e o mais
independente possível em relação ao restante do código. A maioria das linguagens de pro-
gramação estruturadas suporta dois tipos de módulos: funções e procedimentos.

Segundo bimestre
Capítulo 9 – Pesquisa e ordenação
Objetivos
• Pesquisa sequencial.
• Saber ordenar com BubbleSort.
• Pesquisa binária.

15
 Atividades
Explicar que encontrar informações em arquivo desordenado requer uma pesquisa
sequencial começando no primeiro elemento e parando quando o elemento procurado, ou o
final do arquivo, é encontrado. Esse método deve ser usado em dados desordenados, poden-
do ser aplicado também a dados ordenados. Se os dados foram ordenados, pode-se utilizar
uma pesquisa binária, o que ajuda a localizar o dado mais rapidamente.

Orientações didáticas e respostas das

atividades
Capítulo1
Orientações
Alguns autores tratam algoritmos como representação de um pseudocódigo utilizan-
do palavras-chaves formalizadas; para outros, o termo algoritmo é utilizado para descrever
apenas a sequência lógica dos passos independente da formalização. Este último caso tam-
bém é conhecido como português estruturado. No livro é trabalhado com pseudocódigos
formalizados, utilizando palavras-chaves para representar os problemas que vamos resol-
ver. No nosso caso, podemos dizer também que estamos trabalhando com Portugol (algo-
ritmos em português).
Passos para a construção de um bom algoritmo:
1. Ler atentamente o enunciado para compreender o problema, analisando a situação a
ser representada.
2. Identificar as entradas e saídas de dados, ou seja, as informações a fornecer ao progra-
ma e os resultados que este deve retornar.
3. Determinar o que deve ser feito para transformar as entradas recebidas nas saídas
desejadas.
4. Dividir o problema em suas partes principais (módulos), para facilitar a compreensão
do todo (estratégia “dividir para conquistar”).
5. Analisar a divisão obtida para garantir sua coerência.
6. Subdividir as partes mal compreendidas.
7. Construir o algoritmo.
8. Executar manualmente o algoritmo, para testá-lo.

Resposta – página 17
1) A resposta é a critério do aluno.
2) A resposta é a critério do aluno.

16
3) A resposta é a critério do aluno.
4) A resposta é a critério do aluno.

Capítulo 2
Orientações
No Capítulo 2 é apresentado o “nosso primeiro exemplo de algoritmo”. Portanto, o
professor deve enfatizar as características (algoritmo 2.1), como: o algoritmo tem um nome;
existem comentários; está organizado com espaços em branco (indentação); está organiza-
do em uma sequência lógica.

Resposta – página 22
1)

algoritmo “resp_algo_02_01.alg”
// Função : mostrar uma mensagem na tela
// Autor : Marcos Laureano
inicio
  escreval(«O primeiro algoritmo a gente nunca esquece!»)
  escreval(«Fim do Algoritmo»)
fimalgoritmo

2) A resposta é a critério do aluno.
3)

algoritmo “resp_algo_02_03.alg”
// Função : mostrar uma mensagem na tela
// Autor : Marcos Laureano
inicio
  escreval(«Isto não vai dar certo.»)
  escreval(«Você nunca vai conseguir.»)
escreval(“Você vai se estrepar.”)
  escreval(«Não vai dar em nada.»)
escreval(“Está tudo errado!”)
  escreval(«Fim do Algoritmo»)
fimalgoritmo

4) A resposta é a critério do aluno.

17
 5)

algoritmo “resp_algo_02_05.alg”
// Função : mostrar uma mensagem na tela
// Autor : Marcos Laureano
inicio
  escreval(«Desenvolver raciocínio lógico»)
  escreval(«Dominar algoritmos»)
  escreval(«E passar de ano»)
  escreval(«Fim do Algoritmo»)
fimalgoritmo

Capítulo 3
Orientações
O objetivo geral do Capítulo 3 é dar sequência aos exercícios, ou seja, praticar o uso
de variáveis e a leitura dos dados a partir do teclado, perceber as diferenças entre números
inteiros e reais e trabalhar com os diversos operadores matemáticos.

Resposta – páginas 35-36

1)

algoritmo “resp_algo_03_01.alg”
// Função : permuta de 2 valores
// Autor : Marcos Laureano
var
  a,b, temporario: inteiro
inicio
  //solução com permuta
  escreva(«Entre com o valor de A:»)
  leia(a)
  escreva(«Entre com o valor de B:»)
  leia(b)
  
  temporario <- b
  b <- a
  a <- temporario
  
  escreval(«A = «, a, « e B=», b)

  //solução matemática
  escreva(«Entre com o valor de A:»)
  leia(a)
  escreva(«Entre com o valor de B:»)
  leia(b)

18
   a <- a + b
  b <- b + a
  a <- b - a
  b <- b-2* a

  escreval(«A = «, a, « e B=», b)

  escreval(«Fim do Algoritmo»)
fimalgoritmo

2)

algoritmo “resp_algo_03_02.alg”
// Função : cálculo de média
// Autor : Marcos Laureano
var
  media, n1, n2, n3, n4: real
inicio
  escreva(«Entre com a nota 1:»)
  leia(n1)

  escreva(«Entre com a nota 2:»)

  leia(n2)
  
  escreva(«Entre com a nota 3:»)
  leia(n3)

  escreva(«Entre com a nota 4:»)

  leia(n4)

  media <- (n1 + n2*2 + n3*3 + n4*4 )/10

  
  escreval(«A média do aluno é:», media)

  escreval(«Fim do Algoritmo»)
fimalgoritmo

3)

algoritmo “resp_algo_03_03.alg”
// Função : caminhada
// Autor : Marcos Laureano
var
  distancia: real
inicio

  distancia <- 1.6 * 5 * 45

  escreval(«Distância em KM:», distancia)
  escreval(«Fim do Algoritmo»)
fimalgoritmo

19
 4) A resposta é a critério do aluno.
5)

algoritmo “resp_algo_03_04.alg”
// Função : cálculo de média
// Autor : Marcos Laureano
var
  media, n1, n2, n3: real
inicio
  escreva(«Entre com a nota 1:»)
  leia(n1)

  escreva(«Entre com a nota 2:»)

  leia(n2)
  
  escreva(«Entre com a nota 3:»)
  leia(n3)

  media <- (n1 + n2*2 + n3*3 )/6

  
  escreval(«A média do aluno é:», media)

  escreval(«Fim do Algoritmo»)
fimalgoritmo

6) A resposta é a critério do aluno.
7)

algoritmo “resp_algo_03_05.alg”
// Função : conversão temperatura
// Autor : Marcos Laureano
var
  fahrenheit, celsius: real
inicio
  escreva(«Entre com a temperatura Fahrenheit:»)
  leia(fahrenheit)

  celsius <- (5/9) * (fahrenheit-32)

  escreval(«A a temperatura é:», celsius)

  escreval(«Fim do Algoritmo»)
fimalgoritmo

8) A resposta é a critério do aluno.
9) A resposta é a critério do aluno.

20
10)

algoritmo “resp_algo_03_06.alg”
// Função : construção de casas
// Autor : Marcos Laureano
var
  dolar, salario, casas: real
inicio
  escreva(«Entre com a cotação do dólar:»)
  leia(dolar)

  escreva(«Entre com o valor do salário:»)

  leia(salario)

  casas <- (10000000*dolar)/(150*salario)

  escreval(«Foram construídas «, casas, « casas.»)

  escreval(«Fim do Algoritmo»)
fimalgoritmo

11)

algoritmo “resp_algo_03_08.alg”
// Função : cálculo de juros
// Autor : Marcos Laureano
var
  valorTotal, notas100, resto, notas50, notas10, notas05:
inteiro
inicio
  escreva(«Entre com o valor:»)
  leia(valorTotal)

  notas100 <- valorTotal / 100

  resto <- valorTotal % 100

  notas50 <- resto / 50

  resto <- resto % 50

  notas20 <- resto / 20

  resto <- resto % 20

  notas10 <- resto / 10

  resto <- resto % 10

  notas05 <- resto / 5

  resto <- resto % 5

  notas01 = resto

21
   escreval(«Notas necessárias:»)
  escreval(«100 -> «, notas100)
  escreval(« 50 -> «, notas50)
  escreval(« 20 -> «, notas20)
  escreval(« 10 -> «, notas10)
  escreval(« 5 -> «, notas05)
  escreval(« 1 -> «, notas01)

  escreval(«Fim do Algoritmo»)
fimalgoritmo

12)

algoritmo “resp_algo_03_08.alg”
// Função : cálculo de juros
// Autor : Marcos Laureano
var
  prestacao, taxa, valor: real
  dias: inteiro
inicio
  escreva(«Entre com o valor:»)
  leia(valor)

  escreva(«Entre com a taxa:»)

  leia(taxa)

  escreva(«Entre com os dias em atraso:»)

  leia(dias)

  prestacao <- valor + (valor*(taxa/100)*dias)

  escreval(«Valor da prestação:», prestacao)

  escreval(«Fim do Algoritmo»)
fimalgoritmo

Capítulo 4
Orientações
Os valores verdadeiro e falso normalmente estão associados a comparações. Para que
haja comparações é necessário utilizar os operadores relacionais (tabela 4.1). Assim, é fun-
damental conhecê-los dada a sua importância na elaboração de um algoritmo.
Em todos os algoritmos são utilizadas expressões relacionais e lógicas para a tomada
de decisões e consequente desvio do fluxo do algoritmo. Os operadores relacionais servem
para realizar a comparação de dois valores distintos. Portanto, para esse capítulo promover
um “bate-papo” em relação a comparações.

22
 Regras práticas para a construção de algoritmos legíveis:
1. Procure incorporar comentários no algoritmo, pelo menos para descrever o significa-
do das variáveis utilizadas. Os comentários deverão acrescentar alguma coisa e não
apenas parafrasear os comandos. O conjunto de comandos nos diz o que está sendo
feito e os comentários deverão nos dizer por quê.
2. Escolha nomes de variáveis que sejam significativos, isto é, que traduzam o tipo de
informação a ser armazenada na variável.
3. Padronize a sua forma de escrever os comandos. Os comandos do algoritmo pode-
riam ser escritos sempre com a primeira letra em maiúscula e demais minúsculas(Se,
Senao, etc.). Evite misturar caixa-alta com caixa-baixa no seu algoritmo; se você come-
çou a desenvolver tudo em caixa-baixa, mantenha o padrão.
4. Procure alinhar os comandos de acordo com o nível a que pertençam, isto é, destaque
a estrutura na qual estão contidos. Utilize espaços em branco para melhorar a legibili-
dade. Espaços em branco, inclusive linhas em branco, são valiosíssimos para melhorar
a aparência de um algoritmo. Exemplos de uso:
a) Deixar uma linha em branco entre as declarações e o corpo do algoritmo.
b) Deixar uma linha em branco antes e outra depois de um comentário.
c) Separar grupos de comandos que executam funções lógicas distintas por uma ou
mais linhas em branco.
d) Utilizar espaços em brancos para indicar precedência de operadores. Ao invés de
utilizar A + B * C, poderia ser utilizado A + B*C.

Respostas – página 57
1)

algoritmo “resp_algo_04_01.alg”
// Função : pescaria
// Autor : Marcos Laureano
var
  multa: real
  excesso,peso: inteiro
inicio
  escreva(«Entre a quantidade pescada:»)
  leia(peso)
  
  excesso <- 0
  multa <- 0
  se peso > 50 entao
     excesso <- peso - 50
     multa <- excesso * 7
  fimse
  
  escreval(«Excesso:», excesso)
  escreval(«Multa:», multa)

  escreval(«Fim do Algoritmo»)
fimalgoritmo

23
 2)

algoritmo “resp_algo_04_02.alg”
// Função : nome
// Autor : Marcos Laureano
var
  nome: caractere

inicio
  escreva(«Entre com o seu nome:»)
  leia(nome)
  
  se nome = «Marcos Laureano» entao
     escreval(«Nome correto!»)
  senao
     escreval(«Nome incorreto!»)
  fimse
  
  escreval(«Fim do Algoritmo»)
fimalgoritmo

3)

algoritmo “resp_algo_04_03.alg”
// Função : placar
// Autor : Marcos Laureano
var
  gols1time, gols2time: inteiro

inicio
  escreva(«Entre com os gols do 1 time:»)
  leia(gols1time)

  escreva(«Entre com os gols do 2 time:»)

  leia(gols2time)
  
  se gols1time > gols2time entao
     escreval(«Vitória do 1 time.»)
  senao
     se gols1time < gols2time entao
        escreval(«Vitória do 2 time.»)
     senao
        escreval(«Empate.»)
     fimse
  fimse

  escreval(«Fim do Algoritmo»)
fimalgoritmo

24
4)

algoritmo “resp_algo_04_04.alg”
// Função : conversão de moedas
// Autor : Marcos Laureano
var
  quantidadePossui, quantidadeDeseja: real
  moedaPossui, moedaDeseja: caractere

inicio
  escreva(«Escreva o tipo da moeda que você tem:»)
  leia(moedaPossui)
  
  escreva(«Quantidade da moeda atual:»)
  leia(quantidadePossui)
  
  escreva(«Escreva o tipo da moeda que você quer:»)
  leia(moedaDeseja)

  quantidadeDeseja <- 0
  
  escolha moedaPossui
     //trocando ouro por outra moeda
     caso «Ouro»
        se moedaDeseja = «Prata» entao
           quantidadeDeseja <- quantidadePossui*50
        senao
           se moedaDeseja = «Cobre» entao
              quantidadeDeseja <- quantidadePossui*2500

           senao
              quantidadeDeseja <- quantidadePossui //assume a mesma
quantidade
           fimse
        fimse

     //trocando prata por outra moeda

     caso «Prata»
        se moedaDeseja = «Ouro» entao
           quantidadeDeseja <- quantidadePossui/50
        senao
           se moedaDeseja = «Cobre» entao
              quantidadeDeseja <- quantidadePossui*50
           senao
              quantidadeDeseja <- quantidadePossui //assume a mesma
quantidade

           fimse
        fimse

25
      //trocando cobre por outra moeda
     caso «Cobre»
        se moedaDeseja = «Ouro» entao
           quantidadeDeseja <- quantidadePossui/2500
        senao
           se moedaDeseja = «Prata» entao
              quantidadeDeseja <- quantidadePossui/50
           senao
              quantidadeDeseja <- quantidadePossui //assume a mesma
quantidade
           fimse
        fimse
  fimescolha
  
  escreval(«Você terá «, quantidadeDeseja, « de «, moedaDeseja)

  escreval(«Fim do Algoritmo»)
fimalgoritmo

5)

algoritmo “resp_algo_04_05.alg”
// Função : imposto
// Autor : Marcos Laureano
var
  valor, imposto: real
inicio

  escreva(«Entre com o valor:»)

  leia(valor)
  
  imposto <- 0
  
  se valor < 1200 entao
     imposto <- 0
  senao
     se valor < 5000 entao
        imposto <- valor * 0.10
     senao
        se valor < 10000 entao
           imposto <- valor * 0.15
        senao
           imposto <- valor * 0.20
        fimse
     fimse
  fimse

  escreval(«Imposto a ser pago R$», imposto)

  escreval(«Fim do Algoritmo»)
fimalgoritmo

26
Capítulo 5
Orientações
Em vários momentos, na programação, torna-se necessário repetir um trecho de um
programa um determinado número de vezes. Neste caso, pode ser criado um laço de re-
petição que efetue o processamento de um determinado trecho por tantas vezes quantas
forem necessárias. Os laços de repetição também são conhecidos por loopings. Portanto, o
Capítulo 5 traz as estruturas de repetição.

Respostas – página 69
1)

algoritmo “resp_algo_05_01.alg”
// Função : soma dos números de 1 até 100
// Autor : Marcos Laureano
var
  soma, numero: inteiro
inicio

  //com enquanto
  soma <- 0
  numero <- 1
  enquanto numero <= 100 faca
     soma <- soma + numero
     numero <- numero + 1
  fimenquanto
  
  escreval(«Soma:», soma)

  //com para
  soma <- 0
  para numero de 1 ate 100 passo 1 faca
     soma <- soma + numero
  fimpara

  escreval(«Soma:», soma)

  //com repita
  soma <- 0
  numero <- 1
  repita
     soma <- soma + numero
     numero <- numero + 1
  ate numero > 100
  escreval(«Soma:», soma)

  escreval(«Fim do Algoritmo»)
fimalgoritmo

27
 2)

algoritmo “resp_algo_05_02.alg”
// Função : soma dos números pares de 1 até 100
// Autor : Marcos Laureano
var
  soma, numero: inteiro
inicio

  //lembrar que poderia incrementar o número de 2 em 2 começando

com número
  // em 0
  //com enquanto
  soma <- 0
  numero <- 1
  enquanto numero <= 100 faca
     se numero % 2 = 0 entao
        soma <- soma + numero
     fimse
     numero <- numero + 1
  fimenquanto
  
  escreval(«Soma:», soma)

  //com para
  soma <- 0
  para numero de 1 ate 100 passo 1 faca
     se numero % 2 = 0 entao
        soma <- soma + numero
     fimse
  fimpara

  escreval(«Soma:», soma)

  //com repita
  soma <- 0
  numero <- 1
  repita
     se numero % 2 = 0 entao
        soma <- soma + numero
     fimse
     numero <- numero + 1
  ate numero > 100
  escreval(«Soma:», soma)

  escreval(«Fim do Algoritmo»)
fimalgoritmo

28
3)

algoritmo “resp_algo_05_03.alg”
// Função : soma dos números ímpares de 1 até 100
// Autor : Marcos Laureano
var
  soma, numero: inteiro
inicio

  //lembrar que poderia colocar uma condição para verificar se o

número é ímpar
  //com enquanto
  soma <- 0
  numero <- 1
  enquanto numero <= 100 faca
     soma <- soma + numero
     numero <- numero + 2
  fimenquanto
  
  escreval(«Soma:», soma)

  //com para
  soma <- 0
  para numero de 1 ate 100 passo 2 faca
     soma <- soma + numero
  fimpara

  escreval(«Soma:», soma)

  //com repita
  soma <- 0
  numero <- 1
  repita
     soma <- soma + numero
     numero <- numero + 2
  ate numero > 100
  escreval(«Soma:», soma)

  escreval(«Fim do Algoritmo»)
fimalgoritmo

29
 4)

algoritmo “resp_algo_05_04.alg”
// Função : faixa de valores
// Autor : Marcos Laureano
var
  n1, n2, multiplicacao, termo: inteiro
inicio

  repita
     escreva(«Entre com o número 1:»)
     leia(n1)
  ate n1 > 0

  repita
     escreva(«Entre com o número 1:»)
     leia(n2)
  ate (n2 > 0) e (n1 < n2)
  
  multiplicacao <- 1 //valor neutro da multiplicacao
  
  para termo de n1 ate n2 passo 1 faca
     multiplicacao <- multiplicacao * termo
  fimpara
  escreval(«Valor da multiplicação:», multiplicacao)

  escreval(«Fim do Algoritmo»)
fimalgoritmo

5) A resposta é a critério do aluno.
6) A resposta é a critério do aluno.

Capítulo 6
Orientações
O termo string serve para identificar uma sequência de caracteres. Na prática, elas são
usadas para representar textos. Uma string ou cadeia de caracteres é um conjunto de carac-
teres alfanumérico, normalmente representado pelos caracteres disponíveis no teclado de
um computador. É uma expressão contendo qualquer caractere alfanumérico, formando ou
não palavras, por exemplo, a sequência “abc1234” é considerada uma string.
Para esse capítulo, o professor deve aplicar trabalhos individuais, como exemplo: o
comando asc para descobrir o valor numérico de um caractere.

30
Respostas – página 76
1)

algoritmo “resp_algo_06_01.alg”
// Função : separando frases por espaços em branco
// Autor : Marcos Laureano
var
  frase, palavra, frase_parcial: caractere
  posicao_branco:inteiro
inicio
  escreva(«Informe a frase:»)
  leia(frase)
  posicao_branco <- pos(« «, frase) //descobre onde está o espaço em branco
  frase_parcial <- frase
  enquanto posicao_branco <> 0 faca
     palavra <- copia(frase_parcial, 0, posicao_branco-1)
     frase_parcial <- copia(frase_parcial, posicao_branco+1,
compr(frase_parcial))
     posicao_branco <- pos(« «, frase_parcial)
     escreval(«Palavras separada [«, palavra, «]»)
  fimenquanto
  palavra <- frase_parcial //última palavra
  escreval(«Palavras separada [«, palavra, «]»)
  escreval(«Fim do Algoritmo»)
fimalgoritmo

2)

algoritmo “resp_algo_06_02.alg”
// Função : triângulo
// Autor : Marcos Laureano
var
  ladoA, ladoB, ladoC: inteiro
inicio
  escreva(«Informe o tamanho do lado A:»)
  leia(ladoA)

  escreva(«Informe o tamanho do lado B:»)

  leia(ladoB)

  escreva(«Informe o tamanho do lado C:»)

  leia(ladoC)
  
  se ( abs(ladoB-ladoC) < ladoA)  e (ladoA < ladoB+ladoC) entao
     se (ladoA = ladoB) e (ladoA = ladoC) entao
        escreval(«Triângulo equilatéro.»)
     senao
        se (ladoA = ladoB) ou (ladoA = ladoC) ou (ladoB=ladoC) entao
           escreval(«Triângulo isósceles.»)

31
         senao
           escreval(«Triângulo escaleno.»)
        fimse
     fimse
  senao
     escreval(«Não forma triângulo!»)
  fimse

  escreval(«Fim do Algoritmo»)
fimalgoritmo

3)

algoritmo “resp_algo_06_03.alg”
// Função : repetição de letras
// Autor : Marcos Laureano
var
  frase, letra: caractere
  letraA, letraE, letraI, letraO, letraU, posicao:inteiro
inicio
  escreva(«Informe a frase:»)
  leia(frase)
  letraA <- 0
  letraE <- 0
  letraI <- 0
  letraO <- 0
  letraU <- 0
  posicao <- 1
  
  enquanto posicao <= compr(frase) faca
     letra <- copia(frase, posicao, 1)
     escreval(letra)
     escolha letra
        caso «A»,»a»
           letraA <- letraA+1
        caso «E»,»e»
           letraE <- letraE+1
        caso «I»,»i»
           letraI <- letraI+1
        caso «O»,»o»
           letraO <- letraO+1
        caso «U»,»u»
           letraU <- letraU+1
     fimescolha
     posicao <- posicao + 1
  fimenquanto
  escreval(«Quantidade de letras A:», letraA)
  escreval(«Quantidade de letras E:», letraE)
  escreval(«Quantidade de letras I:», letraI)
  escreval(«Quantidade de letras O:», letraO)
  escreval(«Quantidade de letras U:», letraU)
  escreval(«Fim do Algoritmo»)
fimalgoritmo

32
Capítulo 7
Orientações
No Capítulo 7 é apresentado dado homogêneo, ou seja, é hora de conhecer os
vetores. E isso quer dizer que os vetores são utilizados para armazenar uma lista
de valores do mesmo tipo, isto é, o tipo vetor permite armazenar mais de um valor
em uma mesma variável. Um dado vetor é definido como tendo um número fixo de
células idênticas (seu conteúdo é dividido em posições). Cada célula armazena um, e
somente um, dos valores de dados do vetor. Os índices de um vetor irão sempre come-
çar de um (1). Na literatura, os vetores também são conhecidos como arrays.

Respostas – páginas 87-88

1)

algoritmo “resp_algo_07_01.alg”
// Função : leitura de vetores e cálculo da média
// Autor : Marcos Laureano
var
  soma, media: real
  numeros: vetor [1..20] de inteiro
  contador: inteiro
inicio
  para contador de 1 ate 20 passo 1 faca
     escreva(«Entre com o valor para a posição «, contador, «:»)
     leia(numeros[contador])
  fimpara
  
  soma <- 0
  para contador de 1 ate 20 passo 1 faca
     soma <- soma + numeros[contador]
  fimpara
  
  media <- soma/20
  
  escreval(«A média é:», media)

  escreval(«Fim do Algoritmo»)
fimalgoritmo

33
 2)

algoritmo “resp_algo_07_02.alg”
// Função : leitura de vetores e pesquisa
// Autor : Marcos Laureano
var
  numeros: vetor [1..10] de inteiro
  contador, valor_pesquisa: inteiro
inicio

  aleatorio on
  para contador de 1 ate 10 passo 1 faca
     escreva(«Entre com o valor para a posição «, contador, «:»)
     leia(numeros[contador])
  fimpara
  aleatorio off

  repita
     escreva(«Leia o valor da pesquisa:»)
     leia(valor_pesquisa)
     
     para contador de 1 ate 10 passo 1 faca
        se numeros[contador] = valor_pesquisa entao
           escreval(«Valor encontrado na posição:», contador)
        fimse
     fimpara
  ate valor_pesquisa = 0

  escreval(«Fim do Algoritmo»)
fimalgoritmo

3)

algoritmo “resp_algo_07_03.alg”
// Função : leitura de vetores com inversão
// Autor : Marcos Laureano
var
  numeros, invertido: vetor [1..50] de inteiro
  contador_numeros, contador_invertido: inteiro
inicio

//   aleatorio on
  para contador_numeros de 1 ate 50 passo 1 faca
     escreva(«Entre com o valor para a posição «, contador_
numeros, «:»)
     leia(numeros[contador_numeros])
  fimpara
//   aleatorio off
  contador_invertido <- 50
  para contador_numeros de 1 ate 50 passo 1 faca
     invertido[contador_invertido] <- numeros[contador_numeros]
     contador_invertido <- contador_invertido - 1
  fimpara

34
   //impressão do resultado
  para contador_numeros de 1 ate 50 passo 1 faca
     escreval(«Posição «, contador_numeros, « original=»,
numeros[contador_numeros], « invertido=», invertido[contador_
numeros])
  fimpara

  escreval(«Fim do Algoritmo»)
fimalgoritmo

4)

algoritmo “resp_algo_07_04.alg”
// Função : leitura de vetores de letras com pesquisa
// Autor : Marcos Laureano
var
  letras : vetor [1..30] de caractere
  contador, ocorrencias: inteiro
  letra:caractere
inicio

  para contador de 1 ate 30 passo 1 faca

     escreva(«Entre com a letra para a posição «, contador, «:»)
     leia(letras[contador])
  fimpara

  escreva(«Entre com a letra:»)

  leia(letra)
  
  ocorrencias <- 0
  para contador de 1 ate 30 passo 1 faca
     se letras[contador] = letra entao
        ocorrencias <- ocorrencias + 1
     fimse
  fimpara
  
  escreval(«Quantidade de ocorrências:», ocorrencias)

  escreval(«Fim do Algoritmo»)
fimalgoritmo

35
 5)

algoritmo “resp_algo_07_05.alg”
// Função : definiçã do registro de viagem
// Autor : Marcos Laureano
var
  viagem : registro
  inicio
    data, origem, destino: caractere
    codigo, numero_assento:inteiro
    hora, minuto: inteiro
    tempo_viagem: real
    fumante : logico
  fimregistro
inicio

  escreval(«Fim do Algoritmo»)
fimalgoritmo

6)

algoritmo “resp_algo_07_06.alg”
// Função : definição do registro de viagem
// Autor : Marcos Laureano
var
  viagem : registro
  inicio
    data, origem, destino: caractere
    codigo, numero_assento:inteiro
    hora, minuto: inteiro
    tempo_viagem: real
    fumante : logico
  fimregistro

  eFumante: caractere
inicio
  escreval(«Entre com os dados da viagem:»)
  escreva(«Data:»)
  leia(viagem.data)

  escreva(«Código:»)
  leia(viagem.codigo)

  escreva(«Origem:»)
  leia(viagem.origem)

  escreva(«Destino:»)
  leia(viagem.destino)

  escreva(«Número assento:»)
  leia(viagem.numero_assento)

36
   escreva(«Hora partida:»)
  leia(viagem.hora)

  escreva(«Minuto partida:»)
  leia(viagem.minuto)

  escreva(«Tempo viagem:»)
  leia(viagem.tempo_viagem)

  escreva(«Fumante:»)
  leia(eFumante)

  se eFumante = «Sim» entao

     viagem.fumante <- verdadeiro
  senao
     viagem.fumante <- falso
  fimse

  escreval(«Fim do Algoritmo»)
fimalgoritmo

7)  

algoritmo “resp_algo_07_07.alg”
// Função : notas de aluno
// Autor : Marcos Laureano
var
  aluno : registro
  inicio
     nome,situacao: caractere
     matricula: inteiro
     nota1, nota2, nota3, nota4, media:real
  fimregistro
  
  alunos: vetor[1..50] de aluno
  
  qtdAlunos, contador: inteiro
inicio
  escreva(«Entre com a quantidade de alunos:»)
  leia(qtdAlunos)
   
  para contador de 1 ate qtdAlunos passo 1 faca
     escreval(«Entre com os dados do aluno:»)
     escreva(«Nome:»)
     leia(alunos[contador].nome)
     escreva(«Matrícula:»)
     leia(alunos[contador].matricula)
     escreva(«Nota 1:»)
     leia(alunos[contador].nota1)
     escreva(«Nota 2:»)
     leia(alunos[contador].nota2)
     escreva(«Nota 3:»)
     leia(alunos[contador].nota3)
     escreva(«Nota 4:»)
     leia(alunos[contador].nota4)
      

37
      alunos[contador].media <- ( alunos[contador].nota1 +
                                 alunos[contador].nota2 +
                                 alunos[contador].nota3 +
                                 alunos[contador].nota4 )/4

     se alunos[contador].media >= 7 entao

        alunos[contador].situacao <- «Aprovado»
     senao
        se alunos[contador].media >= 4 entao
           alunos[contador].situacao <- «Final»
        senao
           alunos[contador].situacao <- «Reprovado»
        fimse
     fimse
  fimpara
  escreval(«Fim do Algoritmo»)
fimalgoritmo

8)

algoritmo “resp_algo_07_08.alg”
// Função : leitura de matrizes, criando um terceira
// Autor : Marcos Laureano
var

  matrizA,matrizB: vetor [1..4, 1..3] de inteiro

  matrizC: vetor [1..4, 1..3] de logico
  linha, coluna: inteiro
inicio

  aleatorio on
  //leitura da matriz
  para linha de 1 ate 4 passo 1 faca
     para coluna de 1 ate 3 passo 1 faca
        escreva(«MATRIZ A: Entre com um número para «, linha,
«,», coluna, «:»)
        leia(matrizA[linha, coluna])
        escreva(«MATRIZ B: Entre com um número para «, linha,
«,», coluna, «:»)
        leia(matrizB[linha, coluna])
     fimpara
  fimpara
  aleatorio off

  //criando a terceira matriz

  para linha de 1 ate 4 passo 1 faca
     para coluna de 1 ate 3 passo 1 faca
        matrizC[linha,coluna] <- matrizA[linha,coluna]=matrizB[l
inha,coluna]
     fimpara
  fimpara
  

38
   //impressao
  para linha de 1 ate 4 passo 1 faca
     para coluna de 1 ate 3 passo 1 faca
        escreva(matrizC[linha,coluna], « «)
     fimpara
     escreval //linha em branco
  fimpara

  escreval(«Fim do Algoritmo»)
fimalgoritmo

9)

algoritmo “algo_07_09.alg”
// Função : procura o minimax
// Autor : Marcos Laureano
var

  matriz: vetor [1..10, 1..10] de inteiro

  linha, coluna, maior, menor: inteiro
  linhaMaior, colunaMenor: inteiro
inicio

  aleatorio on
  //leitura da matriz
  para linha de 1 ate 10 passo 1 faca
     para coluna de 1 ate 10 passo 1 faca
        escreva(«Entre com um número para «, linha, «,», coluna,
«:»)
        leia(matriz[linha, coluna])
     fimpara
  fimpara
  aleatorio off

  //assume que o primeiro elemento da matriz é o maior

  maior <- matriz[1,1]
  linhaMaior <- 1

  para linha de 1 ate 10 passo 1 faca

     para coluna de 1 ate 10 passo 1 faca
        //primeiro verifico se é o maior elemento
        se matriz[linha,coluna] > maior entao
           maior <- matriz[linha,coluna]
           linhaMaior <- linha
        fimse
     fimpara
  fimpara

39
   //agora procuramos o menor elemento apenas naquela linha
  menor <- matriz[linhaMaior,1]
  para coluna de 1 ate 10 passo 1 faca
     se matriz[linhaMaior,coluna] < menor entao
        menor <- matriz[linhaMaior,coluna]
        colunaMenor <- coluna
     fimse
  fimpara

  //imprimindo toda a matriz na tela

  para linha de 1 ate 10 passo 1 faca
     para coluna de 1 ate 10 passo 1 faca
        escreva(matriz[linha, coluna], « «)
     fimpara
     escreval //pula linha na tela
  fimpara

  escreval(«Minimax:», menor, « na linha «, linhaMaior, « e

coluna «, colunaMenor)
  escreval(«Maior elemento:», maior)

  escreval(«Fim do Algoritmo»)
fimalgoritmo

Capítulo 8
Orientações
Um algoritmo é uma sequência de instruções. À medida que cresce, ele pode tornar-
-se complexo e pouco legível. Além disso, certas sequências de comandos podem ser usadas
com frequência em diversos pontos do algoritmo, tendo de ser inteiramente reescritas em
cada um desses pontos, o que certamente é redundante e uma fonte de erros. Para enfren-
tar essa situação podemos dividir nosso programa em módulos, separando logicamente as
diferentes etapas do programa. A programação modular é uma técnica que tem por objetivo
simplificar o desenvolvimento de programas por meio de sua divisão em partes.

Respostas – página 104

1)

algoritmo “resp_algo_08_01.alg”
// Função : cálculo de raízes
// Autor : Marcos Laureano
var
  raiz1, raiz2: real
  a,b,c:real
inicio

40
   //declaração de um procedimento recebendo 3 valores
  procedimento raizes( a, b, c: inteiro)
  var
     delta: real
  inicio
     delta <- quad(b) - 4 * a * c
     se delta < 0 entao
        escreval(«Não é possível calcular as raízes»)
        raiz1 <- 0
        raiz2 <- 0
     senao
        delta <- raizq(delta)
        raiz1 <- (-b + delta)/(2*a)
        raiz2 <- (-b - delta)/(2*a)
     fimse
  fimprocedimento
  
  escreva(«Entre com A:»)
  leia(a)

  escreva(«Entre com B:»)

  leia(b)
  
  escreva(«Entre com C:»)
  leia(c)

  raizes(a,b,c)

  escreval(«Raiz 1:», raiz1)

  escreval(«Raiz 2:», raiz2)
  
  escreval(«Fim do Algoritmo»)
fimalgoritmo

2)

algoritmo “resp_algo_08_02.alg”
// Função : mostrando de ate 100
// Autor : Marcos Laureano
inicio

  //declaração de um procedimento recebendo 3 valores

  procedimento mostraNumeros()
  var
     contador: inteiro
  inicio
     para contador de 1 ate 100 passo 1 faca
        escreval(contador)
     fimpara
  fimprocedimento
  
  mostraNumeros()
  escreval(«Fim do Algoritmo»)
fimalgoritmo

41
 3)

algoritmo “resp_algo_08_03.alg”
// Função : mostrando de ate 100
// Autor : Marcos Laureano
var
  n1,n2: inteiro
inicio

  //declaração de um procedimento recebendo 3 valores

  procedimento mostraNumeros(inicial, final: inteiro)
  var
     contador: inteiro
  inicio
     se inicial < final entao
        para contador de inicial ate final passo 1 faca
           escreval(contador)
        fimpara
     senao
        para contador de inicial ate final passo -1 faca
           escreval(contador)
        fimpara
     fimse
  fimprocedimento
  
  escreva(«Leia número inicial:»)
  leia(n1)

  escreva(«Leia número final:»)

  leia(n2)

  mostraNumeros(n1,n2)
  escreval(«Fim do Algoritmo»)
fimalgoritmo

4)

algoritmo “resp_algo_08_04.alg”
// Função : elevar um número para outro número
// Autor : Marcos Laureano
var
  numero,expoente, resultado: inteiro
inicio

  //declaração de um procedimento recebendo 3 valores

  funcao eleva(numero, expoente: inteiro): inteiro
  var
     contador, retorno: inteiro
  inicio
     retorno <- 1 //elemento neutro da multiplicação
     para contador de 1 ate expoente passo 1 faca
        retorno <- retorno * numero
     fimpara
     retorne retorno
  fimfuncao
  
42
   escreva(«Leia número:»)
  leia(numero)

  escreva(«Leia Expoente:»)
  leia(expoente)

  resultado <-  eleva(numero, expoente)

  
  escreval(«Resultado:», resultado)
  escreval(«Fim do Algoritmo»)
fimalgoritmo

5)

algoritmo “resp_algo_08_05.alg”
// Função : data extenso
// Autor : Marcos Laureano
var
  data, resultado: caractere
inicio

  //declaração de um procedimento recebendo 3 valores

  funcao extenso(data: caractere): caractere
  var
     mes, ano, dia, resultado: caractere
  inicio
     dia <- copia(data,1,2)
     mes <- copia(data,4,2)
     ano <- copia(data,7,4)
     resultado <- dia + « de «
     escolha mes
        caso «01»
           resultado <- resultado + «Janeiro «
        caso «02»
           resultado <- resultado + «Fevereiro «
        caso «03»
           resultado <- resultado + «Março «
        caso «04»
           resultado <- resultado + «Abril «
        caso «05»
           resultado <- resultado + «Maio «
        caso «06»
           resultado <- resultado + «Junho «
        caso «07»
           resultado <- resultado + «Julho «
        caso «08»
           resultado <- resultado + «Agosto «
        caso «09»
           resultado <- resultado + «Setembro «
        caso «10»
           resultado <- resultado + «Outubro «
        caso «11»
           resultado <- resultado + «Novembro «

43
         caso «12»
           resultado <- resultado + «Dezembro «
        outrocaso
           resultado <- resultado + «mês inválido «
     fimescolha
     resultado <- resultado + ano + «.»
     retorne resultado
  fimfuncao
  
  escreva(«Informe a data no formato DD/MM/AAAA:»)
  leia(data)

  resultado <- extenso(data)

  
  escreval(«Resultado:», resultado)
  escreval(«Fim do Algoritmo»)
fimalgoritmo

6)

algoritmo “resp_algo_08_06.alg”
// Função : mes extenso
// Autor : Marcos Laureano
var
  resultado: caractere
  mes:inteiro
inicio

  //declaração de um procedimento recebendo 3 valores

  funcao mesExtenso(mes: inteiro): caractere
  var
     resultado: caractere
  inicio
     escolha mes
        caso 1
           resultado <- «Janeiro»
        caso 2
           resultado <- «Fevereiro»
        caso 3
           resultado <- «Março»
        caso 4
           resultado <- «Abril»
        caso 5
           resultado <- «Maio»
        caso 6
           resultado <- «Junho»
        caso 7
           resultado <- «Julho»
        caso 8
           resultado <- «Agosto»
        caso 9
           resultado <- «Setembro»

44
         caso 10
           resultado <- «Outubro»
        caso 11
           resultado <- «Novembro»
        caso 12
           resultado <- «Dezembro»
        outrocaso
           resultado <- «mês inválido «
     fimescolha
     retorne resultado
  fimfuncao
  
  escreva(«Informe o mês:»)
  leia(mes)

  resultado <- mesExtenso(mes)

  
  escreval(«Resultado:», resultado)
  escreval(«Fim do Algoritmo»)
fimalgoritmo

7)

algoritmo “resp_algo_08_07.alg”
// Função : Ackermann
// Autor : Marcos Laureano
var
  m,n:inteiro
inicio

  //declaração de um procedimento recebendo 3 valores

  funcao Ackermann(m,n: inteiro): inteiro
  var
  inicio
     se m = 0 entao
        retorne n+1
     senao
        se (m <> 0) e (n = 0) entao
           retorne Ackermann(m-1,1)
        senao
           retorne Ackermann(m-1, Ackermann(m,n-1))
        fimse
     fimse
  fimfuncao
  
  escreva(«Informe M:»)
  leia(m)

  escreva(«Informe N:»)
  leia(n)

  escreval(«Resultado:», Ackermann(m,n))
  escreval(«Fim do Algoritmo»)
fimalgoritmo

45
 Capítulo 9
Orientações
Bancos de dados existem para que, de tempos em tempos, um usuário possa localizar
o dado de um registro, simplesmente digitando uma chave ou termo de pesquisa. Há ape-
nas um método para encontrar informações em um arquivo desordenado e outro para um
arquivo ordenado. Encontrar informações em arquivo desordenado requer uma pesquisa
sequencial começando no primeiro elemento e parando quando o elemento procurado, ou o
final do arquivo é encontrado. Esse método deve ser usado em dados desordenados, poden-
do ser aplicado também a dados ordenados. Se os dados foram ordenados, pode-se utilizar
uma pesquisa binária, o que ajuda a localizar o dado mais rapidamente.
A ordenação é o processo de arranjar um conjunto de informações semelhantes em
uma ordem crescente ou descrente.  

Respostas – página 111

1)

algoritmo “algo_09_01.alg”
// Função : ordenação bolha crescente
// Autor : Marcos Laureano
var
  numeros: vetor [1..20] de inteiro
  i,j, temporario: inteiro
inicio

  aleatorio on
  //preenchendo o vetor para testarmos o algoritmo
  para i de 1 ate 20 passo 1 faca
     escreva(«Entre com um número:»)
     leia(numeros[i])
  fimpara
  aleatorio off

  para i de 1 ate 20 faca

     para j de 1 ate 19 faca
        //troca de posição
        se numeros[j] > numeros[j+1] entao
           temporario <- numeros[j]
           numeros[j] <- numeros[j+1]
           numeros[j+1] <- temporario
        fimse
     fimpara
  fimpara

  //imprime o vetor para mostrar como ficou após ordenação

  para i de 1 ate 20 passo 1 faca
     escreva(numeros[i], « «)
  fimpara

  escreval(«Fim do Algoritmo»)
fimalgoritmo

46
2)

algoritmo “algo_09_02.alg”
// Função : ordenação bolha decrescente
// Autor : Marcos Laureano
var
  numeros: vetor [1..20] de inteiro
  i,j, temporario: inteiro
inicio

  aleatorio on
  //preenchendo o vetor para testarmos o algoritmo
  para i de 1 ate 20 passo 1 faca
     escreva(«Entre com um número:»)
     leia(numeros[i])
  fimpara
  aleatorio off

  para i de 1 ate 20 faca

     para j de 1 ate 19 faca
        //troca de posição
        se numeros[j] < numeros[j+1] entao
           temporario <- numeros[j]
           numeros[j] <- numeros[j+1]
           numeros[j+1] <- temporario
        fimse
     fimpara
  fimpara

  //imprime o vetor para mostrar como ficou após ordenação

  para i de 1 ate 20 passo 1 faca
     escreva(numeros[i], « «)
  fimpara

  escreval(«Fim do Algoritmo»)
fimalgoritmo

47