Algoritmos MP

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.
16
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

3)
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!”)
fimalgoritmo

17
5)
inicio
escreval(«Desenvolver raciocínio lógico»)
escreval(«Dominar algoritmos»)
escreval(«E passar de ano»)
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)
// Função : permuta de 2 valores
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)
fimalgoritmo

2)
// Função : cálculo de média
var
media, n1, n2, n3, n4: real
inicio
escreva(«Entre com a nota 1:»)
leia(n1)

leia(n2)

leia(n3)

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

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

3)
// Função : caminhada
var
distancia: real
inicio
distancia <- 1.6 * 5 * 45

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

19
5)
// Função : cálculo de média
var
media, n1, n2, n3: real
inicio
leia(n1)

leia(n2)

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

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

7)
// Função : conversão temperatura
var
fahrenheit, celsius: real
inicio
escreva(«Entre com a temperatura Fahrenheit:»)
leia(fahrenheit)
celsius <- (5/9) * (fahrenheit-32)
escreval(«A a temperatura é:», celsius)
fimalgoritmo

20
10)
// Função : construção de casas
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.»)
fimalgoritmo

11)
// Função : cálculo de juros
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

resto <- resto % 20

resto <- resto % 10

resto <- resto % 5
notas01 = resto
21
escreval(«Notas necessárias:»)
escreval(«100 -> «, notas100)
escreval(« 50 -> «, notas50)
fimalgoritmo

12)
// Função : cálculo de juros
var
prestacao, taxa, valor: real
dias: inteiro
inicio
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)
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)
// Função : pescaria
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)
fimalgoritmo

23
2)
// Função : nome
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

fimalgoritmo

3)
// Função : placar
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
fimalgoritmo
24
4)
// Função : conversão de moedas
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
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
senao
quantidade
fimse
fimse

25
//trocando cobre por outra moeda
caso «Cobre»
se moedaDeseja = «Ouro» entao
senao
se moedaDeseja = «Prata» entao
senao
quantidade
fimse
fimse
fimescolha

escreval(«Você terá «, quantidadeDeseja, « de «, moedaDeseja)
fimalgoritmo

5)
// Função : imposto
var
valor, imposto: real
inicio

leia(valor)

imposto <- 0

se valor < 1200 entao
imposto <- 0
senao
imposto <- valor * 0.10
senao
senao
fimse
fimse
fimse
escreval(«Imposto a ser pago R$», imposto)
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.
1)
// Função : soma dos números de 1 até 100
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
fimpara
//com repita
soma <- 0
numero <- 1
repita
ate numero > 100
fimalgoritmo
27
2)
// Função : soma dos números pares de 1 até 100
var
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
se numero % 2 = 0 entao
fimse
fimenquanto

//com para
soma <- 0
fimse
fimpara
//com repita
soma <- 0
numero <- 1
repita
fimse
ate numero > 100
fimalgoritmo
28
3)
// Função : soma dos números ímpares de 1 até 100
var
inicio
//lembrar que poderia colocar uma condição para verificar se o

número é ímpar
//com enquanto
soma <- 0
numero <- 1
fimenquanto

//com para
soma <- 0
fimpara
//com repita
soma <- 0
numero <- 1
repita
ate numero > 100
fimalgoritmo
29
4)
// Função : faixa de valores
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)
fimalgoritmo

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
1)
// Função : separando frases por espaços em branco
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, «]»)
fimalgoritmo

2)
// Função : triângulo
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
fimalgoritmo

3)
// Função : repetição de letras
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)
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)
// Função : leitura de vetores e cálculo da média
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
soma <- soma + numeros[contador]
fimpara

media <- soma/20

escreval(«A média é:», media)
fimalgoritmo
33
2)
// Função : leitura de vetores e pesquisa
var
contador, valor_pesquisa: inteiro
inicio
aleatorio on
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)

se numeros[contador] = valor_pesquisa entao
escreval(«Valor encontrado na posição:», contador)
fimse
fimpara
ate valor_pesquisa = 0
fimalgoritmo

3)
// Função : leitura de vetores com inversão
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
invertido[contador_invertido] <- numeros[contador_numeros]
contador_invertido <- contador_invertido - 1
fimpara
34
//impressão do resultado
escreval(«Posição «, contador_numeros, « original=»,
numeros[contador_numeros], « invertido=», invertido[contador_
numeros])
fimpara
fimalgoritmo

4)
// Função : leitura de vetores de letras com pesquisa
var
letras : vetor [1..30] de caractere
contador, ocorrencias: inteiro
letra:caractere
inicio

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

leia(letra)

