Algoritmos 2

Prévia do material em texto

(
Exercícios
 Resolvidos
Algoritmos II
)
Exercícios referentes à aula 01
1. Faça um algoritmo para ler um número inteiro positivo n e, em seguida, calcular e mostrar os n primeiros termos da sequência (1, 3, 6, 10, 15, 21, ...).
algoritmo "Calcula Termos"
 // Função: Algoritmo que calcula n termos da série 1, 3, 6, 10, 15, 21, ...
var
 // Declaração de variáveis
 n, termo, i: inteiro
inicio
 // Lendo a qtde de termos
escreva ("Informe a qtde de termos para a sequência: ")
leia (n)
termo<- 0 // Inicializando a variável termo
escreva ("Sequencia:")
 // Determinando e escrevendo os termos para a sequência
para i de 1 ate n faca
termo<- termo + i
escreva (termo, " ")
fimpara
fimalgoritmo
2. A série de Fibonacci é expressa da seguinte forma: 1, 1, 2, 3, 5, 8, 13, 21, 34, ... Faça um algoritmo para ler um número inteiro e positivo n e, em seguida, calcular e mostrar a série de Fibonacci com n termos.
algoritmo "Calcula Série de Fibonacci"
 // Função: Algoritmo que calcula n termos da série de Fibonacci
var
 // Declaração de variáveis
 n, termo, ant, aux, i: inteiro
inicio
 // Lendo a qtde de termos
escreva ("Informe a qtde de termos para série: ")
leia (n)
 // Inicializando as variáveis
ant<- 0
termo<- 1
escreva ("Série:", termo, " ")
 // Determinando e escrevendo os termos para a sequencia
para i de 2 ate n faca
aux<- termo
termo<- termo + ant
ant<- aux
escreva (termo, " ")
fimpara
fimalgoritmo
Exercícios referentes à aula 02
1. Faça um algoritmo para cadastrar o nome, a população e densidade demográficade uma cidade do estado do Paraná. A seguir, o algoritmo deverá verificar e informar se a cidade cadastrada é ou não a capital do estado.
algoritmo "População"
 // Função: Algoritmo que verifica se uma cidade informada é a capital do Paraná
tipo // Definição do Registro
 Cidade = registro
nome: caractere
populacao: inteiro
densidade: real
fimregistro
var
cdd: Cidade// Declaração de variável do tipo Cidade
inicio
escreva("Informe o nome de uma cidade do Paraná: ")
leia(cdd.nome) // Lendo o nome da cidade
escreva("Informe a população da cidade: ")
leia(cdd.populacao) // Lendo a população da cidade
escreva("Informe a densidade demográfica da cidade: ")
leia(cdd.densidade) // Lendo a densidade demográfica da cidade
 // Verificando se a cidade informada é a capital do estado do Paraná
secdd.nome = "CURITIBA" entao
escreva("A cidade informada é a capital do Paraná")
senao
escreva("A cidade informada não é a capital do Paraná")
fimse
fimalgoritmo
2. Faça um algoritmo para cadastrar 10 produtos de uma loja com os seguintes dados: código, estoque mínimo, estoque atual e preço. A seguir, o algoritmo deverá apresentar o código e o preço dos produtos que contenham o estoque atual menor que o estoque mínimo. 
algoritmo "Produtos de Loja"
 // Função: Algoritmo que apresenta os produtos de uma loja que estão com estoque abaixo do estoque mínimo
tipo // Definicão do Registro
 Produto = registro
codigo: inteiro
estoque_min: inteiro
estoque_atual: inteiro
preco: real
fimregistro
var
 P: vetor[1..10] de Produto // Declaração de um vetor do tipo Produto
 i: inteiro// Declaração de variável para controle da estrutura de repetição
inicio
 // Cadastrando os produtos
para i de 1 ate 10 faca
escreva("Informe o código do produto: ")
leia(P[i].codigo) // Lendo o codigo do produto
escreva("Informe a qtde de unidades para o estoque minimo: ")
leia(P[i].estoque_min) // Lendo o estoque minimo do produto
escreva("Informe a qtde de unidades no estoque atual: ")
leia(P[i].estoque_atual) // Lendo o estoque atual do produto
escreva("Informe o preço do produto: ")
leia(P[i].preco) // Lendo o preço do produto
fimpara
 // Apresentando os produtos com estoque atual inferior ao estoque minimo
