Buscar

Lista 1 Portugol

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Você viu 3, do total de 37 páginas

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Você viu 6, do total de 37 páginas

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Você viu 9, do total de 37 páginas

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Prévia do material em texto

Algoritmos e Laboratório de Programação I 
 
 
Lista I – Solucionário em Portugol 
 
 
Exercícios com * indicam que há outra forma de resolução no final do 
documento 
 
 
EXERCÍCIO 01: 
 
Sendo A= 3, B= 7 e C= 4, informe se as expressões abaixo são 
verdadeiras ou falsas. 
 
a) (A+C) > B F 
b) B >= (A + 2) V 
c) C = (B - A) V 
d) (B + A) <= C F 
e) (C+A) > B F 
 
 
EXERCÍCIO 02: 
 
Sendo A=5, B= 4 e C= 3 e D= 6, informe se as expressões abaixo são 
verdadeiras ou falsas. 
 
a) (A > C) E (C <= D) (5 >3) E (3 <= 6) Verdadeiro E Verdadeiro = 
Verdadeiro 
 
b) (A+B) > 10 OU (A + B ) = (C + D) (5 + 4) > 10 OU (5 + 4) = (3 + 6) 
Falso OU Verdadeiro = Verdadeiro 
 
c) (A>=C) E (D >= C) (5 >=3) E (6 >= 3) Verdadeiro E Verdadeiro = 
Verdadeiro 
 
 
EXERCÍCIO 03: 
 
a) B = A * C E L1 
 
Substituindo os valores de A, B, C e L1, temos: 
7 = 2 * 3.5 E falso 
7 = 7 E falso 
verdadeiro E falso 
 
O resultado da expressão lógica com o operador E somente será 
verdadeiro quando ambos os valores de cada lado do operador forem 
verdadeiros. Então, o resultado dessa expressão lógica é: falso. 
 
b) "dia" = S1 OU "frio" != "clima" 
 
Substituindo o valor de S1,temos: 
"dia" = "noite" OU "frio" != "clima" falso OU verdadeiro 
 
O resultado da expressão lógica com o operador OU somente será falso 
quando ambos os valores de cada lado do operador forem falsos. 
Então, o resultado dessa expressão lógica é: verdadeiro. 
 
c) A + C < 5 
 
Substituindo os valores de A e S1, temos: 
2 + 3.5 < 5 
Falso 
 
d) A * C / B > A * B * C 
 
Substituindo os valores de A, B e C, temos: 
2 * 3.5 / 7 > 2 * 7 * 3.5 
7 / 7 > 14 * 3.5 
1 > 49 
Falso 
 
e) NÃO FALSO 
 
O operador lógica NÃO denota o oposto do valor lógico seguinte. Então, 
o resultado dessa expressão lógica é: verdadeiro. 
 
 
EXERCÍCIO 04: 
 
Determine o resultado lógico das expressões mencionadas (Verdadeira ou 
Falsa). Considere para as respostas os seguintes valores: X= 1, A= 3, 
B= 5, C=8 e D=7. 
 
a) NÃO (X > 3) Verdadeiro 
 
b) (X < 1) E (NÃO (B > D)) Falso 
 
c) NÃO (D < 0) E (C > 5) Verdadeiro 
 
d) NÃO ((X > 3) OU (C < 7)) Verdadeiro 
 
e) (A > B) OU (C > B) Verdadeiro 
 
f) (X >= 2) Falso 
 
g) (X < 1) E (B >= D) Falso 
 
h) ( D < 0) OU (C > 5) Verdadeiro 
 
i) NÃO (D > 3) OU (NÃO (B < 7)) Falso 
 
j) (A > B) OU (NÃO (C > B)) Falso 
 
 
EXERCÍCIO 05: 
 
//Efetuar a soma dos números 5 e 10 e imprimir o resultado 
 
