SOLUÇÃO DA LISTA DE EXERCÍCIOS REFERENTE AO CAPÍTULO 9 DA APOSTILA

DE ALGORITMOS (FUNÇÕES E PROCEDIMENTOS)

9.1 Escreva um programa que receba como entrada um número inteiro e calcula, por meio de uma
função, o módulo (valor absoluto) desse número.

Algoritmo Calcula_Modulo

Var numero_lido,resultado: inteiro

//Definição da função que calcula o módulo

Função modulo (numero: inteiro): inteiro
Início
Se numero >= 0 então
Retorne numero
Senão
Retorne -numero
Fimse
Fim

//Início do programa principal

Início
//Entrada de dados
Escreva (“Digite o número: ”)
Leia (numero_lido)
//Chamada da função módulo
resultado ← modulo(numero_lido)
//Saída de dados
Escreva ("O módulo de ", numero_lido, " é: ",resultado)
Fim
9.2 Escreva um programa que receba como entrada o valor de um ângulo em graus e apresenta seu
valor em radianos, fazendo uso de uma função para o cálculo.
A fórmula para conversão de graus para radianos é: valor em radianos = valor em graus * pi / 180.
Considere o valor de pi como sendo 3.1416.

Algoritmo Conversao_Angulo

Var valor,angulo_convertido: real

//Definição da função que converte o ângulo

Função converte (graus: real): real
Var resultado: real
Início
resultado ← graus * 3.1416 / 180
Retorne resultado
Fim

//Início do programa principal

Início
//Entrada de dados
Escreva (“Digite o valor do ângulo em graus: ”)
Leia (valor)
//Chamada da função converte
angulo_convertido ← converte(valor)
//Saída de dados
Escreva ("O valor do ângulo em radianos é:",angulo_convertido)
Fim
9.3 Elabore um algoritmo que calcule e apresente o valor de um determinado termo da sequência de
Fibonacci. O programa lê um número i, inserido pelo usuário, e imprime o i-ésimo termo da
sequência. O programa deve contemplar uma função específica que receba o número i e retorne o
valor do termo correspondente para o programa principal.

Dado:
A sequência de Fibonacci é a seguinte: 1 1 2 3 5 8 13...
Ela inicia-se em 1, repete o 1 no segundo termo e, a partir do terceiro termo, o valor de qualquer
termo é obtido pela soma dos dois termos anteriores. Ou seja, n = (n-1) + (n-2).

Algoritmo Termo_Fibonacci

Var indice, termo_n: inteiro

//Definição da função que realizará a soma

Função fibonacci (n: inteiro): inteiro
Var ultimo, penultimo, termo: inteiro
Início
Se n = 1 OU n = 2 então
Retorne 1
Senão
ultimo ← 1
penultimo ← 1
Para i de 3 até n+1 passo 1 faça
termo ← ultimo + penultimo
penultimo ← ultimo
ultimo ← termo
Fimpara
Retorne termo
Fimse
Fim

//Início do programa principal