escreva("Produtos com estoque atual inferior ao estoque mínimo")
para i de 1 ate 10 faca
se P[i].estoque_atual< P[i].estoque_minentao
escreva("Código:", P[i].codigo)
escreva("Preço:", P[i].preco)
fimse
fimpara
fimalgoritmo
Exercícios referentes à aula 03
1. Faça um algoritmo contendo um procedimento para receber, por parâmetro, um valor inteiro e positivo n informado no módulo principal. Após a chamada, o procedimento deverá calcular e mostrar o fatorial de n (n!).
algoritmo "Calcula Fatorial"
// Função: Algoritmo que calcula o fatorial de um número
procedimento FATORIAL (num: inteiro) // Procedimento que calcula e escreve o fatorial
var
 //Declaração de variáveis locais
fat, i: inteiro
inicio
fat<- 1
para i de 2 ate num faca // Calculando o fatorial
fat<- fat * i
fimpara
escreval ("Fatorial: ", fat)
fimprocedimento
var
 //Declaração de variáveis
 n: inteiro
inicio
 // Lendo o número para o cálculo do fatorial
escreva ("Informe o número: ")
leia (n)
 FATORIAL(n) // Chamada do procedimento para o calculo do fatorial
fimalgoritmo
2. Faça um algoritmo contendo um procedimento para receber, por parâmetro, três valores inteiros informados no módulo principal. O procedimento deverá então determinar o valor intermediário dos três valores informados. O valor intermediário deverá ser apresentado no módulo principal.
algoritmo "Número Intermediário"
// Função: Algoritmo que calcula o número intermediário entre três números
procedimento INTERMEDIARIO (a, b, c: inteiro; var i: inteiro) // Procedimento que calcula o número intermediário
var
 //Declaração de variável local
inicio
se ((a < b) e (a > c)) ou ((a > b) e (a < c)) entao
 i <- a
senao
se ((b < a) e (b > c)) ou ((b > a) e (b < c)) entao
 i <- b
senao
 i <- c
fimse
fimse
fimprocedimento
var
 //Declaração de variáveis
n1, n2, n3, inter: inteiro
inicio
 // Lendo os números
escreva ("Informe o primeiro número: ")
leia (n1)
escreva ("Informe o segundo número: ")
leia (n2)
escreva ("Informe o terceiro número: ")
leia (n3)
 // Chamada do procedimento para o calculo do número intermediario
INTERMEDIARIO(n1, n2, n3, inter)
escrevaL ("Número intermediário: ", inter) // Apresentando o número intermediário
fimalgoritmo
Exercícios referentes à aula 04
1. Faça um algoritmo contendo uma função para calcular o índice de massa corporal (IMC). O IMC é calculado pela seguinte formula:
O peso e altura deverão ser lidos no módulo principal e fornecidos para a função por parâmetros. O resultado deverá ser retornado pela função e apresentado no módulo principal.
algoritmo "IMC"
// Função: Algoritmo que calcula o Indice de Massa Corporal
funcao IMC(p: real; a: real): real // Função que calcula o IMC de uma pessoa
var
res: real // Declaração de variável local
inicio
 // Calcula e retorna o imc
res<- peso / (altura * altura)
retorne res
fimfuncao
var
 // Declaração de variáveis
peso, altura: real
inicio
 // Leitura das informações
escreva("Informe o peso: ")
leia(peso)
escreva("Informe a altura: ")
leia(altura)
escreval("IMC: ", IMC(peso, altura)) // Chamada da função e escrita do resultado
fimalgoritmo
1. Faça um algoritmo contendo uma função para receber, por parâmetro, um valor inteiro e positivo n e retornar o valor de S, obtido pelo seguinte cálculo: 
S = 1/1 + 1/2 + 1/3 + ... + 1/n
algoritmo "Soma Termos"
// Função: Algoritmo que calcula a soma dos termos de uma serie
funcao SOMA(n:inteiro): real // Função que determina os termos da série e efetua a soma
var
 // Declaração de variáveis locais
 s: real
 i: inteiro
inicio
 s <- 0 // Inicializando a variável para a soma
