Algoritmos | Editora LT

(1)

(2)

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.

(3)

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.

(4)

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 condiverifica-çã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

(5)

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 certainteira-mente é redundante e uma fonte de

erros. Para enfrentar essa situação podemos dividir nosso programa em módulos,

separan-do logicamente as diferentes etapas separan-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 modificatesta-da, 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.

(6)

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 aplicapoden-do também a dapoden-dos ordenapoden-dos. Se os dapoden-dos foram ordenapoden-dos, 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 é utilizautilizan-do 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

(7)

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)

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

(8)

5)

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)

(9)

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)

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

(10)

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

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.

(11)

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

(12)

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.

(13)

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

(14)

2)

algoritmo “resp_algo_04_02.alg” // Função : nome

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

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

(15)

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 //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

fimse fimse

(16)

//trocando cobre por outra moeda caso «Cobre»

se moedaDeseja = «Ouro» entao

se moedaDeseja = «Prata» entao

fimse fimse fimescolha

escreval(«Você terá «, quantidadeDeseja, « de «, moedaDeseja) escreval(«Fim do Algoritmo»)

fimalgoritmo

5)

algoritmo “resp_algo_04_05.alg” // Função : imposto

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

(17)

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)

// 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

(18)

2)

// Função : soma dos números pares de 1 até 100 // Autor : Marcos Laureano

var

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

// em 0

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

(19)

3)

// Função : soma dos números ímpares de 1 até 100 // Autor : Marcos Laureano

var

//lembrar que poderia colocar uma condição para verificar se o número é ímpar

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

(20)

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 caraccarac-teres 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.

(21)

Respostas – página 76

1)

// 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

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

(22)

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

(23)

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 // 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

(24)

2)

// Função : leitura de vetores e pesquisa // Autor : Marcos Laureano

var

numeros: vetor [1..10] de inteiro 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 escreval(«Fim do Algoritmo») fimalgoritmo

3)

// 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

invertido[contador_invertido] <- numeros[contador_numeros] contador_invertido <- contador_invertido - 1

(25)

//impressão do resultado

escreval(«Posição «, contador_numeros, « original=», numeros[contador_numeros], « invertido=», invertido[contador_ numeros]) fimpara escreval(«Fim do Algoritmo») fimalgoritmo

4)

// 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

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

(26)

5)

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

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

(27)

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)

(28)

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)

// 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

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

fimpara fimpara

(29)

//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

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

escreva(«Entre com um número para «, linha, «,», coluna, «:»)

leia(matriz[linha, coluna]) fimpara

//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

(30)

//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

(31)

//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»)

(32)

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)

// 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

(33)

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

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»

(34)

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

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»

(35)

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

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

(36)

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 aplicapoden-do também a dapoden-dos ordenapoden-dos. Se os dapoden-dos foram ordenapoden-dos, 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])

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

(37)

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

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