Resolução Lista Parâmetros

Prévia do material em texto

Parâmetros 
 
1) Dado o exercício 8 da Lista 1: “Uma fábrica de camisetas produz os tamanhos pequeno, médio e 
grande, cada uma sendo vendida respectivamente por 10, 12 e 15 reais. Construa um algoritmo em 
que o usuário forneça a quantidade de camisetas pequenas, médias e grandes referentes a uma 
venda, e o programa informe quanto será o valor arrecadado” 
 
algoritmo “vendas”; 
 
var 
 
 
procedimento calculo(p_peq : inteiro, p_med : inteiro, p_grande : inteiro, VAR val_peq: real, VAR 
val_med : real, VAR val_grande : real) 
 
inicio 
 val_peq <- p_peq * 10; 
 val_med <- p_med * 12; 
 val_grande <- p_grande * 15; 
fimprocedimento 
 
inicio 
var 
 peq, med, grande : inteiro; 
 val_peq, val_med, val_grande : real 
 
 leia(peq, med, grande); 
 
 calculo(peq, med, grande, val_peq, val_med, val_grande); 
 
 escreva(val_peq, val_med, val_grande); 
 
fimalgoritmo 
 
 
2) Dado o exercício 10 da Lista2: “A empresa Hipotheticus paga R$10,00 por hora normal 
trabalhada, e R$15,00 por hora extra. Faça um algoritmo para calcular e imprimir o salário bruto e o 
salário líquido de um determinado funcionário. Considere que o salário líquido é igual ao salário 
bruto descontando-se 10% de impostos.” 
 
algoritmo “pagamento”; 
 
funcao Calc_Sal_Bruto(p_hora_normal: real, p_hora_extra : real): real 
var 
 valor_hora_normal, valor_hora_extra : real; 
 
inicio 
 valor_hora_normal <- p_hora_normal * 10.00; 
 valor_hora_extra <- p_hora_extra * 15.00; 
 
 retorne valor_hora_normal + valor_hora_extra; 
 
fimfunção 
 
funcao Calc_Sal_Liq(p_sal_bruto : real): real 
inicio 
 
 retorne p_sal_bruto * 0.90; 
 
fimfunção 
 
 
inicio 
 
var 
 hora_normal, hora_extra : real; 
 
 salario_bruto, salario_liquido : real; 
 
 leia(hora_normal); 
 leia(hora_extra); 
 
 salario_bruto <- Calc_Sal_Bruto(hora_normal, hora_extra); 
 
 salario_liquido <- Calc_Sal_Liq(salario_bruto); 
 
 escreva(salário_bruto); 
 escreva(salário_liquido); 
fimalgoritmo 
 
 
3) Dado o exercício 7 da Lista 3: “Tendo como dados de entrada a altura e o sexo (M e F) de uma 
pessoa, construa um algoritmo que calcule sue peso ideal, utilizando as seguintes fórmulas: 
• Para homens: (72.7 * h) – 58; 
• Para mulheres: (62.1 * h) – 44.7. “ 
Faça esse algoritmo criando as funções ideal_homem e ideal_mulher, para o cálculo do peso ideal 
para cada sexo, onde o valor da altura é passado como parâmetro. 
 
algoritmo “peso_ideal”; 
 
 
funcao ideal_homem(p_altura : real): real 
inicio 
 retorne (72.7 * p_altura) – 58; 
fimfuncao 
 
funcao ideal_mulher(p_altura : real): real 
inicio 
 retorne (62.1 * p_altura) – 44.7; 
fimfuncao 
 
 
inicio 
 
var 
 peso_ideal, altura : real; 
 sexo : caracter; 
 
 leia(altura); 
 leia(sexo); 
 
 se (sexo = “M”) então 
 escreva(ideal_homem(altura)); 
 senão 
 escreva(ideal_mulher(altura)); 
 fimse 
 
fimalgoritmo 
 
 
 
4) Faça uma calculadora com as 4 operações básicas da matemática (soma, subtração, divisão e 
multiplicação). Essa calculadora realizará cálculos até que o usuário informe o caractere # para a 
operação. IMPORTANTE: para cada uma das quatro operações básicas, deve ser criado um 
procedimento que receberá como parâmetro os operandos da operação. Impedir que na operação de 
divisão (/) ocorre de um número se dividido por 0 (zero) 
 
algoritmo “Calculadora”; 
 
 
funcao soma(op1, op2 : real): real 
inicio 
 retorne op1 + op2; 
fimfunçao 
 
 
funcao subtracao (op1, op2 : real) : real 
inicio 
 retorne op1 - op2; 
fimfunçao 
 
funcao multilicacao (op1, op2 : real) : real 
inicio 
 retorne op1 * op2; 
fimfunçao 
 
funcao divisao (op1, op2 : real) : real 
inicio 
 se (op2 <> 0) entao 
 retorne op1 / op2; 
 senão 
 retorne 0; 
 fimse 
fimfunçao 
 
 
inicio 
 