//Entrada de dados
Início
Escreva ("Digite o valor do índice (i): ")
Leia (indice)
//Validação da entrada
Enquanto indice < 1 faça
Escreva ("Valor inválido! Digite um valor inteiro positivo: ")
Leia (indice)
Fimenquanto
//Chamada da função
termo_n ← fibonacci(indice)
//Apresentação do resultado
Escreva("O termo”,indice,”da sequência de Fibonacci é”,termo_n)
Fim
9.4 Desenvolva um programa que realiza a operação de divisão. O programa deve receber como
entrada o valor do dividendo e do divisor e, por meio de uma sub-rotina, calcula e imprime o
resultado da operação.

Algoritmo Calcula_Divisão

Var dividendo_dig, divisor_dig: real

//Definição do procedimento
Procedimento imprime_divisao(dividendo,divisor: real)
Var resultado: real
Início
resultado ← dividendo/divisor
Escreva("O resultado da divisão é",resultado)
Fim

// Programa principal
Início
//Entrada de dados
Escreva ("Digite o valor do dividendo:")
Leia (dividendo_dig)
Escreva ("Digite o valor do divisor:")
Leia (divisor_dig)
//Chamada do procedimento
imprime_divisao(dividendo_dig,divisor_dig)
Fim
9.5 Faça um programa que leia o valor do salário atual de um militar e imprima o valor do salário
reajustado. O programa principal deve solicitar ao usuário para digitar o salário do militar e chamar
a função de nome Calcula_Aumento, receber o retorno desta função, imprimir o novo valor do
salário e perguntar se o usuário deseja digitar outro salário ou não. Se o usuário responder que sim,
o ciclo deve se repetir até que o usuário responda que não. Se o usuário digitar um valor diferente
de “sim” ou “não”, o programa deverá apresentar uma mensagem de entrada inválida e solicitar
uma nova entrada, até que o usuário digite uma entrada válida (sim ou não).
A função Calcula_Aumento deve seguir a seguinte regra para calcular o novo salário: se o salário
atual for menor ou igual a R$ 1.000,00, deverá aplicar um aumento de 10%; se for maior que R$
1.000,00 e menor ou igual a R$ 2.000,00, o aumento será de 8%; já se for maior que R$ 2.000,00, o
aumento deverá ser de 5%. Essa função deverá calcular o novo salário e retornar o valor para o
programa principal.

Algoritmo Calcula_Salário
Var
resp: texto
salario_dig, salario_reaj: real

//Definição da função
Função Calcula_Aumento(salario: real): real
Var salario_novo: real
Início
Se salario <= 1000 então
salario_novo ← salario * 1.1
Senão
Se salario >1000 E salario <= 2000 então
salario_novo ← salario * 1.08
Senão
salario_novo ← salario * 1.05
Fimse
Fimse
Retorne salario_novo
Fim

//Programa principal
Início
resp = "sim" //Inicialização da variável de controle
Enquanto resp == "sim" OU resp == "Sim" OU resp == "SIM" faça
Escreva ("Digite o valor do salário:")//Entrada de dados
Leia (salario_dig)
salario_reaj ← Calcula_Aumento(salario_dig)//Chamada da função
Escreva ("O valor do salário reajustado é”,salario_reaj)//Saída de dados
Escreva ("Deseja digitar outro salário?")
Escreva ("Digite sim para continuar ou não para encerrar:")
Leia (resp)
Enquanto resp<>"sim" E resp<>"Sim" E resp<>"SIM" E resp<>"não" E
resp<>Não" E resp<>"NÃO" faça //Validação da escolha
Escreva ("Entrada inválida! Digite sim para continuar ou não para parar:")
Leia (resp)
Fimenquanto
Fimenquanto
Fim
9.6 Modifique o algoritmo do exercício 7.11 da lista de exercícios referente ao capítulo 7
(Condicionais) da apostila de Algoritmos, de modo que o cálculo do valor de delta, o cálculo do
valor das raízes (quando houverem) e a impressão dos resultados, sejam realizadas por meio de sub-
rotinas, que serão chamadas pelo programa principal.

Algoritmo Calcula_Bhaskara
Var delta,raiz1,raiz2,a_dig,b_dig,c_dig: real
//Definição da função que calcula o delta
Função calcula_delta(a, b, c: real): real
Início
Retorne b**2-4*a*c
Fim
//Definição da função que calcula x1
Função calcula_x1(d, a, b: real): real
Início
Retorne (-b+d**(1/2))/(2*a)
Fim
//Definição da função que calcula x2
Função calcula_x2(d, a, b: real): real
Início
Retorne (-b-d**(1/2))/(2*a)
Fim
//Definição do procedimento que calcula e imprime o resultado
Procedimento imprime_resultado(d,a,b:real)
Início
Se d < 0 então
Escreva ("A equação não possui raízes reais!")
Senão
Se d = 0 então
raiz1 ← calcula_x1(d,a,b)
Escreva ("A equação possui uma raiz, cujo valor é",raiz1)
Senão
raiz1 ← calcula_x1(d,a,b)
raiz2 ← calcula_x2(d,a,b)
Escreva ("A equação possui duas raízes, cujos valores são”,raiz1,”e”,raiz2)
Fimse
Fimse
Fim
//Programa principal
Início
//Entrada de dados (índices da equação)
Escreva ("Digite o valor de a: "))
Leia (a_dig)
Escreva ("Digite o valor de b: ")
Leia (b_dig)
Escreva ("Digite o valor de c: ")
Leia (c_dig)
//Chamada da função que calcula o valor de delta
delta = calcula_delta(a_dig,b_dig,c_dig)
//Chamada do procedimento que imprime os resultados
imprime_resultado(delta,a_dig.b_dig)
Fim
9.7 Escrever um programa que receba como entrada dois números inteiros e apresente os seguintes
resultados: maior valor digitado (obtido por uma função chamada Calcula_Maior); resultado da
multiplicação dos dois números digitados (obtido por uma função chamada Multiplica_Numeros);
se cada número digitado é positivo ou negativo (obtido pela função Verifica_Sinal).

Algoritmo Verifica_Numeros

Var num1, num2,maior: inteiro

//Definição da função que verifica o maior valor digitado

Função Calcula_Maior (num_1, num_2: inteiro): inteiro
Início
Se num_1 > num_2 então
Retorna num_1
Senão
Retorna num_2
Fimse
Fim

Função Multiplica_Numeros (numero_1, numero_2: inteiro): inteiro

Início
Retorna num1 * num2
Fim

Função Verifica_Sinal (numero: inteiro): logico

Início
Se numero < 0 então
Retorne Falso
Senão
Retorne Verdadeiro
Fimse
Fim

//Programa principal
Início
//Entrada de dados
Escreva ("Digite o primeiro número: "))
Leia (num1)
Escreva ("Digite o segundo número: "))
Leia (num2)

