Você está na página 1de 9

Exercícios Complementares de enquanto/faça

nquanto/faça

01. Escreva um algoritmo que receba a idade de um grupo de pessoas, calcule e imprima a
quantidade de pessoas maiores de idade (idade >= 18 anos). Para encerrar a entrada de
dados, deve ser digitado um valor < 0.
Resolução:
algoritmo enquanto_01;
início
inteiro idade, qtde_maior_idade;

qtde_maior_idade  0;
escreva(“Digite a primeira idade ou idade <0 para parar :”);
leia(idade);
enquanto (idade >= 0) faça
início
se ( idade >= 18 ) então
qtde_maior_idade  qtde_maior_idade + 1;

escreva(“Digite a próxima a idade da pessoa ou idade <0 para parar: ”);


leia(idade);
fim;
escreva (“Nº de pessoas maiores de idade: ”,qtde_maior_idade);
fim.

02. Escreva um algoritmo que receba a idade de um grupo de pessoas, calcule e imprima a
porcentagem de cada faixa etária em relação ao total de pessoas.

As faixas etárias são:


01 - 15 anos - A
16 - 30 anos - B
31 - 45 anos - C
46 - 60 anos - D
>= 61 anos - E

Para encerrar a entrada de dados, digite uma idade <= 0.


Resolução:
algoritmo enquanto_02;
início
inteiro idade ,qtde_faixa_a,
qtde_faixa_b,qtde_faixa_c,
qtde_faixa_d,qtde_faixa_e;

real qtde_pessoas;

qtde_pessoas  0;
qtde_faixa_a  0;
qtde_faixa_b  0;
qtde_faixa_c  0;
qtde_faixa_d  0;
qtde_faixa_e  0;
escreva(“Digite a primeira idade ou idade<=0 para parar: ”);
leia(idade);
enquanto (idade > 0) faça
início
qtde_pessoas  qtde_pessoas + 1;
se(( idade>=1)&&(idade<=15)) então
qtde_faixa_a  qtde_faixa_a + 1;
senão
se (( idade>=16)&&(idade<=30)) então
qtde_faixa_b  qtde_faixa_b + 1;
senão
se (( idade>=31)&&(idade<=45)) então
qtde_faixa_c  qtde_faixa_c + 1;
senão
se (( idade>=46)&&(idade<=60)) então
qtde_faixa_d  qtde_faixa_d + 1;
senão
qtde_faixa_e  qtde_faixa_e + 1;
escreva(“Digite a idade ou idade<=0 para parar: ”);
leia(idade);
fim;
escreva (“Qtde. pessoas faixa A em % : “,((qtde_faixa_a / qtde_pessoas) * 100));
escreva (“Qtde. pessoas faixa B em % : “,((qtde_faixa_b / qtde_pessoas) * 100));
escreva (“Qtde. pessoas faixa C em % : “,((qtde_faixa_c / qtde_pessoas) * 100));
escreva (“Qtde. pessoas faixa D em % : “,((qtde_faixa_d / qtde_pessoas) * 100));
escreva (“Qtde. pessoas faixa E em % : “,((qtde_faixa_e / qtde_pessoas) * 100));
fim.

03. Escreva um algoritmo que receba um conjunto de valores inteiros e positivos,calcule e


imprima o maior e o menor valor do conjunto.

 Para encerrar a entrada de dados, deve ser digitado o valor zero.


 Para valores negativos, deve ser enviada uma mensagem.
 Esses valores (zero e negativo) não entrarão nos cálculos.
Resolução:
algoritmo enquanto_03;
início
inteiro valor, maior, menor;

escreva(“Digite um valor :”);


leia(valor);
maior  valor;
menor  valor;
enquanto ( valor != 0) faça
início
se (valor < 0) então
escreva (“Você digitou um valor negativo, digite novamente !”);
senão
se (valor > maior) então
maior  valor;
senão
se ( valor < menor) então
menor  valor;
escreva(“Digite um valor :”);
leia(valor);
fim;
escreva (“Maior valor: ”,maior);
escreva (“Menor valor: ”,menor);
fim.