var 
 operando1, operando2 : real 
 operador : caractere; 
 
 
 leia(operador); 
 enquanto (operador <> “#”) faca 
 
 leia(operando1, operando2); 
 
 escolha operador 
 caso ‘+’ : 
 escreva(soma(operando1, operando2)); 
 
 caso ‘-‘ : 
 escreva(subtracao(operando1, operando2)); 
 
 caso ‘*’ : 
 escreva(multilicacao(operando1, operando2)); 
 
 caso ‘/’ : 
 escreva(divisao(operando1, operando2)); 
 
 
 outroscasos 
 inicio 
 escreva(“Operação invalida”); 
 fim 
 fimcaso 
 
 leia(operador) 
 
 fimenquanto 
fimalgoritmo 
 
 
 
5) Faça um algoritmo que leia um número informado pelo cliente e calcule o seu dobro. Esse 
cálculo deve ser realizado em um PROCEDIMENTO chamado cálculo que recebe um parâmetro 
por Referência. 
 
algoritmo “ex04”; 
 
 
procedimento dobro(VAR x : real) 
inicio 
 x <- x * 2; 
fimprocedimento 
 
inicio 
 
var 
 num : real; 
 
 
 leia(num); 
 dobro(num); 
 escreva(num); 
fimalgotimo 
 
 
6) A empresa Fortex vai pagar um bônus de fim-de-ano aos seus funcionários. Faça um algoritmo 
para ler o salário de um funcionário (em reais) e seu tempo de trabalho na empresa (em anos), e 
depois imprimir este salário com um bônus de acordo com os critérios abaixo: 
 
• Para salários de até R$ 400,00 – bônus de 15 %; 
• Para salários entre R$ 400,01 e R$ 1.000,00 – bônus de 12 %; 
• Para salários acima de R$ 1.000,01 – bônus de 5 %; 
 
Faça um PROCEDIMENTO chamado calculo_bonus que receba como parâmetro (por referencia) o 
salário e por valor o percentual do bonus. 
 
Todos os funcionários com pelo menos 3 (três) anos de casa também ganham um bônus 
complementar de 10 % (sobre o bônus anterior). Para isso faça uma FUNÇÃO chamada 
calculo_bonus_extra que receba como parâmetro o salário a ser reajustado em 10 %. 
 
algoritmo “bonus_Fortex”; 
 
 
procedimento calculo_bonus(var sal : real, bônus : inteiro) 
inicio 
 sal <- sal + (sal * bônus / 100); 
fimprocedimento 
 
função calculo_bônus_extra(sal : real): real 
inicio 
 retorne sal + (sal * 10 / 100); 
fimprocedimento 
 
 
inicio 
var 
 salario : real; 
 tempo : inteiro: 
 
 
 leia(salário); 
 leia(tempo); 
 
 se (salário <= 400) então 
 calculo_bônus(salário, 15); 
 senão 
 se( salário <= 1000) entao 
 calculo_bônus(salário, 12); 
 senao 
 calculo_bônus(salário, 5); 
 fimse 
 fimse 
 
 se (tempo >=3) então 
 escreva(calculo_bônus_extra(salário)); 
 fimse 
 
 
fimalgoritmo 
 
 
7) O que será mostrado na tela nos algoritmos a seguir 
 
a) 
algoritmo “ex_valor”; 
 
 
procedimento alteravalor(x : inteiro) 
inicio 
 escreva(x); 
 x <- 5; 
 escreva(x); 
fimprocedimento 
 
inicio 
 
var 
 n : inteiro; 
 
 
 leia(n); 
 escreva(n) 
 alteravalor(n) 
 escreva(n); 
fimalgoritmo 
 
n Resultado 
4 4, 4, 5, 4 
17 17, 17, 5, 17 
12 12, 12, 5, 12 
 
b) 
nome “ex_referencia”; 
 
procedimento alteravalor(var x : inteiro) 
Inicio 
 escreva(x); 
 x <- 5; 
 escreva(x); 
fimprocedimento 
 
inicio 
 
var 
 n : inteiro; 
 
 leia(n); 
 escreva(n) 
 alteravalor(n) 
 escreva(n); 
fimalgoritmo 
 
n Resultado 
6 6, 6, 5, 5 
11 11, 11, 5, 5 
15 15, 15, 5, 5 
 
8) Faça um algoritmo que some o valor de dois números informados pelo usuário. Criar uma função 
com o nome SOMA, função esta que recebe dois parâmetros do tipo Real; 
 
algoritmo “soma”; 
 
função soma(num1, num2 : real): real 
Inicio 
 Retorne num1 +num2; 
fimfuncaoinicio 
 
var 
 n1,n2, resultado : real; 
 
 leia(n1, n2); 
 resultado <- soma(n1,n2); 
 escreva(resultado); 
fimalgoritmo 
 
 
9) Faça uma função que receba um valor real como referência e retorne o resto da divisão deste 
número por 10. Altere também o valor da variável passada por referência, dividindo-a por 10. 
 
algoritmo “exercício_03”; 
 
função resto(var n : real) : real 
var 
 res : real; 
 
Inicio 
 
 res <- n % 10; 
 n <- n / 10; 
 retorne res; 
 
fimfuncao 
 
inicio 
 
var 
 num, resultado : real; 
 
 leia(num); 
 resultado <- resto (num); 
 escreva(resultado); 
 escreva(num); 
fimalgoritmo