//Verifica o maior dos números digitados

Se num1 = num2 então
Escreva ("Os dois números digitados são iguais")
Senão
maior ← Calcula_Maior(num1,num2)
Escreva ("O maior número digitado foi: ",maior)
Fimse

//Multiplicação dos dois números

Escreva ("O resultado da multiplicação dos dois números é",Multiplica_Numeros(num1,
num2))
//Verifica se os números são positivos ou negativos
Se num1 = 0 então
Escreva ("O primeiro número digitado é zero")
Senão
Se Verifica_Sinal(num1) = Verdadeiro então
Escreva ("O primeiro número digitado é positivo")
Senão
Escreva ("O primerio número digitado é negativo")
Fimse
Fimse
Se num2 = 0 então
Escreva("O segundo número digitado é zero")
Senão
Se Verifica_Sinal(num2) = Verdadeiro então
Escreva ("O segundo número digitado é positivo")
Senão
Escreva ("O segundo número digitado é negativo")
Fimse
Fimse
Fim
9.8 Desenvolva um algoritmo que receba como entrada um caractere e, por meio de uma sub-rotina,
verifica e imprime a informação que o caractere digitado trata-se de uma vogal ou consoante. Deve-
se partir do princípio que o usuário digitará uma letra e não um número ou qualquer outro caractere
especial.

Algoritmo Verifica_letra

Var letra_dig:caractere

//Definição do procedimento
Procedimento verifica (letra: caractere)
Início
Se letra='a' OU letra='e' OU letra='i' OU letra='o' OU letra='u' OU letra='A' OU letra='E' OU
letra='I' OU letra='O' OU letra='U' então
Escreva ("O caractere digitado é vogal.")
Senão
Escreva ("O caractere digitado é consoante.")
Fimse
Fim