para i de 1 ate n faca
 s <- s + 1 / i // Determinando e somando os termos
fimpara
retorne s // Retornando a soma
fimfuncao
var
 // Declaração de variável
 n: inteiro
inicio
 // Leitura do número de termos
escreva("Informe a quantidade de termos da série: ")
leia(n)
escreval("Soma da série: ", SOMA(n)) // Chamada da função e escrita do resultado
fimalgoritmo
Exercícios referentes à aula 05
1. Faça um algoritmo contendo um procedimento para receber, por parâmetro, três valores inteiros representando um horário expresso em horas, minutos e segundos. O procedimento deverá então converter o horário (horas, minutos e segundos) para apenassegundos. O resultado deverá ser armazenado em uma variável global para ser apresentado no módulo principal do algoritmo.
algoritmo "Conversão Para Segundos"
 // Função: Algoritmo que converte horas, minutos e segundos para segundos
procedimento CONVERTE(h, m, s:inteiro) // Procedimento que realiza a conversão
inicio
ts<- h * 3600 + m * 60 + s // Atribuindo o resultado para uma variável global
fimprocedimento
var
 // Variável global
ts: inteiro
 // Declaração de variáveis locais
 h, m, s: inteiro
inicio
 // Leitura do valores
escreva("Informe o número de horas: ")
leia(h)
escreva("Informe o número de minutos: ")
leia(m)
escreva("Informe o número de segundos: ")
leia(s)
CONVERTE(h, m, s) // Chamada do procedimento
escreval("Horário em segundos: ", ts) // Escrita do resultado
fimalgoritmo
2. Faça um algoritmo contendo um procedimento para calcular o número de lâmpadas necessárias para iluminar um determinado cômodo de uma residência. O procedimento deverá receber, por parâmetro, a potência da lâmpada utilizada (em watts), a largura e o comprimento (em metros) do cômodo. A potência necessária para uma boa iluminação é de 20 watts por metro quadrado. O resultado deverá ser armazenado em uma variável global e apresentado no módulo principal.
algoritmo "Calcula Lâmpadas"
 // Função: Algoritmo que calcula a qtde de lâmpadas para iluminar um cômodo
procedimento LAMPADAS(p: inteiro; l, c: real) // Procedimento que determina o número de lâmpadas
inicio
nl<- (l * c * 20) / p // Atribuindo o resultado para uma variável global
fimprocedimento
var
 // Variável global
nl: real
 // Declaração de variáveis locais
potencia: inteiro
largura, comprimento: real
inicio
 // Leitura do valores
escreva("Informe a potência da lâmpada a ser utilizada: ")
leia(potencia)
escreva("Informe a largura do cômodo: ")
leia(largura)
escreva("Informe o comprimento do cômodo: ")
leia(comprimento)
LAMPADAS(potencia, largura, comprimento) // Chamada do procedimento
escreval("Número de lâmpadas: ", nl) // Escrita do resultado
fimalgoritmo
Exercícios referentes à aula 06
1. Faça um algoritmo contendo uma função recursiva para calcular a soma dos números pares do intervalo de 0 a n. O módulo principal do algoritmo deverá fazer a leitura de n e apresentar o resultado. 
algoritmo "Soma Pares"
// Função: Algoritmo que cálcula a soma dos valores pares de 0 a 10
funcao SOMA(n: inteiro): inteiro // Função que soma dos valores pares
inicio
se n = 0 entao
retorne(0)
senao
retorne n + SOMA(n-2) // Recursão
fimse
fimfuncao
var
 // Declaração de variáveis
 n, res: inteiro
inicio
escreva("Informe o valor: ")
leia(n) // Lendo o valor
se n mod 2 <> 0 entao // Se o valor for impar altero para o par anterior mais próximo
 n <- n - 1
