- EXERCCIOS PROPOSTOS Lista 2

- PGINAS 25, 26 E 27
1.
Algoritmo_1
programa mensalidade;
const
mens=45;
inteiro
idade;
caractere sexo;
real
total;
inicio
total_mens;
leia (sexo,idade);
se sexo = f ento
se idade<=15 ento
total_mens*0.85
seno
total_mens*0.9
seno
se idade>=22 ento
total_mens*0.8;
escreva(total);
fim.
#include <stdio.h>
#include <stdlib.h>
const mens=45;
int idade;
char sexo;
float total;
int main(int argc, char** argv) {
total=mens;
printf("Digite sexo e idade \n");
scanf("%c%d",&sexo,&idade);
if (sexo=='F' || sexo== 'f')
if (idade<=15)
total=mens*0.85;
else
total=mens*0.90;
else
if (idade>=22)
total=mens*0.8;
printf("\nMensalidade: %.2f\n",total);
return (EXIT_SUCCESS);
}

**********************************************************************
2.
algoritmo media_aluno;
real nota1, nota2, nota3, media;
inicio
leia(nota1, nota2, nota3);

media ((nota1 * 3) + (nota2 * 2) + (nota3 * 5))/10;

se (media >= 7) ento
escreva(Aluno aprovado com mdia , media);
seno
se (media >= 5 E media < 7) ento
escreva(Aluno em exame com mdia , media);
seno
se (media < 5) ento
escreva(Aluno reprovado com mdia , media);
fim.
**********************************************************************
3.
algoritmo numero_par;
inteiro num, resto_div;
inicio
leia(num);
resto_div num%2;
se (resto_div = 0) ento
escreva(O nmero lido par.);
seno
escreva(O nmero lido no par.);
fim.
**********************************************************************
4.
Algoritmo_4
programa operacoes;
inteiro
n1,n2,codigo;
real
r;
inicio
leia(codigo, n1,n2);
escolha codigo
1: rn1+n2;
2:rn1-n2;
3:rn1*n2;
4:rn1/n2
seno
escreva('cdigo invlido');
fim;
escreva('resultado: ',r);
fim.
#include <stdio.h>
#include <stdlib.h>
int n1,n2,codigo;
float r;

int main(int argc, char** argv)