ocorrencias <- 0
se letras[contador] = letra entao
ocorrencias <- ocorrencias + 1
fimse
fimpara

escreval(«Quantidade de ocorrências:», ocorrencias)
fimalgoritmo
35
5)
// Função : definiçã do registro de viagem
var
viagem : registro
inicio
data, origem, destino: caractere
codigo, numero_assento:inteiro
hora, minuto: inteiro
tempo_viagem: real
fumante : logico
fimregistro
inicio
fimalgoritmo

6)
// Função : definição do registro de viagem
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
fimalgoritmo

7)
// Função : notas de aluno
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)

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
fimalgoritmo

8)
// Função : leitura de matrizes, criando um terceira
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

matrizC[linha,coluna] <- matrizA[linha,coluna]=matrizB[l
inha,coluna]
fimpara
fimpara

38
//impressao
escreva(matrizC[linha,coluna], « «)
fimpara
escreval //linha em branco
fimpara
fimalgoritmo

9)
algoritmo “algo_07_09.alg”
// Função : procura o minimax
var
matriz: vetor [1..10, 1..10] de inteiro

linha, coluna, maior, menor: inteiro
linhaMaior, colunaMenor: inteiro
inicio
aleatorio on
//leitura da matriz
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

//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]
se matriz[linhaMaior,coluna] < menor entao
menor <- matriz[linhaMaior,coluna]
colunaMenor <- coluna
fimse
fimpara
//imprimindo toda a matriz na tela

escreva(matriz[linha, coluna], « «)
fimpara
escreval //pula linha na tela
fimpara
escreval(«Minimax:», menor, « na linha «, linhaMaior, « e

coluna «, colunaMenor)
escreval(«Maior elemento:», maior)
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.

1)
// Função : cálculo de raízes
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)

fimalgoritmo

2)
// Função : mostrando de ate 100
inicio

procedimento mostraNumeros()
var
contador: inteiro
inicio
escreval(contador)
fimpara
fimprocedimento

mostraNumeros()
fimalgoritmo
41
3)
// Função : mostrando de ate 100
var
n1,n2: inteiro
inicio

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)
fimalgoritmo

4)
// Função : elevar um número para outro número
var
numero,expoente, resultado: inteiro
inicio

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)
fimalgoritmo

5)
// Função : data extenso
var
data, resultado: caractere
inicio

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)

fimalgoritmo

6)
// Função : mes extenso
var
resultado: caractere
mes:inteiro
inicio

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)

fimalgoritmo

7)
// Função : Ackermann
var
m,n:inteiro
inicio

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))
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.

1)
// Função : ordenação bolha crescente
var
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

escreva(numeros[i], « «)
fimpara
fimalgoritmo

46
2)
// Função : ordenação bolha decrescente
var
i,j, temporario: inteiro
inicio
aleatorio on
//preenchendo o vetor para testarmos o algoritmo
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

escreva(numeros[i], « «)
fimpara
fimalgoritmo
47

Algoritmos MP

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Algoritmos MP

Enviado por

Direitos autorais:

Formatos disponíveis

ALGORITMOS

Objetivos do material didático

Orientações didáticas e respostas das

Resposta – páginas 35-36

escreva(«Entre com a nota 2:»)

escreva(«Entre com a nota 4:»)

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

distancia <- 1.6 * 5 * 45

escreva(«Entre com a nota 2:»)

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

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

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

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

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

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

notas100 <- valorTotal / 100

notas50 <- resto / 50

notas20 <- resto / 20

notas10 <- resto / 10

notas05 <- resto / 5

escreva(«Entre com a taxa:»)

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

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

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

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

//trocando prata por outra moeda

escreva(«Entre com o valor:»)

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

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

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

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

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

Respostas – páginas 87-88

para contador de 1 ate 30 passo 1 faca

escreva(«Entre com a letra:»)

se eFumante = «Sim» entao

se alunos[contador].media >= 7 entao

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

//criando a terceira matriz

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

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

para linha de 1 ate 10 passo 1 faca

//imprimindo toda a matriz na tela

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

Respostas – página 104

escreva(«Entre com B:»)

escreval(«Raiz 1:», raiz1)

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

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

escreva(«Leia número final:»)

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

resultado <- eleva(numero, expoente)

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

resultado <- extenso(data)

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

resultado <- mesExtenso(mes)

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

Respostas – página 111

para i de 1 ate 20 faca

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

para i de 1 ate 20 faca

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

Você também pode gostar

media <- (n1 + n22 + n33 + n4*4 )/10

media <- (n1 + n22 + n33 )/6

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

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