//Programa principal
Início
//Entrada de dados
Escreva ("Digite uma letra do alfabeto: ")
Leia (letra_dig)
//Chamada do procedimento
verifica (letra_dig)
Fim
9.9 Escreva um programa que recebe como entrada dois números inteiros positivos e, por meio de
uma função, calcula a soma dos números inteiros existentes entre eles (excluindo eles próprios),
retornando tal valor para o programa principal. O programa deve validar a entrada, ou seja, ficar
apresentando a mensagem de entrada inválida e solicitando um valor correto, até que a entrada seja
válida.
O programa deve tratar os casos em que não existem números entre os valores digitados,
apresentando tal mensagem na tela.

Algoritmo Soma_entre_limites
Var num1,num2,resultado:inteiro

//Definição da função
Função calcula_soma (inferior,superior: inteiro): inteiro
Var soma:inteiro
Início
soma ← 0//Inicialização da variável de soma
Para i de inferior+1 até superior passo 1 faça
soma ← soma + i
Fimpara
Retorne soma
Fim

//Programa principal
Início
Escreva ("Digite o primeiro número: ")
Leia (num1)
Enquanto num1 <= 0 faça//Validação da primeira entrada
Escreva ("Valor inválido! Digite um número inteiro positivo: ")
Leia (num1)
Fimenquanto
Escreva ("Digite o segundo número: ")
Leia (num2)
Enquanto num2 <= 0 faça//Validação da segunda entrada
Escreva ("Valor inválido! Digite um número inteiro positivo: ")
Leia (num2)
Fimenquanto
Se num1 = num2 OU (num1-num2) = 1 OU num2-num1 = 1 então
Escreva ("Não existem números entre os valores digitados!")
Senão
Se num1 < num2 então
resultado ← calcula_soma(num1,num2)//Chamada da função
Senão
resultado ← calcula_soma(num2,num1)//Chamada da função
Fimse
Fimse
//Saída de dados
Escreva ("A soma dos números existentes entre",num1,"e",num2,"é",resultado)
Fim
9.10 Desenvolva um algoritmo que, por meio de sub-rotinas, realiza e apresenta o somatório dos N
primeiros números primos, sendo que o valor de N é digitado pelo usuário. O programa deverá
possuir uma função e um procedimento: a função verifica se determinado número é primo; já o
procedimento, calcula o somatório e imprime o resultado. O programa principal deverá receber o
valor de “N” digitado pelo usuário e invocar o procedimento que realiza e mostra o somatório dos
números primos, que por sua vez chama a função que verifica se determinado número é primo. O
programa não deverá permitir que o usuário digite um valor de “N” menor do que 1, mostrando
repetidamente a mensagem de valor inválido, até que o usuário digite um número inteiro positivo.
Obs.: número primo: números inteiros positivos, diferentes de 1, que possuem apenas dois
divisores: o 1 (um) e ele mesmo.

Algoritmo Somatório_primos
Var n_dig: inteiro

//Definição da função que verifica se o número é primo

Função verifica_primo (numero: inteiro): logico
Var numDiv: inteiro
Início
numDiv ← 0//Inicialização da variável que soma o número de divisores
Para i de 2 até numero passo 1 faça
Se numero % i = 0 então
numDiv ← numDiv + 1
Fimse
Fimpara
Se numDiv = 0 então
Retorne Verdadeiro
Senão
Retorne Falso
Fimse
Fim

//Definição do procedimento que soma os primos e apresenta o resultado

Procedimento soma_primos (n: inteiro)
Var
soma,qtd_primos,num: inteiro
e_primo: logico
Início
soma ← 0//Inicialização da variável que soma o número de primos
qtd_primos ← 0//Inicialização da variável que conta o número de primos
num ← 2//Inicialização da variável que guarda o número a ser verificado
Enquanto qtd_primos < n faça
e_primo ← False
e_primo ← verifica_primo(num)
Se e_primo = Verdadeiro então
soma ← soma + num
qtd_primos ← qtd_primos + 1
Fimse
num ← num + 1
Fimenquanto
//Saída de dados
Escreva ("O somatório dos",n,"primeiros números primos é",soma)
Fim
//Programa principal
Início
//Entrada de dados
Escreva ("Digite o valor de n: ")
Leia (n_dig)
//Validação da entrada
Enquanto n_dig <= 0 faça
Escreva ("Valor inválido! Digite um número inteiro positivo: ")
Leia (n_dig)
Fimenquanto
soma_primos(n_dig)//Chamada do procedimento
Fim
9.11 Utilizando os conceitos de procedimentos e funções, desenvolva um algoritmo que calcule, a
partir de 2 números inteiros positivos P e M, a combinação de M elementos tomados P a P,
conforme a expressão: C = M!/(P!(M – P)!)).
Os valores dos diversos fatoriais existentes na expressão deverão ser obtidos por meio de uma
função para isso destinada.