{

printf("1- adicao 2-subtracao 3-multiplicacao 4-divisao\n");

printf("digite a opcao\n");
scanf("%i",&codigo);
printf("digite os dois valores inteiros\n");
scanf("%i%i",&n1,&n2);
switch (codigo)
{
case 1: r= n1+n2;
break;
case 2: r= n1-n2;
break;
case 3: r= n1*n2;
break;
case 4: r= n1/n2;
break;
default: printf("\nopcao invalida\n");
}
printf("resulatdo: %.2f\n",r);
return 0;

**********************************************************************
5.
algoritmo calcula_raizes;
inteiro a, b, c;
real x1, x2;
inicio
leia(a, b, c);
se (a = 0) ento
escreva(No possvel a diviso por zero.);
seno
se((pow(b, 2) 4 * a * c) < 0) ento
escreva( invivel o clculo de razes imaginrias.);
seno
inicio
x1 (-b + sqrt(pow(b, 2) 4 * a * c))/(2 * a);
x2 (-b - sqrt(pow(b, 2) 4 * a * c))/(2 * a);
escreva(x1, x2);
fim;
fim.
**********************************************************************
6.
algoritmo multiplos;
real num1, num2;
inicio
leia(num1, num2);
se (num1 % num2 = 0) ento

escreva(num1, mltiplo de , num2);

se(num2 % num1 = 0) ento
escreva(num2, mltiplo de , num1);
fim.
**********************************************************************
7.
algoritmo maior;
real num1, num2, num3;
inicio
leia(num1, num2, num3);
se(num1 > num2 E num1 > num3) ento
escreva(Maior: , num1);
seno
se(num2 > num3) ento
escreva(Maior: , num2);
seno
escreva(Maior: , num3);
fim.
**********************************************************************
8.
algoritmo triangulo;
real a, b, c, semi_p, area;
inicio
leia(a, b, c);
se ( (a < b + c) E (b < a + c) E (c < a + b)) ento
inicio
se (a = b E a = c) ento
inicio
semi_p (a + b + c)/2;
area sqrt(semi_p * (semi_p a) * (semi_p b) * (semi_p c));
escreva(Tringulo equiltero com rea igual a , area);
fim;
seno
inicio
se (a = b OU a = c OU b = c) ento
inicio
semi_p (a + b + c)/2;
area sqrt(semi_p * (semi_pa) * (semi_pb) * (semi_pc));
escreva(Tringulo issceles com rea igual a , area);
fim;
seno
inicio
semi_p (a + b + c)/2;
area sqrt(semi_p * (semi_pa) * (semi_pb) * (semi_pc));

escreva(Tringulo escaleno com rea igual a , area);

fim;
fim;
fim;
seno
escreva(Os valores informados no podem ser lados de um tringulo.);
fim.
**********************************************************************
9.
algoritmo ordem_crescente;
inteiro a, b, c, aux;
inicio
leia(a, b, c);
se (a > b) ento
inicio
aux a;
a b;
b aux;
fim;
se (a > c) ento
inicio
aux a;
a c;
c aux;
fim;
se (b > c) ento
inicio
aux b;
b c;
c aux;
fim;
escreva(Ordem crescente: , a, , , b, , , c);
fim.
**********************************************************************
10.
algoritmo dinheiro;
real valor;
inteiro t_50, t_10, t_5, t_1, resto;
inicio
t_50 0;
t_10 0;
t_5 0;
t_1 0;
resto 0;

leia(valor);
se (valor >= 50) ento
inicio
resto abs(fmod(valor, 50));
t_50 valor/50;
se (resto >= 10) ento
inicio
t_10 resto/10;
resto abs(fmod(resto, 10));
fim;
se (resto >= 5) ento
inicio
t_5 resto/5;
resto abs(fmod(resto, 5));
fim;
se (resto >= 1) ento
t_1 resto;
fim;
seno
inicio
se (valor >= 10) ento
inicio
resto abs(fmod(valor, 10));
t_10 valor/10;
se (resto >= 5) ento
inicio
t_5 resto/5;
resto abs(fmod(resto, 5));
fim;
se (resto >= 1) ento
t_1 resto;
fim;
seno
inicio
se (valor >= 5) ento
inicio
resto abs(fmod(valor, 5));
t_5 valor/5;
se (resto >= 1) ento
t_1 resto;
fim;
seno
t_1 valor;
fim;
fim;

escreva(t_50, notas de R$50,00.);

escreva(t_10, notas de R$10,00.);
escreva(t_5, notas de R$5,00.);
escreva(t_1, notas de R$1,00.);
fim.
**********************************************************************
11.
Algorimo_11
programa jogo;
inteiro
hi,hf,dh;
inicio
leia(hi,hf);
se hi<hf ento
dh_hf-hi
seno
dh_24-hi+hf;
escreva(dh,' horas');
fim.
#include <stdio.h>
int hi,hf,dh;
int main(void)
{
printf("Digite hora inicial e final (meia noite=0)\n");
scanf("%i%i",&hi,&hf);
if (hi<hf)
dh=hf-hi;
else
dh=24-hi+hf;
printf("%i horas\n",dh);
}

**********************************************************************
12.
algoritmo jogo;
inteiro hi, hf, mi, mf, hd, md;
inicio
escreva(Digite hora inicial: );
leia(hi);
escreva(Digite minuto inicial: );
leia(mi);
escreva(Digite hora final: );
leia(hf);
escreva(Digite minuto final: );
leia(mf);
se (mi > mf) ento
inicio

mf mi + 60;
hf hf 1;
fim;
se (hi > hf) ento
hf hf + 24;
md mf mi;
hd hf hi;
escreva(O jogo durou , hd, hora(s) e , md, minuto(s).);
fim.
**********************************************************************
13.
algoritmo escolhe_operacao;
const PI = 3.14;
real raio, area, perimetro;
inteiro op;
inicio
leia(op, raio);
se (op = 1) ento
inicio
area PI * pow(raio, 2);
escreva(area);
fim;
seno
inicio
se (op = 2) ento
inicio
perimetro 2 * PI * raio;
escreva(perimetro);
fim;
seno
escreva(Operao invlida!);
fim;
fim.
**********************************************************************
14.
algoritmo ordena;
inteiro I;
real A, B, C;
inicio
escreva(Digite trs valores reais: );
leia(A, B, C);
escreva(Digite um valor inteiro: );
leia(I);

se (I = 1) ento
inicio
se (A < B E A < C) ento
inicio
se (B < A) ento
escreva(A, B, C);
seno
escreva(A, C, B);
fim;
seno
inicio
se (B < A E B < C) ento
inicio
se (A < C) ento
escreva(B, A, C);
seno
escreva(B, C, A);
fim;
seno
se (C < A E C < B) ento
inicio
se (A < B) ento
escreva(C, A, B);
seno
escreva(C, B, A);
fim;
fim;
fim;
seno
inicio
se (I = 2) ento
inicio
se (A > B E A > C) ento
inicio
se (B > A) ento
escreva(A, B, C);
seno
escreva(A, C, B);
fim;
seno
inicio
se (B > A E B > C) ento
inicio
se (A > C) ento
escreva(B, A, C);
seno
escreva(B, C, A);
fim;
seno

se (C > A E C > B) ento

inicio
se (A > B) ento
escreva(C, A, B);
seno
escreva(C, B, A);
fim;
fim;
fim;
seno
inicio
se (I = 3) ento
inicio
se (A > B E A > C) ento
escreva(B, A, C);
seno
inicio
se (B > A E B > C) ento
escreva(A, B, C);
seno
se (C > A E C > B) ento
escreva(A, C, B);
fim;
fim;
seno
escreva(Valor invlido para I.);
fim;
fim;
fim.
**********************************************************************
15.
algoritmo desconto;
real total_compra, valor_final;
inteiro tipo;
inicio
leia(total_compra, tipo);
se (tipo = 1) ento /* funcionrio */
inicio
valor_final (total_compra * 95)/100;
escreva(valor_final);
fim;
seno
inicio
se (tipo = 2) ento /* cliente especial */
inicio
valor_final (total_compra * 90)/100;
escreva(valor_final);

fim;
seno
inicio
escreva(Compra sem desconto!);
escreva(total_compra);
fim;
fim;
fim.
**********************************************************************
16.
algoritmo juros;
real preco_a_vista, preco_com_juros, prestacao;
inteiro n_parcelas;
inicio
leia(preco_a_vista, n_parcelas);
se (n_parcelas = 0) ento
escreva(Valor a pagar: , preco_a_vista);
seno
inicio
se (n_parcelas = 3) ento
inicio
preco_com_juros preo_a_vista + (preo_a_vista * 0.1);
prestao preco_com_juros/3;
escreva(Valor total a pagar: , preco_com_juros);
escreva(Valor de cada uma das 3 parcelas: , prestacao);
fim;
seno
inicio
se (n_parcelas = 5) ento
inicio
preco_com_juros preo_a_vista + (preo_a_vista * 0.2);
prestao preco_com_juros/5;
escreva(Valor total a pagar: , preco_com_juros);
escreva(Valor de cada uma das 5 parcelas: , prestacao);
fim;
seno
escreva(Quantidade de parcelas invlida.);
fim;
fim;
fim.
**********************************************************************
17.
algoritmo lanche;
inteiro codigo, quantidade;

real valor;
inicio
leia(codigo, quantidade);
escolha codigo
100:
inicio
valor quantidade * 3.50;
escreva(valor);
fim;
101:
inicio
valor quantidade * 4.00;
escreva(valor);
fim;
102:
inicio
valor quantidade * 4.50;
escreva(valor);
fim;
103:
inicio
valor quantidade * 4.00;
escreva(valor);
fim;
104:
inicio
valor quantidade * 3.00;
escreva(valor);
fim;
seno
escreva(Cdigo incorreto.);
fim;
fim.
**********************************************************************
18.
algoritmo aumento;
real salario, novo_salario, diferenca;
inteiro codigo;
inicio
leia(salario, codigo);
escolha codigo
101:
inicio
novo_salario salario + (salario * 0.1);
diferenca novo_salario salario;

fim;
102:
inicio
novo_salario salario + (salario * 0.2);
diferenca novo_salario salario;
fim;
103:
inicio
novo_salario salario + (salario * 0.3);
diferenca novo_salario salario;
fim;
seno
inicio
novo_salario salario + (salario * 0.4);
diferenca novo_salario salario;
fim;
fim;
escreva(Salrio antigo: , salario);
escreva(Novo salrio: , novo_salario);
escreva(Diferena: , diferenca);
fim.
**********************************************************************
19.
algoritmo classifica;
real num;
inicio
leia(num);
se (num > 0) ento
escreva(Positivo.);
seno
inicio
se (num < 0) ento
escreva(Negativo.);
seno
escreva(Nulo.);
fim;
fim.
**********************************************************************
20.
algoritmo frutas;
real total_macas, total_peras, total_compra;
inteiro quantidade_macas, quantidade_peras;
inicio
leia(quantidade_macas, quantidade_peras);

se (quantidade_macas < 12) ento

total_macas quantidade_macas * 0.50;
seno
inicio
se (quantidade_macas = 12) ento
total_macas(quantidade_macas*0.5)(quantidade_macas*0.5*0.05);
seno
se (quantidade_macas >= 24) ento
total_macas (quantidade_macas * 0.5) (quantidade_macas
* 0.5 * 0.1);
fim;
se (quantidade_peras < 12) ento
total_peras quantidade_peras * 0.65;
seno
inicio
se (quantidade_peras = 12) ento
total_peras (quantidade_peras*0.65)-(quantidade_peras*0.65*0.04);
seno
se (quantidade_peras >= 36) ento
total_peras (quantidade_peras * 0.65) (quantidade_peras *
0.65 * 0.08);
fim;
total_compra total_macas + total_peras;
escreva(Valor total da compra: R$ , total_compra);
fim.
**********************************************************************
21.
algoritmo vencedor;
inteiro votos1, votos2, votos3, votos4, maior;
caractere cand1, cand2, cand3, cand4, vencedor;
inicio
leia(cand1, votos1);
maior votos1;
vencedor cand1;
leia(cand2, votos2);
se (votos2 > maior) ento
inicio
maior votos2;
vencedor cand2;
fim;
leia(cand3, votos3);
se (votos3 > maior) ento

inicio
maior votos3;
vencedor cand3;
fim;
leia(cand4, votos4);
se (votos4 > maior) ento
inicio
maior votos4;
vencedor cand4;
fim;
escreva(O vencedor da eleio foi o candidato , vencedor, com , maior, votos.);
fim.
**********************************************************************
22.
algoritmo combustivel;
caractere tipo;
real litros, total;
const PG = 2.63, PA = 1.56;
inicio
leia(litros, tipo);
se (tipo = A) ento
inicio
se (litros <= 30) ento
inicio
total (litros * PA) (litros * PA * 0.03);
escreva(Total a pagar: , total);
fim;
seno
inicio
se (litros > 30 E litros <= 40) ento
inicio
total (litros * PA) (litros * PA * 0.05);
escreva(Total a pagar: , total);
fim;
seno
se (litros > 40) ento
inicio
total (litros * PA) (litros * PA * 0.07);
escreva(Total a pagar: , total);
fim;
fim;
fim;
seno
inicio

se (tipo = G) ento
inicio
se (litros <= 20) ento
inicio
total (litros * PG) (litros * PG * 0.04);
escreva(Total a pagar: , total);
fim;
seno
inicio
se (litros > 20 E litros <= 30) ento
inicio
total (litros * PG) (litros * PG * 0.06);
escreva(Total a pagar: , total);
fim;
seno
se (litros > 30) ento
inicio
total (litros * PG) (litros * PG * 0.08);
escreva(Total a pagar: , total);
fim;
fim;
fim;
seno
escreva(Tipo de combustvel invlido.);
fim;
fim.
**********************************************************************
23.
algoritmo poluicao;
inteiro tipo;
real nivel_poluicao;
inicio
leia(tipo, nivel_poluicao);
se (tipo = 1) ento
inicio
se (nivel_poluicao < 0.35) ento
escreva(Nvel de poluio aceitvel.);
seno
inicio
se (nivel_poluicao >= 0.35 E nivel_poluicao <= 0.45) ento
escreva(Ajustar produo.);
seno
se (nivel_poluicao > 0.45) ento
escreva(Paralisar produo.);
fim;
fim;

seno
inicio
se (tipo = 2) ento
inicio
se (nivel_poluicao < 0.3) ento
escreva(Nvel de poluio aceitvel.);
seno
inicio
se (nivel_poluicao >= 0.3 e nivel_poluicao <= 0.4) ento
escreva(Ajustar produo.);
seno
se (nivel_poluicao > 0.4) ento
escreva(Paralisar produo.);
fim;
fim;
seno
inicio
se (tipo = 3) ento
inicio
se (nivel_poluicao < 0.25) ento
escreva(Nvel de poluio aceitvel.);
seno
inicio
se (nivel_poluicao>=0.25 E nivel_poluicao<=0.35) ento
escreva(Ajustar produo.);
seno
se (nivel_poluicao > 0.35) ento
escreva(Paralisar produo.);
fim;
fim;
seno
escreva(Grupo invlido para empresa.);
fim;
fim;
fim.
**********************************************************************
24.
algoritmo idade;
inteiro idade_h_1, idade_h_2, idade_m_1, idade_m_2;
inteiro soma, produto, h_velho, h_novo, m_velha, m_nova;
inicio
leia(idade_h_1, idade_h_2);
leia(idade_m_1, idade_m_2);
se (idade_h_1 > idade_h_2) ento
inicio
h_velho idade_h_1;

h_novo idade_h_2;
fim;
seno
inicio
h_velho idade_h_2;
h_novo idade_h_1;
fim;
se (idade_m_1 > idade_m_2) ento
inicio
m_velha idade_m_1;
m_nova idade_m_2;
fim;
seno
inicio
m_velha idade_m_2;
m_nova idade_m_1;
fim;
soma h_velho + m_nova;
produto h_novo * m_velha;
escreva(Soma: , soma);
escreva(Produto: , produto);
fim.
**********************************************************************
25.
algoritmo data;
inteiro dia, mes, ano, verdadeiro;
inicio
leia(dia, mes, ano);
se (ano >= 1) ento
inicio
verdadeiro 1;
se (mes < 1 OU mes > 12 OU dia < 1 OU dia > 31) ento
verdadeiro 0;
seno
inicio
se ((mes = 4 OU mes = 6 OU mes = 9 OU mes = 11) E dia > 30) ento
verdadeiro 0;
seno
inicio
se (mes = 2) ento
inicio
se ((ano%4 = 0 E ano%100 <> 0) OU ano%400=0) ento
inicio
se (dia > 29) ento
verdadeiro 0;

seno
se (dia > 28) ento
verdadeiro 0;
fim;
fim;
fim;
fim;
fim;
seno
verdadeiro 0;
se (verdadeiro = 0) ento
escreva(Data invlida!);
seno
escreva(Data vlida!);
fim.