principal 
{ 
inteiro P1, P2, SOMA; //declaração de 3 variáveis inteiras 
P1 <- 5; //a 1ª parcela inteira é 5 
P2 <- 10; //a 2ª parcela inteira é 10 
SOMA <- P1 + P2; //a soma inteira é 5 + 10 
imprima("A saída é:”, SAIDA); //impressão do resultado soma 
} 
 
 
 
EXERCÍCIO 06: 
 
//Efetuar a soma de três números digitados pelo usuário e imprimir o 
resultado. 
 
principal 
{ 
//declaração de variáveis do tipo real 
real A,B,C,SOMA; 
 
 //leitura dos números informados pelo usuário 
 imprima ("Informe o primeiro número: 
"); leia (A); 
imprima ("Informe o segundo número: "); 
leia (A); 
imprima ("Informe o terceiro número: "); 
leia (C); 
 
//a variável soma recebe a soma de A, B e C 
SOMA <- A+B+C; 
 
//resultado 
imprima (“A soma é: ”,SOMA); 
} 
 
 
EXERCÍCIO 07: 
 
//Efetuar a multiplicação de dois números digitados pelo 
usuário e imprimir o resultado. 
 
principal 
 
{ 
 
//declaração de variáveis do tipo inteiro (inteiro) 
 
 inteiro a,b,produto; 
 
//leitura dos números informados pelo usuário 
 
imprima("Informe o primeiro numero: "); 
 
 leia(a); 
 
imprima("Informe o segundo numero: "); 
 
 leia(b); 
 
 
//a variável produto recebe o produto de a por b 
 
produto ← a*b; 
 
//resultado 
 
imprima("O produto eh: ",produto); 
 
} 
 
 
 
EXERCÍCIO 08: 
 
//Calcular o aumento que será dado a um funcionário, obtendo do 
usuário as 
 
//seguintes informações : salário atual e a porcentagem de aumento. 
 
//Apresentar o novo valor do salário e o valor do aumento. 
 
 
 
principal 
 
{ 
 
//declaração de variáveis do tipo real (real) 
 
real salario, aumento, novo_salario; 
 
//leitura de dados do funcionário 
imprima("Informe seu salario 
atual"); leia(salario); 
imprima ("Informe a porcentagem de aumento"); 
 
leia (aumento); 
 
//calculo do aumento salarial 
aumento ←salario*aumento/100; 
 
//calculo 
 
novo_salario←salario+aumento; 
 
//impressão 
 
imprima ("O valor do aumento salarial é", aumento); 
 
imprima ("O valor do novo salario é ", novo_salario); 
 
} 
 
 
 
EXERCÍCIO 09: 
 
//Converter uma quantidade de horas digitadas pelo usuário em minutos. 
//Informe o resultado em minutos. 
 
principal 
{ 
//declaração das variáveis inteiras (trata-se de quantidade e não 
frações) 
int horas,minutos; 
 
//leitura das 
horas 
imprima("Horas: 
"); leia(horas); 
 
//conversão horas para minutos (X 60) 
minutos ← horas*60; 
 
//impressão do resultado em minutos 
imprima("Em minutos, é ",minutos); 
} 
 
 
 
EXERCÍCIO 10: 
 
// Leitura: salário bruto e número de horas extras 
//Cálculo: 
//salário líquido = (salário bruto + valor das horas extras) - 8% do 
total de INSS 
//Mostrar: salário líquido 
 
principal 
{ 
// Declaração de Variáveis: 
//horas: quantidade de horas extras (inteiro) 
//bruto: salario bruto (real) 
//valor_extra: valor de cada hora extra (real) 
//liquido: salário líquido a ser calculado (real) 
 
inteiro horas; 
real bruto,valor_extra,liquido; 
 
//Leitura das Informações 
 
imprima("Digite o valor do salário bruto do funcionário: "); 
leia(bruto); 
imprima("Digite o valor das horas extras: "); 
leia(valor_extra); 
imprima("Digite a quantidade de horas extras trabalhadas pelo 
funcionário: "); 
leia(horas); 
 
// O cálculo do salário líquido é: 
// 1) Extra = horas * valor_extra (valor extra total recebido) 
// 2) Salario Parcial = Salário Bruto + Extra (sem desconto) 
// 3) INSS = 8% do Salario Parcial, ou seja, 0.8 * Salario 
Parcial 
// 4) Salario Liquido = Salario Parcial - INSS = (1 - 0.8)* 
Salario Parcial= 0.92 * Salario Parcial 
 
liquido = 0.92 * (bruto + horas * valor_extra); 
 
//Impressão do Salário Líquido: 
imprima("O salário líquido do funcionário é de: ", liquido); 
} 
 
 
EXERCÍCIO 11: 
 
//Leitura do nº de Kw consumido 
//Preço: 0.12 por kw 
//Calcular valor a ser pago: 0.12 * qtd_de_kw + 18% do ICMS 
 
principal 
{ 
 
// Declaração de Variáveis 
// KW é a quantidade de kW consumido e VALOR é o valor a pagar 
 
real KW, VALOR; 
imprima("Informe a quantidade de Kw consumidos:"); 
leia(KW); 
 
//1º cálculo: valor será 0.12 por Kw 
VALOR <- KW * 0,12; 
 
//2º cálculo: pagará 100% do valor + 18% deste, ou seja, 118%. Ou 
//seja: 
VALOR <- VALOR * 1,18; 
 
//Impressão do valor: 
imprima("Valor total a ser pago: “, VALOR); 
 
} 
 
 
EXERCÍCIO 12: 
 
//Calcular a média de combustível gasto pelo usuário, sendo informado 
a 
//quantidade de quilômetros rodados e a quantidade de combustível 
//consumido. 
 
principal 
{ 
//declaração das variáveis reais 
real km,comb,media; 
 
//leitura da quantidade de km rodados 
imprima("Quantidade de KM rodados: "); 
leia(km); 
 
//leitura da quantidade de combustivel consumido 
imprima("Quantidade de Combustivel consumido: "); 
leia(comb); 
 
//cálculo da média (resultado real) 
media ← comb/km; 
 
//impressão da media 
imprima("A media de combustivel por km é: ",media); 
 
} 
 
EXERCÍCIO 13: 
 
//Efetuar a leitura de uma nota e, se o valor for maior ou igual a 60, 
imprimir na tela "APROVADO". 
 
principal 
{ 
//declaração da variavel nota 
inteiro nota; 
 
//leitura da nota 
imprima("Nota do aluno(a): "); 
leia(nota); 
 
//comparação e impressão da mensagem 
se (nota > 60) então 
imprima("APROVADO"); 
} 
 
EXERCÍCIO 14: 
 
//Leia uma nota 
//nota >= 60 -> APROVADO 
//nota < 60 -> REPROVADO 
 
principal 
{ 
//Declaraçãoda variável nota 
real nota; 
 
//Leitura da Nota 
imprima(“Digite a nota: ”); 
leia (nota); 
 
//Verificar se nota é maior ou igual a 60 
se (nota > 60) entao//verifica se a nota é maior ou igual a 60 
{ 
imprima (“Aprovado”); //caso a condição em se for verdadeira 
} 
senão 
{ 
imprima (“Reprovado”); //caso a condição em se for falsa 
} 
 
} 
 
 
EXERCÍCIO 15: 
 
//Efetuar a leitura de uma nota e, se o valor for maior ou igual a 60, 
imprimir na tela "APROVADO", se for menor, imprimir reprovado. Testar 
ainda se o valor lido foi maior do que 100 ou menor do que zero. Neste 
caso, imprimir "NOTA INVÁLIDA". 
 
principal 
{ 
 
//declaração da variavel nota 
//Motivo de ser real: suponhamos que a nota é 100.1 
//Deve ser nota inválida 
//se fosse inteiro, ele pegaria a parte inteira de 
//100.1 que é 100 e diria que está aprovado. 
//Como real ele não comete este erro. 
 
real nota; 
 
//leitura da nota 
imprima ("Nota do aluno(a): "); 
leia (nota); 
 
//comparação e impressão da mensagem 
se ((nota<0) OU (nota>100))entao 
imprima (“NOTA INVÁLIDA"); 
senão se (nota<60)entao 
imprima ("REPROVADO"); 
senão 
 imprima ("APROVADO"); 
} 
 
 
EXERCÍCIO 16: 
 
//Ler um número inteiro e informar se o número lido é par ou impar. 
 
principal 
{ 
inteiro NUM; 
//Declaração de variável inteira. 
imprima(“Informe um número: ”); 
leia(NUM); 
//Leitura do número 
se(NUM mod 2 = 0)entao 
//Se o resto da divisão por 2 é zero... 
{ 
imprima(“PAR”); 
//imprime “par” 
} 
senão 
//senão... 
{ 
imprima(“ÍMPAR”); 
//imprime “ímpar” 
} 
} 
 
 
EXERCÍCIO 17: 
 
//Ler um número inteiro 
//Testar se termina com 0 (divisível por 10) 
//-> Se sim, exiba METADE do numero 
//-> Se não, exiba "O número digitado não termina com 0" 
 
principal 
{ 
inteiro NUM; 
//Declaração de variável inteira NUM 
imprima(“Digite um número: ”); 
leia(NUM); 
//Leitura do número 
se(NUM mod 10 = 0)entao 
//Testando se NUM é divisível por 10 
{ 
//Se sim, imprime metade de NUM. Observe que poderíamos 
criar outra variável conta ← num div 2 e imprimir ela 
imprima(“A metade deste numero é: ”, NUM div 2); 
} 
senão 
{ 
//Se não, imprime a mensagem 
imprima(“O número digitado não termina com 0”); 
} 
} 
 
 
EXERCÍCIO 18: 
 
// Ler um número e informar se ele é positivo, negativo ou neutro 
(zero). 
 
principal 
{ 
//declaração de variáveis do tipo inteiro 
inteiro num; 
 
//leitura e armazenamento do valor 
imprima("Digite um numero"); 
leia(num); 
 
//compara e avalia se o valor é positivo, 
//negativo ou neutro e imprime o resultado 
se (num=0) entao 
imprima ("O valor lido é neutro"); 
senão 
se (num>0) entao 
imprima ("O valor lido é positivo"); 
senão 
imprima ("O valor lido é negativo"); 
 
} 
 
 
EXERCÍCIO 19: 
 
//Faça a leitura do salário atual e do tempo de serviço de um 
funcionário. A seguir, calcule o seu salário reajustado. Funcionários 
com até 1 ano de empresa, receberão aumento de 10%. Funcionários com 
mais de um ano de tempo de serviço, receberão aumento de 20%. 
 
principal 
{ 
//Declaração de variáveis: todos são número reais. 
real SALARIO, TEMPO, NOVO; 
 
//Leitura do salário 
imprima (“Informe o salário:”); 
leia (SALARIO); 
 
//Leitura do Tempo de serviço 
imprima (“Informe o tempo de servico em anos:”); 
leia (TEMPO); 
 
// 1ª parte do se 
// se o tempo é de até um ano, o reajuste é 10%, ou seja, o novo 
salario é 110% do antigo, ou seja, é o salário antigo 
multiplicado por 1.1; 
// 2ª parte do se 
// reajuste de 20%, novo salário é 120%, salário antigo 
multiplicado por 1.2. 
se (TEMPO ≤ 1)entao 
{ 
NOVO ← SALARIO * 1.1; 
imprima (“O novo salario e: “, NOVO); 
} 
senão 
{ 
NOVO ← SALARIO * 1.2; 
imprima (“O novo salario e: “, NOVO); 
} 
} 
 
 
EXERCÍCIO 20: 
 
//Leitura: Ano atual, ano de nascimento 
//Exibir: sua idade e classificação 
//-> 0 a 3 anos: Bebê 
//-> 4 a 10 anos: Criança 
//-> 11 a 18 anos: Adolescente 
//-> 19 a 50 anos: Adulta 
//-> 51 ou mais: Idoso 
 
principal 
 
{ 
 
//Declaração de Variáveis (dois anos e uma idade inteiros) 
 
inteiro ano_atual,ano_nasc,idade; 
 
//Leitura de ambos 
 
imprima("Informe o ano atual: "); 
 
leia(ano_atual); 
 
imprima("Informe o ano de nascimento: "); 
 
leia(ano_nasc); 
 
//Cálculo da idade 
 
idade ← ano_atual - ano_nasc; 
 
//Exibir idade 
 
imprima("Sua idade é:",idade); 
 
//Exibir Classificação 
 
se(idade<0)entao 
{ 
imprima("Idade Inválida"); //não existe idade negativa 
} 
senao 
{ 
se((0<=idade) E (idade<=3))entao 
{ 
imprima("Bebê"); //comparei como >=0 e <=3 
} 
senao 
{ 
se((4<=idade) E (idade<=10))entao 
{ 
imprima("Criança"); //comparei como >=4 e <=10 
} 
senao 
{ 
se((10<idade) E (idade<19))entao 
{ 
imprima("Adolescente"); 
 //comparei como >10 e <19, que é 11 a 18 
} 
senao 
{ 
se((18<idade) E (idade<51))entao 
{ 
imprima("Adulto "); //19 a 50 
} 
senao 
{ 
imprima("Idoso "); 
//o quê restou foi 51 ou mais 
} 
} 
} 
} 
} 
} 
 
EXERCÍCIO 21: 
 
//Informar o número do mês do ano e mostrar o nome do mês 
por extenso. 
//Caso o número do mês não exista, exibir a mensagem "Mês 
inválido". 
 
principal 
{ 
//declaração da variável mes que será de 1 a 12 
inteiro mes; 
 
//leitura do numero do mes 
imprima ("Informe o numero do mes: "); 
leia (mes); 
 
 
 
//comando escolha com 12 casos + senão 
//de 1 a 12, irá imprimir o mes correspondente 
//o senão informa que o numero é inválido, ou seja, 
//se não estar em [1,12], é inválido 
 
escolha (mes) 
{ 
caso 1: imprima 
("Janeiro"); caso 2: 
imprima ("Fevereiro"); 
caso 3: imprima 
("Marco"); 
caso 4: 
imprima("Abril"); 
caso 5: imprima 
("Maio"); 
caso 6: imprima 
("Junho"); caso 7: 
imprima ("Julho"); 
caso 8: imprima 
("Agosto"); 
caso 9: imprima 
("Setembro"); 
caso 10: imprima 
("Outubro"); 
caso 11: 
imprima("Novembro"); 
caso 12: 
imprima("Dezembro"); 
senão: imprima ("Mes 
Invalido"); 
} 
} 
 
 
EXERCÍCIO 22: 
 
//Faça um algoritmo que receba o valor do salário de uma pessoa e o 
valor de um financiamento pretendido. Caso o financiamento seja menor 
ou igual a 5 vezes o salário da pessoa, o algoritmo deverá escrever 
"Financiamento Concedido"; senão, ele deverá escrever "Financiamento 
Negado". 
 
principal 
{ 
//Declaração das variáveis 
real SALÁRIO, FINANC; 
real RAZÃO; //razão entre financiamento e salário 
 
//Leitura do salário e financiamento 
imprima(“Digite o salário e o valor do financiamento: ”); 
leia(SALÁRIO, FINANC); 
 
//Cálculo da razão “financiamento/salário 
RAZÃO ← FINANC / SALÁRIO; 
 
se(RAZÃO > 5)entao 
//Se razão > 5... 
{ 
//O financiamento será negado 
imprima(“Financiamento Negado”); 
} 
senão 
//Senão... 
{ 
//O financiamento será concedido 
imprima(“Financiamento Concedido”); 
} 
 
} 
 
 
EXERCÍCIO 23: 
 
//Calcular e mostrar o salário semanal de uma pessoa: 
//-> número de horas trabalhadas < 40, a pessoa recebe R$15,00 por 
hora 
//-> senão recebe R$600,00 + R$21,00 para cada hora a mais de 40 horas 
//Leia o número de horas trabalhadas e informe o salário. 
 
principal 
{ 
//Declaração de variáveis: horas é um numero inteiro e o salário 
é real. 
inteiro HORAS; 
real SALARIO; 
 
//Leitura da quantidade de horas. 
imprima (“Informe o numero de horas trabalhadas:”); 
leia (HORAS); 
 
//Cálculo do Salário 
se (HORAS<40) 
//Se o número de horas é menor que 40, o salario é R$15.00 por 
hora. 
{ 
salario ← HORAS * 15; 
} 
 
//Caso contrário, o salário será 600 + R$21.00 por hora excedente 
senão 
{ 
SALARIO ← 600 + 21 * (HORAS - 40); // hora excedente = HORAS 
- 40. 
} 
//Impressao 
imprima ("O salário semanal desta pessoa é:", SALARIO); 
} 
 
 
 
EXERCÍCIO 24: 
 
//A taxa de juro depende do tempo. Num banco: 
 
//1) 5 anos =< tempo ---> 0.95 
//2) 4 anos =< tempo < 5 anos ---> 0.9 
//3)3 anos =< tempo < 4 anos ---> 0.85 
//4) 2 anos =< tempo < 3 anos ---> 0.75 
//5) 1 ano =< tempo < 2 anos ---> 0.65 
//6) tempo < 1 ano ---> 0.55 
 
//Receba o tempo em que os fundos foram mantidos em depósito e informe 
a taxa de 
//juros correspondente. 
 
principal 
{ 
 
// Declaração de Variáveis: 
// Perceba que é complicado fornecer frações de anos. É mais 
fácil informar o 
// tempo em meses. A partir daí, dividimos por 12 e sabemos a 
fração de ano 
// correspondente. 
// Por isso, duas variáveis: meses (inteiro) e anos (real). 
 
inteiro MESES; 
real ANOS; 
 
imprima("Informe o tempo(meses) em que os fundos foram mantidos 
em deposito:"); 
leia(MESES); 
ANOS <- MESES/12; // Cálculo da fração de ano correspondente 
 
// Impressão dos valores correspondentes 
// Esta é outra maneira de encadear SE's. Repare que no último 
SENÃO, ainda 
// colocamos uma condição SE. Se não o tivéssemos feito, anos 
negativos 
// poderiam ser considerados 
 
se(ANOS>=5)entao 
imprima("Taxa de juros de 0,55"); 
senão 
se(ANOS < 5 E ANOS>=4) entao 
imprima("Taxa de juros de 0,65"); 
senão 
se(ANOS < 4 E ANOS>=3) entao 
imprima("Taxa de juros de 0,75"); 
senão 
se(ANOS < 3 E ANOS>=2) então 
imprima("Taxa de juros de 0,85"); 
senão 
 se(ANOS < 2 E ANOS>=1) então 
imprima("Taxa de juros de 
0,9"); 
senão 
se(ANOS < 1 E ANOS>=0) 
imprima("Taxa de juros 
de 0,95"); 
} 
 
 
EXERCÍCIO 25: 
 
/*Classifica-se a classe de peso e taxa de registro de um carro pelo 
seu ano e peso. 
1) Ano <= 1970: 
a) peso < 1200 ---> Classe 1 / Taxa de 16.50 
b) 1200 =< peso <= 1700 ---> Classe 2 / Taxa de 25.50 
c) 1700 < peso ---> Classe 3 / Taxa de 46.50 
2) 1971 <= Ano <= 1979: 
a) peso < 1200 ---> Classe 4 / Taxa de 27.00 
b) 1200 =< peso <= 1700 ---> Classe 5 / Taxa de 30.50 
c) 1700 < peso ---> Classe 6 / Taxa de 52.50 
3) Ano >= 1980: 
a) peso < 3600 ---> Classe 7 / Taxa de 19.50 
b) 3600 <= peso ---> Classe 8 / Taxa de 52.50 
Programa recebe peso e ano -> informa classe e taxa*/ 
 
principal 
{ 
inteiro ANO; //Declaração de variável inteira 
real PESO; //Declaração de variável real 
 
//Leitura do ano do carro 
imprima(“Informe o ano do carro: ”); 
leia(ANO); 
 
//Leitura do peso do carro 
imprima(“Informe o peso do carro: ”); 
leia(PESO); 
 
//1º caso 
se(ANO < 1970)entao 
{ 
se(PESO < 1200)entao 
 imprima(“Classe: 1 Taxa de Registro: R$ 16,50”); 
senão 
{ 
se(PESO > 1200 E PESO < 1700)entao 
imprima(“Classe: 2 Taxa de Registro: R$ 25,50”); 
senão 
//senão > 1700 (situação que restou) 
imprima(“Classe: 3 Taxa de Registro: R$ 46,50”); 
} 
 
} 
senão 
{ 
se(ano > 1970 e ano < 1980)entao 
{ 
se(PESO < 1200)entao 
imprima(“Classe: 4 Taxa de Registro: R$ 27,00”); 
senão 
{ 
se(PESO > 1200 E PESO < 1700)entao 
imprima(“Classe: 5 Taxa de Registro: R$ 
30,50”); 
senão 
imprima(“Classe: 6 Taxa de Registro: R$ 
52,50”); 
} 
} 
senão //este “senão” é relativo ao ano restante ( > 1980) 
{ 
se(peso < 3600)entao 
imprima(“Classe: 7 Taxa de Registro: R$19,50”); 
senão 
imprima(“Classe: 8 Taxa de Registro: R$52,50”); 
} 
} 
} 
 
 
EXERCÍCIO 26: 
 
//Ler as informações de um aluno: 
//-> notas em 2 provas (entre 0 e 10) 
//-> nota de um trabalho (entre 0 e 10) 
//-> sua frequência (número de ausências) 
//Condições: 
//-> reprovado se faltou mais de 15 aulas 
//-> aprovado se não for reprovado por falta e média >= 6,0 
//-> Prova final se média < 6,0 
//Média: 
//-> peso 3 para a 1ª prova 
//-> peso 5 para a 2ª prova 
//-> peso 2 para o trabalho 
 
principal 
{ 
//Declaração de Variáveis: 
// P1, P2: notas das provas 
// TRAB: nota do trabalho 
// MEDIA: média final do aluno: 3*p1 + 5*p2 + 2*TRAB 
// Essa soma dividida por 10 é a média 
// FREQ: total de ausências 
real P1, P2, TRAB, MEDIA; 
inteiro FREQ; 
 
//Leitura dos Dados 
imprima("Informe a nota da 1ª prova: "); 
leia(P1); 
imprima("Informe a nota da 2ª prova: "); 
leia(P2); 
imprima("Informe a nota do trabalho "); 
leia(TRAB); 
imprima("Informe a freqüência /total de ausências/:"); 
leia(FREQ); 
 
//Cálculo da Média 
MEDIA <- (3 * P1 + 5 * P2 + 2 * TRAB)/10; 
 
//1º Teste: freqüência 
se(FREQ>15)entao 
imprima("Reprovado"); 
 
senão//não foi reprovado por freqüência. Agora é a média que 
qualifica 
{ 
se (MEDIA>=6)entao 
imprima("Aprovado"); 
senão 
imprima("Reprovado"); 
} 
 
} 
 
 
EXERCÍCIO 27: 
 
//Leia um código e apresente o cargo correspondente 
//Se não existir o código, diga "código inválido" 
 
//Código Cargo 
//101 - Vendedor 
//102 - Atendente 
//103 - Auxiliar Técnico 
//104 - Assistente 
//105 - Coordenador de Grupo 
//106 - Gerente 
 
principal 
{ 
//Declaração de variáveis 
inteiro CODIGO; 
 
//Leitura do Código 
imprima ("Digite o código do cargo do funcionário: "); 
leia (CODIGO); 
 
//Múltipla escolha 
escolha (CODIGO) 
{ 
//Se a variável for igual a 101 
caso 101: imprima ("Cargo: Vendedor"); 
 
//Se a variável for igual a 102 – e assim por diante. 
caso 102: imprima ("Cargo: Atendente"); 
 
caso 103: imprima ("Cargo: Auxiliar Técnico"); 
 
caso 104: imprima ("Cargo: Assistente"); 
 
caso 105: imprima ("Cargo: Coordenador de Grupo"); 
 
caso 106: imprima ("Cargo: Gerente"); 
 
// Caso a variável não assuma os valores acima, o senão é 
executado. 
senão: imprima ("Código Inválido."); 
 
} 
 
} 
 
EXERCÍCIO 28: 
 
//Código de 1 a 4, que indica o tipo seguinte: 
//Código Tipo da unidade 
//1 CD-ROM (700MB) 
//2 DVD-ROM (4.7GB) 
//3 DVD-9 (8.54 GB) 
//4 Blu-Ray (25 GB) 
//Receba o código e informe o tipo correto de unidade de disco. 
 
principal 
{ 
inteiro CODIGO; // variável CODIGO que será usado na múltipla 
escolha 
 
//Leitura do Código 
imprima ("Informe o código: "); 
leia (CODIGO); 
 
//múltipla escolha entre 4 casos específicos e um senão 
escolha (CÓDIGO) 
{ 
caso 1: imprima ("CD-ROM (700MB)"); 
caso 2: imprima ("DVD-ROM (4.7GB)"); 
caso 3: imprima ("DVD-9 (8.54 GB)"); 
caso 4: imprima ("Blu-Ray (25 GB)"); 
senão: imprima ("Código Inválido"); // caso Codigo difente 1,2,3,4 
} 
} 
 
 
 
EXERCÍCIO 29: 
 
/*Escreva um programa que receba dois números reais e um código de 
seleção do usuário. Se o código digitado for 1, faça o programa 
adicionar os dois números previamente digitados e mostrar o resultado; 
se o código de seleção for 2, os números devem ser multiplicados; se o 
código de seleção for 3, o primeiro número deve ser dividido pelo 
segundo. Se nenhuma das opções acima for escolhida, mostrar "Código 
inválido".*/ 
 
principal 
{ 
//declaração dos dois números reais e resultado da operação 
realizada 
real A,B,RESULT; 
 
//declaração do código de seleção 
inteiro COD; 
 
//leitura dos dois números 
imprima ("Insira dois números reais : "); 
leia (A,B); 
 
//leitura do código 
imprima ("Insira o código: "); 
leia (COD); 
 
//Opções 
disponíveis: 
// COD = 1 : somar 
// COD = 2 : multiplicar 
// COD = 3 : dividir 
// outro COD = inválido 
 
escolha (COD) 
{ 
caso 1: 
{ 
RESULT ← A + B; 
imprima ("A soma é: ",RESULT); 
} 
caso 2: 
{ 
RESULT ← A * B; 
imprima ("O produto é: ",RESULT); 
} 
caso 3: 
{ 
se(b != 0) então 
 { 
RESULT ← A div B; 
 imprima ("O quociente é: ",RESULT); 
} 
 senão 
 imprima ("impossível realizar divisão”); 
 } 
senão : imprima ("Código Inválido"); 
} 
} 
 
 
 
EXERCÍCIO 30: 
 
//Transforma a nota de um aluno em conceito. As notas 
//10 e 9 receberão conceito A, as notas 8 e 7 receberão conceito B, as 
notas 6 
//e 5 receberão conceito C e abaixo de 5 conceito D. 
 
principal 
{ 
//declaração de variáveis 
inteiro NOTA; 
 
//leitura da nota do aluno 
imprima ("Informe o valor da nota "); 
leia (NOTA); 
 
//compara a nota e atribui o conceito correspondente 
se ((NOTA<0) OU (NOTA>10))entao 
imprima ("Nota inválida"); 
senão 
se ((NOTA = 9) OU (NOTA= 10))entao 
imprima ("Conceito A"); 
senão 
se ((NOTA = 8) OU (NOTA = 7))entao 
imprima ("Conceito B"); 
senão 
se ((NOTA = 6) OU (NOTA = 5))entao 
imprima ("Conceito 
C"); 
senão 
imprima ("Conceito 
D"); 
} 
 
 
 
EXERCÍCIO 31: 
 
//Dados 2 valores inteiros positivos entre 1 e 10 
//se soma < 8, informe média 
//se soma = 8, informe produto 
//se soma > 8, informe quociente do maior pelo menor 
 
principal 
{ 
//declaração de variáveis 
inteiro n1, n2, soma, produto, aux; 
real media, quociente; 
//leitura 
faça 
{ 
imprima("Digite dois inteiros entre 1 e 10: "); 
leia (n1,n2); 
//n1,n2 entre [1,10] 
}enquanto((n1<1) OU (n1>10) OU (n2<1) OU (n2>10)); 
 
 
//calcula a soma 
soma ← n1+n2; 
//se soma<8 
se (soma<8)entao 
{ 
media ← (n1+n2)/2; 
imprima("A média é",media); 
} 
 
senão 
{ 
se(soma=8) entao 
{ 
produto ← n1*n2; 
imprima("O produto é ", produto); 
} 
 
senão 
{ 
se (n1<n2)entao 
{ 
aux ← n1; 
n1 ← n2; 
n2 ← aux; 
} 
quociente ← n1/n2; 
imprima("O quociente é ",quociente); 
} 
} 
} 
 
 
EXERCÍCIO 32: 
 
//Escrever um algoritmo que lê 10 valores e conte quantos destes 
valores são 
//negativos, escrevendo esta informação. 
 
principal 
{ 
 
// Declaração de Variáveis 
// numero: numero digitado, que é real 
// i: variável que será usado no para-faça como variável de controle 
// cont: contador de números negativos. Começa com 0, pois não 
// existe nenhum negativo inicialmente 
 
real numero; 
inteiro i, cont; 
cont ← 0; 
para(i ← 1;i < 10; i ← i + 1) faça 
 // i começa com 1 e vai até 10 aumentando de 1 em 1 
 // Ou seja, iremos realizar os comandos abaixo 10X, para 10 
números 
 
{ 
//Leitura do numero (ocorrerá 10X) 
imprima(“Digite o ", i, “º numero: ”); 
leia(numero); 
se (numero < 0)entao 
cont ← cont + 1; //se o numero lido for negativo, 
cont recebe +1 
// aqui o i recebe +1. Se ele continuar < 10, repete mais 
uma vez. 
// Se não, sai do para-faça 
} 
//ao chegar aqui, cont terá recebido a quantidade de negativos entre 
os 10 numeros 
 
//Impressão da quantidade 
imprima("A quantidade de numeros negativos são ",cont); 
} 
 
EXERCÍCIO 33: 
 
//Escreva um algoritmo que leia 20 valores e encontre o maior e o 
menor 
//deles. Mostre o resultado. 
 
principal 
{ 
//Declaração das Variáveis 
//maior: armazenará o maior valor 
//menor: armazenará o menor valor 
//cont: contador que limitará o programa (vale 1 a 20) 
//valor: valor lido 
 
inteiro maior, menor, valor, cont; 
cont  1; 
 
//Leitura do 1º Valor 
imprima("Digite o valor 1: "); 
leia(valor); //armazena na 
variável valor 
 
maiorvalor; //inicializa maior com o primeiro valor digitado 
menorvalor; //inicializa menor com o primeiro valor digitado 
//Perceba que o 1º valor digitado é o maior e o menor até agora 
 
contcont + 1; //incrementa contador. 
 
faça //faça uma vez primeiro... 
{ 
//Leitura dos novos valores 
imprima("Digite o valor",cont); 
leia(valor); 
 
//Vamos comparar com a variável maior 
//que armazena o maior valor até aqui 
 
se(valor > maior)entao //se o valor é maior que o maior valor, 
então 
maiorvalor; //a variável maior armazena o novo valor 
se(valor < menor) entao//de forma análoga para o menor 
menorvalor; 
 
contcont + 1;//Vamos ler o próximo numero 
 
//... e continuaremos repetindo tudo até que cont ultrapasse 20 
}enquanto(cont ≤ 20); 
 
//Poderíamos ter usado somente enquanto aqui. 
//Seria enquanto(cont ≤ 20){...} 
 
imprima("Maior: ",maior, "Menor: ", menor); //impressão dos valores 
finais 
} 
 
 
EXERCÍCIO 34: 
 
//Faça um algoritmo que lê um valor N inteiro e positivo e que calcula 
e 
//escreve o fatorial de N (N!). 
//Lembre-se: Não existe fatorial de número negativo e o exercício não 
permite de zero 
 
principal 
{ 
// Declaração de Variáveis 
// N foi iniciado com 0 para que entre no 1º enquanto 
// res é o resultado. Ele receberá ele mesmo multiplicado pela 
próxima 
// parcela do fatorial. Para não modificar o produto final, ele 
// deve ser neutro. Logo, começa com 1 que é o fator neutro da 
// multiplicação. 
 
inteiro 
N, res; N 
← 0; 
res ← 1; 
 
//Comando Enquanto: 
//enquanto N≤0, vai ficar solicitando um numero positivo 
//irá fazer a verificação se este N é > 0. Aí vai parar. 
 
enquanto(N≤0) 
{ 
imprima("Informe N: "); 
leia(N); 
} 
 
//Imprimir a mensagem abaixo 
imprima("O fatorial de ",N, " é: "); 
 
//Código (explicação no final): 
enquanto(N≥1) 
{ 
res ← res * N; 
se(N≠1)entao 
imprima(N); 
senão 
imprima(
N); 
N ← N - 1; 
 } 
 imprima(res); 
} 
 
// Código: 
// 1) Vamos imprimir cada componente do fatorial e um sinal 
// 2) o fatorial será calculado pegando N * (N-1) * (N-2) * ... * 1 
= res 
 
 
EXERCÍCIO 35: 
 
/*A prefeitura de uma cidade fez uma pesquisa entre seus habitantes, 
coletando dados sobre o salário e número de filhos. A prefeitura 
deseja saber: 
a) média do salário da população; 
b) média do número de filhos; 
c) maior salário; 
d) percentual de pessoas com salário até R$100,00; 
O final da leitura de dados se dará com a entrada de um salário 
negativo.*/ 
 
principal 
{ 
 
/*Declaração de Variáveis: 
filhos: quantidade de filhos 
salario: recebe o salario informado pelo usuario 
contp: contador de população -> cada novo salario é mais um na 
população 
mediaF: média de filhos. Primeiramente somaremos todos os filhos 
aqui. 
Depois, dividiremos este valor pela população (contp) armazenando 
nesta mesma variável mediaF 
mediaS: média de salário. Análogo à mediaF. 
maior: maior salário. Inicialmente será 0. Não existe salário 
negativo, logo 
o menor possível é zero. 
perc: percentual de pessoas com salario < 100. Será uma espécie 
de contador 
primeiramente. Depois usaremos regra de três. Assim, 
perc=(perc*100)/contp*/ 
 
inteiro filhos, contp; 
real salario, mediaF, mediaS, maior, perc; 
 
contp0; 
mediaF0; 
mediaS0; 
maior0; 
perc0; 
 
//Leitura do 1º salário 
imprima("Informe o salário: "); 
leia(salario); 
enquanto (salario > 0)faça 
{ 
contp ← contp + 1; 
mediaS ← mediaS + salario; 
//se o salario é maior que o maior anteriormente registrado, 
maior recebe ele 
se (salario > maior) entao 
{ 
maior ← salario; 
} 
//Ver se enquadra na parte menor de 100 
se(salário < 100)entao 
{ 
perc ← perc + 1; 
} 
//Leitura do numero de filhos 
imprima("Numero de Filhos: "); 
leia(filhos); 
 
//somaremos os filhos aqui (mediaF = mediaF + filhos) 
mediaF ← mediaF + filhos; 
 
//Leitura do 1º salário 
imprima("Informe o salário: "); 
leia(salario); 
} 
//aqui já temos todos os salários registrados 
 
//Cálculo da média do salário da população 
mediaS ← mediaS/contp; 
 
//Cálculo da média do número de filhos 
mediaF ← mediaF/contp; 
 
 
//percentual de pessoas com salário até R$100,00 
perc ← (perc*100)/contp; 
 
//Impresssão de Informações 
//contp pode ser 0 se o 1º salario for negativo. Logo não tem que 
informar nada 
se (contp ≠ 0)entao 
{ 
imprima("Média de Salário: ",mediaS); 
imprima("Média de Filhos: ",mediaF); 
imprima("Maior salário: ",maior); 
imprima("Percentual de pessoas com salário até 100: ", 
perc); 
} 
 
} 
 
 
EXERCÍCIO 36: 
 
//Chico tem 1,50 metro e cresce 2 centímetros por ano, enquanto Zé tem 
1,30 
 
//metro e cresce 3 centímetros por ano. Construa um algoritmo que 
calcule e 
 
//imprima quantos anos serão necessários para que Zé seja maior que 
Chico. 
 
 
 
principal 
{ 
 
//declaração de variáveis 
 
inteiro anos←0; //quantidade de anos que se passam até zé ficar 
maior 
 
real chico←1.5,ze ←1.3; //altura de cada um 
 
enquanto(chico >=ze) //enquanto chico maior que ze, ambos aumentam 
e passa 1 ano por loop 
 
{ 
 
chico←chico+0.02; //chico cresce 0.02 
 
zé ← zé + 0.03; //ze cresce 0.03 -> Repare que ze+=0.03; é a mesma 
coisa que ze=ze+0.03; 
 
anos ← anos + 1;//passou 1 ano 
 
} 
// só saiu do enquanto quando ze ficou maior. 
anos irá valer a quantidade de anos necessários 
para isso 
 
 
imprima("Anos:",anos); //imprime-se a quantidade de anos 
 
} 
 
 
EXERCÍCIO 37: 
 
//Construir um algoritmo que calcule a média aritmética de vários 
valores 
//inteiros positivos, lidos externamente. O final da leitura 
acontecerá quando 
//for lido um valor negativo. 
 
principal 
{ 
 
//declaração de variáveis 
//NUM: numero digitado 
//CONT: quantos numeros foram (inicialmente é zero) 
//SOMA: a soma de todos (inicialmente é zero) 
 
inteiro NUM, CONT,SOMA; 
real MEDIA; 
CONT <- 0; 
SOMA <- 0; 
 
//Iremos ler o 1º numero e ficar repetindo enquanto NUM>= 0 
//(quando NUM<0, interrompe) 
faça{ 
imprima("Informe um numero inteiro e positivo: "); 
leia(NUM); //leitura de NUM 
 
se(NUM > = 0){ 
SOMA <- SOMA + NUM; 
CONT<-CONT +1; 
} 
 
//iremos ficar repetindo até que NUM torne-se negativo 
}enquanto (NUM >= 0); 
 
//Agora, n foi negativo. 
//Já somamos todos os anteriores e contamos quantos foram 
 
se(CONT > 0) 
//se cont for igual a 0, quer dizer que não houve numero nenhum. 
//O negativo foi o 1º 
{ 
MEDIA<- SOMA/CONT; 
imprima("A media aritmética é:”,MEDIA); 
} 
} 
 
 
EXERCÍCIO 38: 
 
 
//- 1,2,3,4 = voto para os respectivos candidatos; 
//- 5 = voto nulo; 
//- 6 = voto em branco; 
//Leia o código, calcule e escreva as seguintes informações: 
//- total de votos para cada candidato; 
//- total de votos nulos; 
//- total de votos em branco; 
//Como finalizador do conjunto de votos, utilize o valor 0. 
 
principal 
{ 
//Declaraçãode Variáveis 
// CODIGO: código de votação 
// C1,C2,C3,C4,NULO,BRANCO: contadores para os candidatos 1,2,3 e 
4 e para nulo e branco 
inteiro CODIGO,C1,C2,C3,C4,NULO,BRANCO; 
 
C1 <- 0; 
C2 <- 0; 
C3 <- 0; 
C4 <- 0; 
NULO <- 0; 
BRANCO <- 0; 
 
//Leitura do código 
imprima ("Informe o código: "); 
leia (CODIGO); 
 
//se CODIGO é diferente de zero, faça: 
enquanto (CODIGO != 0)faça 
{ 
escolha (CODIGO) //múltipla escolha 
{ 
caso 1: C1 <- C1 + 1; //+1 voto para o 1 
caso 2: C2 <- C2 + 1; //+1 voto para o 2 
caso 3: C3 <- C3 + 1; //+1 voto para o 3 
caso 4: C4 <- C4 + 1; //+1 voto para o 4 
caso 5: NULO <- NULO + 1; //+1 voto nulo 
caso 6: BRANCO <- BRANCO + 1; //+1 voto branco 
senão: imprima (" Código Inválido "); //códigos negativos e 
maiores que 6 
 
} 
//Leitura do código 
imprima ("Informe o código: "); 
leia (CODIGO); 
 
} 
//impressão 
imprima ("Total de votos para o candidato 1: 
",C1); imprima ("Total de votos para o 
candidato 2: ",C2); imprima ("Total de votos 
para o candidato 3: ",C3); imprima ("Total de 
votos para o candidato 4: ",C4); imprima 
("Total de votos nulos: ",NULO); 
imprima ("Total de votos brancos: 
",BRANCO); 
} 
 
 
EXERCÍCIO 39: 
 
//Escrever um algoritmo que leia uma variável n e calcule a tabuada de 
1 até n. 
//Mostre a tabuada na forma: 
//1 x n = n 
//2 x n = 2n 
//3 x n = 3n 
//............... 
//n x n = n2 
 
principal 
{ 
//declaração de variáveis (N é o número e I é usado no 
para...faça) 
inteiro N, I; 
 
//leitura do n 
imprima("Informe 
n"); 
leia(N); 
 
// PARA..FAÇA: iremos imprimir n linhas. 
// Repare que o 1º número começa em 1 e vai até n (1<=i<=n) 
// Então usaremos I pra "correr" de 1 a N 
// O 2º número é sempre o N 
// O 3º número é I*N (multiplicação) 
// IMPRIMA: 3 números inteiros impressos: I, N e o resultado I*N 
 
para(I = 1; I < N; I ++) faça 
imprima( i, "X", n, "=", 
i*n); 
} 
 
 
 
EXERCÍCIO 40: 
 
// Lê os valores n1 e n2 e imprime o intervalo fechado entre esses 
dois valores. */ 
 
principal 
 
{ 
 
//declaração de variaveis 
 
inteiro n1, n2, aux; 
 
//leitura dos inteiros 
 
imprima("Digite dois valores inteiros"); 
 
leia (n1,n2); 
 
//compara n1 e n2 e atribui o menor valor à variavel n1 
 
se (n1>n2)entao 
 
{ 
 
aux←n2; 
n2←n1; 
n1←aux; 
} 
 
imprima ("Intervalo fechado entre", n1, n2); 
 
// A cada loop o valor de n1 aumenta uma unidade e é impresso. 
 
//Quando n1 for maior que n2 sai do loop e realiza o proximo comando 
 
enquanto (n1<=n2) 
 
{ 
 
imprima (n1); 
 
n1++; //n1=n1+1; 
 
} 
 
} 
EXERCÍCIO 41: 
 
//Escrever um algoritmo que leia um número n que indica quantos 
valores 
//devem ser lidos a seguir. Para cada número lido, mostre uma tabela 
//(1 linha e duas colunas) contendo o valor lido e o fatorial deste 
valor. 
//(Ver questão 34) 
 
principal 
{ 
// Declaração de Variáveis 
// n: quantidade de valores a calcular o fatorial 
// numero: numero a ser fatorado 
// result: é o resultado. Ele receberá ele mesmo multiplicado 
pela próxima parcela do fatorial. Para não modificar o produto 
final, ele deve ser neutro. Logo, começa com 1 que é o fator 
neutro da multiplicação. result será modificado constantemente 
para cada numero 
// fator: é a parcela que irei multiplicar com o resultado 
anterior até que o 
// fatorial esteja calculado. Começará com 1 e irá até numero 
// repetir: número de repetições do cálculo do fatorial. Começa 
com 1 e vai até n 
 
inteiro n, result, fator, numero, repetir; 
 
repetir  1; 
 
//Leitura da qtd de valores 
imprima ("Quantidade de Valores: "); 
leia (n); 
 
faça { //faça uma vez... 
 
//"resetando" o resultado e a fator para cada numero 
 
Result ← 0; 
 
//Leia o numero a ser fatorado 
imprima ("Valor: "); 
leia (numero); 
 
se (numero = 0 ou numero = 1) //fatoriais de 0 e 1 é 1 
{ 
Result ← 1; //resultado direto 
} 
senão //caso seja 2 pra frente... 
{ 
enquanto (fator < numero) faça 
{ 
 
//...result ← result * fator até fator igual numero 
 
result ← result * fator; 
fator ← fator + 1; 
} 
} 
 
imprima (“Numero: ”, numero ,“Fatorial: ”,fator); 
repetir ← repetir + 1; 
}enquanto (repetir < n); 
//chegando aqui, todos os n valores tiveram seu fatorial calculado e impresso 
} 
 
 
 
EXERCÍCIO 42: 
 
//Escrever um algoritmo que leia um número não determinado de valores e 
//calcule a média aritmética dos valores lidos, a quantidade de valores 
//positivos, a quantidade de valores negativos e o percentual de valores 
//negativos e positivos. Mostre os resultados. 
//ATENÇÃO: o enunciado não deixa claro mas será usado o valor 0 para 
//simbolizar o fim da entrada de dados 
 
principal 
{ 
// Declaração de Variáveis 
// NUM: numero inteiro lido 
// CONT: quantidade total de números lidos (inteiro) 
// MEDIA: no 1º momento, será a soma de todos os números 
// no 2º momento, MEDIA <- MEDIA div CONT. 
// Assim, media será a média aritmética dos números (soma/qtd) 
// C1 e C2: no 1º momento, eles se comportarão como inteiros. 
// Eles serão os contadores de números positivos e 
// negativos respectivamente. 
// no 2º momento, C1 <- (C1*100) div CONT, ou seja, 
// C1 será o PERCENTUAL de valores positivos em (CONT) 
// números lidos. Aqui ele será real. Por isso, foi declarado como 
real 
 
inteiro NUM,CONT; 
real MEDIA,C1,C2; 
 
CONT <- 0; MEDIA <- 0; 
C1 <- 0; 
C2 <- 0; 
imprima ("Digite um numero: "); 
leia (NUM); 
 
enquanto (NUM !=0) faça 
{ 
MEDIA <- MEDIA + NUM; 
 
CONT <- CONT + 1; 
 
se (NUM>0) 
{ 
C1 <- C1 + 1; 
 
} 
senão C2 <- C2 + 1; 
 
 imprima ("Digite um numero: "); 
 leia (NUM); 
 
} 
 
 
//Cálculo media 
MEDIA <- MEDIA div CONT; 
 
//impressão 
imprima ("Média Aritmética: ",MEDIA); 
 imprima ("Quantidade de Valores Positivos: ",C1); 
imprima ("Quantidade de Valores Negativos: ",C2); 
 
C1 <- (C1*100) div CONT; C2 <- 
(C2*100) div CONT; 
 
imprima ("Percentual de Valores Positivos: ",C1); 
imprima ("Percentual de Valores Negativos: ",C2); 
} 
 
 
EXERCÍCIO 43: 
 
/*Escrever um algoritmo que leia uma quantidade desconhecida de números e conte 
quantos deles estão nos seguintes intervalos: [0,25], [26,50], [51,75] e [76,100] . 
A entrada de dados deve terminar quando forlido um número negativo.*/ 
 
principal 
{ 
 
//Declaração de Variáveis 
// numero: numero lido 
// c1,c2,c3,c4: contadores de cada intervalo 
 
inteiro numero, c1, c2, c3, c4; 
numero ← 1; 
c1← 0; 
c2← 0; 
c3← 0; 
c4← 0; 
 
enquanto (numero > 0) faça{ //... enquanto numero > 0 
 
//Leia o numero imprima("Numero: 
"); leia(numero); 
 
se (numero > 0 E numero < 25)entao { 
c1 ← c1 + 1; 
}//intervalo 1 
senao { 
se (numero > 26 E numero < 50) entao { 
c2 ← c2 + 1; //intervalo 2 
} senão { 
se (numero > 51 E numero < 75) entao { 
c3 ← c3 + 1; //intervalo 3 
} senão { 
se (numero > 76 E numero < 100) entao { 
c4 ← c4 + 1; //intervalo 4 
} 
} 
} 
} 
 
} 
//Impressão dos resultados 
imprima("No intervalo [0,25] tem “, c1, “ numeros lidos"); 
imprima("No intervalo [26,50] tem “, c2, “ numeros lidos"); 
imprima("No intervalo [51,75] tem “, c3, “ numeros lidos"); 
imprima("No intervalo [76,100] tem “, c4, “ numeros lidos"); 
} 
 
 
EXERCÍCIO 44: 
 
/*Faça um algoritmo que leia uma quantidade não determinada de números 
positivos. Calcule a quantidade de números pares e ímpares, a média de valores 
pares e a média geral dos números lidos. O número que encerrará a leitura será 
zero.*/ 
 
principal 
{ 
//Declaração de variáveis 
// n: numero 
// contp: contador de pares 
// conti: contador de ímpares 
// somap: soma dos pares 
// somat: soma total 
//As médias serão a soma dividido pelos contadores, que podem ser real 
// mediap: média dos pares 
// mediat: média total (Observe que a quantidade total é contp + conti) 
 
inteiro n, contp, conti, somap, somat; 
real mediap, mediat; 
 
contp←0; conti←0; 
somap←0; somat←0; 
 
imprima ("Informe n positivo: "); 
leia (n); //leitura do 1º n 
 
enquanto (n>0) faça //Se n for positivo realiza-se as contas 
{ 
somat←somat + n; //some o n na soma total 
 
se (n mod 2 = 0)entao //se n for par 
{ 
contp←contp + 1; 
//iremos acrescentar +1 no contador de pares 
somap←somap+n; //iremos somar o n par ao somap 
} 
 
senão conti←conti + 1; 
//se n for ímpar, somente some +1 no conti 
imprima ("Informe n positivo: "); 
leia (n); //leitura do 1º n 
 
} 
 
 
 
//Cálculo médias 
Mediap  somap / contp; 
mediat  somat / (contp + conti); 
 
//Impressão 
imprima ("Quantidade de Pares: ",contp); 
imprima ("Quantidade de Ímpares: ",conti); 
imprima ("Média dos Pares: ",mediap); 
imprima ("Média Total: ",mediat); 
} 
 
 
EXERCÍCIO 45: 
 
//Uma empresa deseja aumentar seus preços em 20%. Faça um algoritmo que 
//leia o código e o preço de custo de cada produto e calcule o preço novo. 
//Calcule também, a média dos preços com e sem aumento. Mostre o código e 
//o preço novo de cada produto e, no final, as médias. A entrada de dados 
//deve terminar quando for lido um código de produto negativo. 
 
principal 
{ 
// Declaração de Variáveis inteiras 
inteiro CODIGO, CONT ← 0; 
// Declaração das Variáveis reais 
real PREÇO, MEDIA1 ← 0, MEDIA2 ← 0; 
 
imprima(“Código: ”); 
leia(CODIGO); 
 
enquanto(CODIGO > 0)faça 
//Códigos negativos são inválidos 
{ 
CONT ← CONT + 1; 
//Temos mais um produto 
 
//Leitura do preço atual 
imprima(“Preço Atual: ”); 
leia(PREÇO); 
 
//soma dos preços SEM aumento 
MEDIA1 ← MEDIA1 + PREÇO; 
 
//calcula o novo preço, com aumento 
PREÇO ← 1,2 * PREÇO; 
 
//Leitura do código 
 
// soma dos preços, agora COM aumento 
MEDIA2 ← MEDIA2 + PREÇO; 
 
//imprime código e novo preço 
imprima(“Código: Preço Novo:”, CODIGO, PREÇO); 
 
imprima(“Código: ”); 
leia(CODIGO); 
 
} 
se(CONT ≠ 0)entao //evitaremos o 0/0 
{ 
//cálculo da média dos preços antigos 
MEDIA1 ← MEDIA1 / CONT; 
 
//cálculo dos preços novos 
MEDIA2 ← MEDIA2 / CONT; 
 
//imprime média antiga 
imprima(“Média dos preços antigos: ”, MEDIA1); 
 
//imprime média nova 
imprima(“Média dos preços novos: ”, MEDIA2); 
 
} 
 
} 
EXERCÍCIO 46: 
 
//Escreva um algoritmo que gere o números de 1000 a 1999 e escreva aqueles 
//que dividido por 11 dão resto igual a 5. 
 
principal 
{ 
//Declaração da variável (N será o número que vai de 1000 a 1999) 
inteiro N; 
 
para(N ← 1000; N < 1999; N ← N + 1)faça 
//1000 < N < 1999 e N vai aumentando de 1 a cada loop 
 
{ 
se(N mod 11 = 5)entao 
 
//Lembre-se que em pseudolinguagem o resto da divisão é “mod”. 
//Se o resto for 5, entra no loop (em C, resto da divisão é “%”) 
//Iremos imprimir o número N específico onde “N mod 11 = 5” 
 
imprima(N); 
} 
} 
 
 
EXERCÍCIO 47: 
 
//Escreva um algoritmo que lê um valor n inteiro e positivo e que calcula a 
//seguinte soma: 
//S := 1 + 1/2 + 1/3 + 1/4 + ... + 1/n 
//O algoritmo deve escrever cada termo gerado e o valor final de S. 
 
principal 
{ 
 
// Declaração de Variáveis 
// N: número positivo 
// I: denominador que varia de 2 a N 
// S: soma das frações. Será um float. Começa com 1.0, pois não pode 
// ser 1 ou um numero maior que 1. Em todos, S irá valer pelo menos 1 
 
inteiro N, I; 
real S; 
S ← 1.0; 
 
// Leitura do numero N, que deve ser positivo. 
//Se N for menor ou igual a 0, continua-se pedindo 
 
faça 
{ 
imprima ("Informe N positivo: "); 
leia (N); 
}enquanto (N ≤ 0); 
 
// 1º CASO: n=1 
// Irei imprimir: 
// “S = 1 (cada termo gerado) 
// S = 1” (valor final de S) 
 
se (N = 1)entao 
{ 
imprima ("S=1", “S=1”); 
} 
 
//2º CASO: explicação no final 
 
senão 
{ 
 
imprima ("S = 1 + "); 
para (I ← 2; I ≤ N; I ← I + 1) faça 
{ 
 
S ←S + 1 / I; 
se (I ≠ N)entao 
{ 
imprima ("1/ ",I ,“+”); 
} 
senão 
{ 
imprima("1/ ", I); 
} 
imprima (S); 
} 
 
} 
 
} 
 
// 2º CASO: n é diferente de 1 
// Primeiro imprime o 1º termo gerado S = 1 + 
// A partir daqui, o denominador i varia de 2 até o numero N 
// S será o somatório dos termos 1/i, sendo que seu valor inicial é 1 
// Se o I for diferente de N (não é o último termo), imprime 1/i e o sinal + 
// Caso contrário (i=n, ou seja, é o último termo), só coloca 1/i 
// Depois de tudo isso, os termos já foram impressos 
// Agora imprime o valor final de S. 
 
 
EXERCÍCIO 48: 
 
//Escrever um algoritmo que lê 10 valores, um de cada vez, e conte quantos 
//deles estão no intervalo [10,20] e quantos deles estão fora do intervalo, 
//escrevendo estas informações. 
 
principal 
{ 
//Declaração de Variáveis 
//numero: numero lido 
//i: variável de controle do comando de repetição para...faça 
//cont1: contador de quantos numeros estão no intervalo [10,20] 
//cont2: contados de quantos estão fora 
 
inteiro numero, i, cont1,cont2; 
cont10; 
cont20; 
//Código que repetirá os comandos 10x 
para (i 1; i < 10 ; i i + 1) faça //i valerá de 1 a 10 
{ 
//Leitura do numero 
imprima ("Numero: "); 
leia (numero); 
//Teste do intervalo 
se (numero > 10 E numero < 20)entao 
cont1cont1 + 1; //se está no intervalo, cont1 recebe +1 
senão cont2cont2 +1; //senão cont2 recebe +1 
 
} 
//Impressão do resultado 
imprima (cont1,“ numeros estão no intervalo [10,20]”); 
imprima (cont2,“ numeros estão fora do intervalo [10,20]”); 
 
} 
 
 
EXERCÍCIO 49: 
 
//Escrever um algoritmo que gere e escreva os 5 primeiros números perfeitos. 
//Um número perfeito é aquele que é igual a soma dos seus divisores EXCLUINDO 
//ELE MESMO. (Ex.: 6 = 1+2+3; 28= 1+2+4+7+14 etc). 
 
principal 
 
{ 
 
// Decalaração de Variáveis 
 
// numero: será os números de 1 a infinito 
 
// iremos testar cada numero até achar os 5 primeiros perfeitos 
// cont: contador de quantos números perfeitos foram encontrados 
// i: valor de controle do for 
// será utilizado para se determinar os divisores do numero 
// irá valer de 1 até o numero-1, já que o próprio número é desconsiderado 
// soma: somatório dos divisores 
// como i irá se alterar constantemente, precisamos somar os divisores 
// encontrados. No final, se esse somatório for igual ao numero, 
// temos nosso numero perfeito 
inteiro numero,cont,soma,i;numero←1; 
 
cont←0; 
 
faça 
 
{ 
 
soma←0; //resetei a soma para cada numero a ser experimentado 
 
//i irá correr todos os prováveis divisores de numero exceto ele mesmo 
 
para(i←1;i<numero;i ← i + 1)faça //não precisa de { }, pois há só um comando, 
o se 
 
//se o numero for divisível por i, achamos um divisor 
 
se(numero mod i=0) entao soma+=i; //soma dos divisores recebe o divisor i 
 
//aqui a soma de todos os divisores já foi feita 
 
se (soma=numero) entao //se a soma for igual ao numero, achamos um perfeito 
 
{ 
 
imprima(numero); //impressão do perfeito 
 
cont ← cont + 1; //achamos um perfeito 
 
} 
 
numero ← numero + 1; //Vamos verificar o próximo número 
 
}enquanto(cont<4); //até que cont torne-se 4 
 
} 
 
//ATENÇÃO: 
 
// O exercício pediu os 5 primeiros. O correto seria enquanto(cont<5)faça 
 
// No entanto, os números perfeitos são: 
 
// {6,28,496,8.128,33.550.336} 
 
// O 5º número é enorme e o computador demora tempo demais para processar 
 
// Por comodidade, acharemos os 4 primeiros 
 
EXERCÍCIO 50: 
 
// Escrever um algoritmo que leia um valor N inteiro e positivo e que calcula o 
// valor de E. Imprime o resultado de E ao final. 
// E = 1 + 1 / 1! + 1 / 2! + 1 / 3! + 1 / N! 
 
principal 
{ 
// declaração de variáveis 
// N: numero 
// CONT: será o numero cujo fatorial é o denominador, varia de 1 a N 
// AUX: é o resultado de cada fatorial 
// E: é a soma acima, começando com 1 
 
inteiro N,CONT, AUX; 
real E; 
CONT ← 1; 
AUX ← 1; 
E ← 1; 
 
//leitura do numero até ser maior do que 0 
faça 
{ 
imprima ("Informe N positivo: "); 
leia (N); 
}enquanto (N ≤ 0); 
 
//explicação no final 
enquanto (CONT ≤ N) faça 
{ 
AUX ←AUX * CONT ; 
E ←E +1.0/AUX; 
CONT ←CONT + 1; 
} 
 
//imprimindo o valor de E 
imprima (E); 
 
} 
 
// O cont vai variar de 1 a N. 
// aux é o valor do fatorial de cont, ou seja, aux = cont ! 
// Suponhamos que o N tenha sido 3. 
// 1º loop) cont vale 1 
// aux deve ser 1! -> aux ←aux * cont, ou seja, aux ←1 * 1 = 1 = 1! 
// E vai somar-se à divisão de 1/1 
// cont←cont + 1 faz cont virar 2 
// 2º loop) cont vale 2 
// aux deve ser 2! -> aux ←aux * cont, ou seja, aux ← 1 * 2 = 2 = 2! 
// E vai somar-se à divisão float 1/2 
// cont←cont + 1 -> cont = 3 
// 3º loop) cont vale 3 = N -> último loop 
// aux deve ser 3! -> aux←aux * cont, ou seja, aux ←2 * 3 = 6 = 3! 
// E vai somar-se à divisão 1/6 
// cont←cont + 1 ->cont = 4, saindo do while

Outros materiais