Algoritmo Calcula_Combinação
Var
p,m: inteiro
c: real

//Definição da função fatorial

Função fatorial (num: inteiro): inteiro
Var fat: inteiro
Início
fat ← 1//Inicialização do valor do fatorial
Se num >= 2 então
Para i de 1 até num+1 passo 1 faça
fat ← fat * i
Fimpara
Fimse
Retorne fat
Fim

//Programa principal
Início
//Entrada de dados
Escreva ("Digite o valor de P: ")
Leia (p)
Enquanto p <= 0 faça//Validação da entrada
Escreva ("Valor inválido! Digite um número inteiro positivo: "))
Leia (p)
Fimenquanto
Escreva ("Digite o valor de M: ")
Leia (m)
Enquanto m <= 0 faça//Validação da entrada
Escreva ("Valor inválido! Digite um número inteiro positivo: "))
Leia (m)
Fimenquanto
//Processamento (chamadas da função)
c ← fatorial(m) / (fatorial(p) * fatorial(m - p))
//Saída de dados
Escreva ("O resultado da combinação de",m,"tomados",p,"a",p,"é",c)
Fim
9.12 Elabore um algoritmo que possua uma função que lê um número positivo do teclado, de modo
similar à função input (nativa do Python). A diferença é que, caso o usuário não forneça um número
inteiro positivo, a função repete a leitura até que um número positivo seja lido. O código da função
pode usar a função input e deverá retornar o número lido.
O programa principal deve chamar a função que lê um número do teclado 3 vezes, para a leitura de
3 números distintos. O programa não deve permitir que o usuário entre com valores iguais. No final,
o programa deverá imprimir os números digitados na ordem decrescente.

Algoritmo Ordem_decrescente
Var num1,num2,num3,maior,medio,menor: inteiro

//Definição da função
Função le_numero(): inteiro
Var numero: inteiro
Início
Escreva ("Digite um número inteiro positivo: ")
Leia (numero)
Enquanto numero <= 0 faça
Escreva ("Valor inválido! Digite um número inteiro positivo: ")
Leia (numero)
Fimenquanto
Retorne numero
Fim

//Programa principal
Início
num1 ← le_numero()
num2 ← le_numero()
Enuanto num2 = num1 faça
Escreva ("Valor deve ser distinto de valores já digitados!”)
num2 = le_numero()
Fimenquanto
num3 ← le_numero()
Enquanto num3 = num1 OU num3 = num2 faça
Escreva ("Valor deve ser distinto de valores já digitados!”)
num3 = le_numero()
Fimenquanto

#Inicialização das variáveis

maior ← 0
menor ← 0
medio ← 0

#Fazendo as comparações
Se num1 > num2 E num1 > num3 então
maior ← num1
Se num2 > num3 então
medio ← num2
menor ← num3
Senão
medio ← num3
 menor ← num2
Fimse
Senão
Se (num1 > num2 E num1 < num3) OU (num1 < num2 and num1 > num3) então
medio ← num1
Se num2 > num3 então
maior ← num2
menor ← num3
Senão
maior ← num3
menor ← num2
Fimse
Senão
menor ← num1
Se num2 > num3 então
maior ← num2
medio ← num3
Senão
maior ← num3
medio ← num2
Fimse
Fimse
Fimse

//Imprimindo o resultado
Escreva ("Números em ordem decrescente: ",maior,medio,menor)
Fim