04. Faça um algoritmo que apresente um menu de opções para o cálculo das seguintes
operações entre dois números: adição, subtração, multiplicação e divisão. Possibilitar ao
usuário escolher a operação desejada, mostrar o resultado e voltar ao menu de opções.
Resolução:
algoritmo enquanto_04;
início
caractere oper;
inteiro num1, num2;
real resultado;

escreva (“Escolha operação :”);


escreva (“+ - * /”);
escreva (“S ou s - encerrar”);
leia(oper);
enquanto( (oper != ‘S’) && (oper != ‘s’)) faça
início
se ( (oper != ‘+’) && (oper != ‘-‘) && (oper != ‘*’) && (oper != ‘/’)) então
escreva (“Operação inválida !!!”);
senão
início
escreva(“Valor 1:”);
leia(num1);
escreva(“Valor 2:”);
leia(num2);
escolha (oper)
inicio
caso ’+’: resultado  num1 + num2; pare;
caso ‘-‘: resultado  num1 - num2; pare;
caso ‘*’: resultado  num1 * num2; pare;
caso ‘/’: resultado  num1 / num2; pare;
caso contrário: escreva(“Opcao invalida!”);
fim;
escreva (“Resultado: “,resultado);
fim;
escreva (“Escolha operação :”);
escreva (“+ - * /”);
escreva (“S ou s - encerrar”);
leia(oper);
fim;
fim.

05. Faça um algoritmo receba o código de várias mercadorias vendidas em um determinado


dia. Os códigos obedecem a tabela abaixo:
“L” ou “l” - limpeza
“A” ou “a” - alimentação
“H” ou “h” - higiene

Calcule e imprima:
• total vendido naquele dia, com todos os códigos juntos;
• total vendido naquele dia em cada um dos códigos.
Para encerrar a entrada de dados, digite o valor da mercadoria zero.
Resolução
algoritmo enquanto_05;
início
caractere codigo;
inteiro qtde_total, qtde_limp, qtde_alim, qtde_hig;

qtde_total  0;
qtde_limp  0;
qtde_alim  0;
qtde_hig  0;
escreva(“Digite o código da mercadoria ou 0 para parar: “);
leia(codigo);
enquanto ( codigo != ‘0’ ) faça
início
escolha (codigo)
inicio
caso `L`: caso`l` : qtde_limp  qtde_limp + 1; pare;
caso `A`: caso `a` : qtde_alim  qtde_alim + 1; pare;
caso `H`: caso `h` : qtde_hig  qtde_hig + 1; pare;
caso contrário: escreva (“Código inexistente !!!”);
fim;
escreva(“Digite o código da mercadoria ou código 0 para parar: “);
leia(codigo);
fim;
qtde_total  qtde_limp + qtde_alim + qtde_hig;
escreva (“Qtde. total = “, qtde_total);
escreva (“Qtde. limpeza = “, qtde_limp);
escreva (“Qtde. alimentação = “, qtde_alim);
escreva (“Qtde. higiene = “, qtde_hig);
fim.

Exercícios Complementares de faça/


faça/enquanto

01. Faça um algoritmo que receba como entrada, uma lista de números positivos ou
negativos finalizada com o número zero e forneça, como saída, a soma dos números
positivos, a soma dos números negativos e a soma das duas parciais.
Resolução
algoritmo faça_enquanto_01;
início
inteiro soma_pos, soma_neg, soma_tot, valor;

soma_pos  0;
soma_neg  0;
faça
inicio
escreva(“Digite um valor ou zero para parar: “);
leia(valor);
se (valor != 0) então
se (valor > 0) então
soma_pos  soma_pos + valor;
senão
soma_neg  soma_neg + valor;
fim;
enquanto (valor != 0);
soma_tot  soma_pos + soma_neg;
escreva (“A soma dos valores positivos = “,soma_pos);
escreva (“A soma dos valores negativos = “,soma_neg);
escreva (“A soma total dos valores lidos = “,soma_tot);
fim.
02. Faça um algoritmo que receba a idade e a altura de várias pessoas, calcule e imprima a
média das alturas das pessoas com mais de 50 anos. Para encerrar a entrada de dados,
digite idade <= zero.
Resolução:
algoritmo faça_enquanto_02;
início
inteiro idade, num_pessoas_50;
real altura, soma_alt_50, media_alt_50;

