ALGORITMOSprofissional 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

ALGORITMOS

12

Orientações geraisO 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ógicosO 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údoO 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.

13

Atividades complementaresAlé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 leituraAzevedo, 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 PlanejamentoO 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 1Primeiro bimestreCapí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.

14

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 bimestreCapí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 2Primeiro bimestreCapítulo 7 – Dados homogêneos e heterogêneos

Capítulo 8 – Funções, procedimentos e recursividade

15

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 bimestreCapítulo 9 – Pesquisa e ordenação

Objetivos

• Pesquisa sequencial.

• Saber ordenar com BubbleSort.

• Pesquisa binária.

16

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 atividadesCapítulo1Orientaçõ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 171) A resposta é a critério do aluno.

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

17



Capítulo 2Orientaçõ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 221)

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


3)

algoritmo “resp_algo_02_03.alg”// Função : mostrar uma mensagem na tela// Autor : Marcos Laureanoinicio 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


18

5)

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


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

algoritmo “resp_algo_03_01.alg”// Função : permuta de 2 valores// Autor : Marcos Laureanovar a,b, temporario: inteiroinicio //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)

19

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 Laureanovar media, n1, n2, n3, n4: realinicio 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)


3)

algoritmo “resp_algo_03_03.alg”// Função : caminhada// Autor : Marcos Laureanovar distancia: realinicio

distancia <- 1.6 * 5 * 45 escreval(«Distância em KM:», distancia) escreval(«Fim do Algoritmo»)fimalgoritmo

20


5)

algoritmo “resp_algo_03_04.alg”// Função : cálculo de média// Autor : Marcos Laureanovar media, n1, n2, n3: realinicio 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)



7)

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

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

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




21

10)

algoritmo “resp_algo_03_06.alg”// Função : construção de casas// Autor : Marcos Laureanovar dolar, salario, casas: realinicio 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.»)


11)

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

notas100 <- valorTotal / 100 resto <- valorTotal % 100

notas50 <- resto / 50 resto <- resto % 50




notas01 = resto

22

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


12)

algoritmo “resp_algo_03_08.alg”// Função : cálculo de juros// Autor : Marcos Laureanovar prestacao, taxa, valor: real dias: inteiroinicio 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)



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.

23

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

algoritmo “resp_algo_04_01.alg”// Função : pescaria// Autor : Marcos Laureanovar multa: real excesso,peso: inteiroinicio 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)


24

2)

algoritmo “resp_algo_04_02.alg”// Função : nome// Autor : Marcos Laureanovar 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 Laureanovar 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


25

4)

algoritmo “resp_algo_04_04.alg”// Função : conversão de moedas// Autor : Marcos Laureanovar 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

26

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


5)

algoritmo “resp_algo_04_05.alg”// Função : imposto// Autor : Marcos Laureanovar valor, imposto: realinicio

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)


27


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.


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

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


28

2)

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

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


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


29

3)

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

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


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


30

4)

algoritmo “resp_algo_05_04.alg”// Função : faixa de valores// Autor : Marcos Laureanovar n1, n2, multiplicacao, termo: inteiroinicio

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)





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.

31


algoritmo “resp_algo_06_01.alg”// Função : separando frases por espaços em branco// Autor : Marcos Laureanovar frase, palavra, frase_parcial: caractere posicao_branco:inteiroinicio 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 Laureanovar ladoA, ladoB, ladoC: inteiroinicio 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.»)

32

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


3)

algoritmo “resp_algo_06_03.alg”// Função : repetição de letras// Autor : Marcos Laureanovar frase, letra: caractere letraA, letraE, letraI, letraO, letraU, posicao:inteiroinicio 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

33


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

algoritmo “resp_algo_07_01.alg”// Função : leitura de vetores e cálculo da média// Autor : Marcos Laureanovar soma, media: real numeros: vetor [1..20] de inteiro contador: inteiroinicio 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)


34

2)

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

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


3)

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

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

35

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


4)

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

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)


36

5)

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


6)

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

eFumante: caractereinicio 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)

37

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


7)

algoritmo “resp_algo_07_07.alg”// Função : notas de aluno// Autor : Marcos Laureanovar aluno : registro inicio nome,situacao: caractere matricula: inteiro nota1, nota2, nota3, nota4, media:real fimregistro alunos: vetor[1..50] de aluno qtdAlunos, contador: inteiroinicio 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)

38

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 Laureanovar

matrizA,matrizB: vetor [1..4, 1..3] de inteiro matrizC: vetor [1..4, 1..3] de logico linha, coluna: inteiroinicio

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[linha,coluna] fimpara fimpara

39

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

matriz: vetor [1..10, 1..10] de inteiro linha, coluna, maior, menor: inteiro linhaMaior, colunaMenor: inteiroinicio

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

40

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



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.


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

41

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

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

42

3)

algoritmo “resp_algo_08_03.alg”// Função : mostrando de ate 100// Autor : Marcos Laureanovar n1,n2: inteiroinicio

//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 Laureanovar numero,expoente, resultado: inteiroinicio

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

43

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 Laureanovar data, resultado: caractereinicio

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

44

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 Laureanovar resultado: caractere mes:inteiroinicio

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

45

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 Laureanovar m,n:inteiroinicio

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

46


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.


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

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


47

2)

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

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


Documents

ALGORITMOSprofissional 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