fimse
res<- SOMA(n) // Chamada da função recursiva
escreval("Soma dos pares de 0 a 10:", res) // Escrita dos resultados
fimalgoritmo
//Pilha de Recursão
//soma(10)
//10 + soma(8) => 30
// 8 + soma(6) => 20
// 6 + soma(4) => 12
// 4 + soma(2) => 6
// 2 + soma(0) => 2
// 0
2. Faça um algoritmo contendo uma função recursiva para calcular e mostrar on-ésimotermo da sequência: 1, 3, 6, 10, 15, 21, ... O valor de n deverá ser lido no módulo principal.
algoritmo "Calcula Enésimo Termo"
// Função: Algoritmo que cálculan-ésimo termo da série 1, 3, 6, 10, 15, 21, ...
funcao TERMO(n: inteiro): inteiro // Função que calcula o termo
inicio
se n = 0 entao
retorne(0)
senao
retorne n + TERMO(n-1)// Recursão
fimse
fimfuncao
var
 // Declaração de variável
 n: inteiro
inicio
 // Leitura da qtde de termos
escreva("Informe o número de termos: ")
leia(n)
escreval("Enésino termo da série:", TERMO(n)) // Chamada da função recursiva
fimalgoritmo
//Exemplo de Pilha de Recursão
//Termo(5)
// 5 + termo(4) => 15
// 4 + termo(3) => 10
// 3 + termo(2) => 6
// 2 + termo(1) => 3
// 1 + termo(0) => 1
// 0
Exercícios referentes à aula 07
1. Faça um algoritmo para ler, em um arquivo, as informações referentes aos produtos de uma loja de informática cadastrados com os seguintes dados: código, descrição, quantidade em estoque e preço da unidade. A seguir, o algoritmo deverá apresentar o código, a descrição e o preço dos produtos commais de 100 unidades em estoque.
algoritmo "Produtos de Loja"
 // Função: Algoritmo que apresenta o produto com maior unidades em estoque de uma loja
tipo // Definicão do Registro
 Produto = registro
codigo: inteiro
descricao: caractere
estoque: inteiro
preco: real
fimregistro
var
 LOJA arquivo de Produto // Declaração do arquivo
prod: Produto// Declaração de variável do tipo registro
inicio
abra LOJA leitura // Abrindo o arquivo
 // Percorrendo todos os registros do arquivo
repita
LOJA.leia(prod) // Lendo um registro referente a um produto do arquivo
seprod.estoque> 100 entao // Verificando se o produto possui mais de 100 unidades em estoque
 // Apresentando as informações dos produtos com mais de 100 unidades em estoque
escreva("Código:", prod.codigo)
escreva("Descrição:", prod.descricao)
escreva("Preço:", prod.preco)
fimse
ate LOJA EOF // Verificando final do arquivo
feche LOJA // Fechando o arquivo
fimalgoritmo
2. Faça um algoritmo para ler, em um arquivo, as informações referentes a turma de alunos de uma disciplina. O arquivo contém cadastrados os seguintes dados: número de matrícula, nome do aluno, nota 01, nota 02, nota 03, nota 04. Durante a leitura, o algoritmo deverá calcular a média final de cada aluno e então escrever seus dados em outro arquivo, caso ele tenha sido aprovado. Para a aprovação é necessário que o aluno tenha obtido uma média igual ou superior a 6,0. Os alunos não aprovados deverão ser desconsiderados.
algoritmo "Alunos Aprovados"
 // Função: Algoritmo que apresenta, em um arquivo de saída, os alunos aprovados em uma disciplina
tipo // Definicão do Registro
 Aluno = registro
matricula: inteiro
nome: caractere
n1, n2, n3, n4: real
fimregistro
var
 DISCIPLINA arquivo de Aluno // Declaração do arquivo de entrada
 APROVADOS arquivo de Aluno // Declaração do arquivo de saída
aln: Aluno// Declaração de variável do tipo registro
media: real
inicio
abra DISCIPLINA leitura // Abrindo o arquivo de entrada
abra APROVADOS escrita // Abrindo o arquivo de saída
 // Percorrendo todos os registros do arquivo de entrada
repita
DISCIPLINA.leia(aln) // Lendo um registro referente a um aluno
media<- (aln.n1 + aln.n2 + aln.n3 + anl.n4) / 4 // Calculando a média do aluno
se media >= 6.0 entao // Verificando se o aluno está aprovado
APROVADOS.escreva(aln) // Escrevendo no arquivo de saída o registro do aluno aprovado
fimse
ate DISCIPLINA EOF // Verificando final do arquivo de entrada
feche DISCIPLINA // Fechando o arquivo de entrada
feche APROVADOS // Fechando o arquivo de saída
fimalgoritmo