num_pessoas_50  0;
soma_alt_50  0;
faça
inicio
escreva(“Digite a idade da pessoa ou idade <= 0 para parar: “);
leia(idade);
se (idade > 50) então
início
escreva(“Digite a altura da pessoa : “);
leia(altura);
num_pessoas_50  num_pessoas_50 + 1;
soma_alt_50  soma_alt_50 + altura;
fim;
fim; //bloco do faça enquanto
enquanto (idade > 0);
se (num_pessoas_50 > 0) então
inicio
media_alt_50  soma_alt_50 /num_pessoas_50;
escreva (“Média de altura das pessoas com mais de 50 anos : “,media_alt_50);
fim;
senão
escreva(“NÃO existem pessoas com idade maior do que 50 anos”);
fim.
03. Construa um algoritmo que leia um conjunto de valores inteiros e positivos, e determine
qual o menor e o maior valor do conjunto. Para valor final de entrada considerar o valor -1
que não deve ser considerado.
Resolução
algoritmo faça_enquanto_03;
início
inteiro maior, menor, valor;
caractere primeira_vez;

primeira_vez `s`;
faça
inicio
escreva(“Digite um valor : “);
leia(valor);
se (valor != - 1) então
início
se (primeira_vez = `s`) então
início
maior  valor;
menor  valor;
primeira_vez  `n`;
fim;
senão
inicio
se (valor > maior) então
maior  valor;
senão
se (valor < menor) então
menor  valor;
fim;
fim;
fim;
enquanto (valor != -1);
escreva (“Maior valor : “, maior);
escreva (“Menor valor : “, menor);
fim.
Exercícios Complementares do comando para/faça
para/faça

01. Escreva um algoritmo para calcular N! (fatorial de N), sendo que o valor inteiro de N é
fornecido pelo usuário.

Sabe-se que: N! = 1 * 2 * 3 * ... * (N-1) * N;


0! = 1
Resolção:
algoritmo para_01;
início
inteiro i, n, fat;

faça
inicio
escreva(“Digite um valor >= 0 para calcular o fatorial: “);
leia(n);
se ( n< 0 ) então
escreva(“ Numero invalido!”);
fim;
enquanto(n<0);
fat  1;
para( i  2; i<= n; i  i + 1)
fat  fat * i;
escreva (“Fatorial de “,n,” = “,fat);
fim.

02. A conversão de graus Farenheit para Centígrados é obtida por C = (5/9) * (F - 32). Faça
um algoritmo que calcule e escreva uma tabela de graus Centígrados e os graus Farenheit,
que variam de 50 a 65 de 1 em 1.
Resolução:
algoritmo para_02;
início
real C;
inteiro F;

escreva (“Tabela Farenheit - Centigrados”);


para(F 50 ; F <= 65 ; F  F + 1) faça
início
C  (5/9.0) * ( F - 32);
escreva (F,” “,C);
fim;
fim.

03. Faça um algoritmo que receba a idade e o estado civil : C - casado, S - solteiro, V - viúvo
e D - desquitado, de 10 pessoas. Calcule e imprima:

 a quantidade de pessoas casadas;


 a média das idades das pessoas viúvas.

Resolução:
algoritmo para_03;
início
inteiro i, idade, qtde_cas, qtde_viu;
caractere estado;
real med_viu, soma_idad_viu;

qtde_cas  0;
qtde_viu  0;
soma_idad_viu  0;
med_viu  0;
para( i  1; i<= 10; i  i + 1)
início
escreva(“Digite a idade da pessoa : );
leia(idade);
escreva(“Digite o estado civil: );
leia(estado);
se ( (estado == ‘C’) || (estado == ‘c’) ) então
qtde_cas  qtde_cas + 1;
senão
se ( (estado == ‘V’) || (estado == ‘v’) ) então
início
qtde_viu  qtde_viu + 1;
soma_idad_viu  soma_idad_viu + idade;
fim;
fim;
se (qtde_viu != 0) então
med_viu  soma_idad_viu / qtde_viu;
escreva (“Qtde. pessoas casadas: “,qtde_cas);
escreva (“Média de idade dos viúvos: “,med_viu);
fim.

Você também pode gostar