Lista 1 C

Prévia do material em texto

Algoritmos e Laboratório de Programação I 
 
 
Lista I – Solucionário em C 
 
 
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 
*/ 
 
#include <stdio.h> 
#include <stdlib.h> 
 
int main() 
{ 
int 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 
printf("A soma é: %d",soma); //impressão do resultado soma 
 
return 0; 
} 
 
 
EXERCÍCIO 06: 
 
//Efetuar a soma de três números digitados pelo usuário e imprimir o resultado. 
 
#include <stdio.h> 
#include <stdlib.h> 
 
int main() 
{ 
// declaração de variáveis do tipo real (float) 
float a,b,c,soma; 
 
//leitura dos números informados pelo usuário 
printf("Informe o primeiro numero: "); 
scanf("%f",&a); 
printf("Informe o segundo numero: "); 
scanf("%f",&b); 
printf("Informe o terceiro numero: "); 
scanf("%f",&c); 
 
//a variável soma recebe a soma de a, b e c 
soma=a+b+c; 
 
//Exibe resultado 
printf("A soma eh: %.2f",soma); //%.2f imprime o número real com 2 
casas decimais 
 
return 0; 
} 
 
 
EXERCÍCIO 07: 
 
//Efetuar a multiplicação de dois números digitados pelo usuário e imprimir o 
resultado. 
 
#include <stdio.h> 
#include <stdlib.h> 
 
int main() 
{ 
//declaração de variáveis do tipo inteiro (int) 
int a,b,produto; 
 
//leitura dos números informados pelo usuário 
printf("Informe o primeiro numero: "); 
scanf("%d",&a); 
printf("Informe o segundo numero: "); 
scanf("%d",&b); 
 
//calcula produto de a*b e armazena na variável produto 
produto=a*b; 
 
//Exibe o resultado 
printf("O produto eh: %d",produto); 
 
return 0; 
} 
 
 
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. 
*/ 
 
#include <stdio.h> 
#include <stdlib.h> 
 
int main() 
{ 
//declaração de variáveis do tipo real (float) 
float salario, aumento, novo_salario; 
 
//leitura de dados do funcionário 
printf("Informe seu salario atual\n"); 
scanf ("%f", &salario); 
printf ("Informe a porcentagem de aumento\n"); 
scanf ("%f", &aumento); 
 
//calculo do aumento salarial 
aumento=salario*aumento/100; 
 
//calculo do novo salario 
novo_salario=salario+aumento; 
 
//impressão dos resultados 
printf ("O valor do aumento salarial e' %.2f\n", aumento); 
printf ("O valor do novo salario e' %.2f\n", novo_salario); 
 
return 0; 
} 
 
 
EXERCÍCIO 09: 
 
/* 
Converter uma quantidade de horas digitadas pelo usuário em minutos. Informe o 
resultado em minutos. 
*/ 
 
#include <stdio.h> 
#include <stdlib.h> 
 
int main() 
{ 
//declaração das variáveis inteiras (trata-se de quantidade e não frações) 
int horas,minutos; 
 
//leitura das horas 
printf("Horas: "); 
scanf("%d",&horas); 
 
//conversão horas para minutos (X 60) 
minutos=horas*60; 
 
//impressão do resultado em minutos 
printf("Em minutos, eh %d",minutos); 
 
return 0; 
} 
 
 
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 
*/ 
 
#include <stdio.h> 
#include <stdlib.h> 
 
int main() 
{ 
/* 
Declaração de Variáveis: 
horas: quantidade de horas extras (int) 
bruto: salario bruto (float) 
valor_extra: valor de cada hora extra (float) 
liquido: salário líquido a ser calculado (float) 
*/ 
int horas; 
float bruto,valor_extra,liquido; 
 
//Leitura do salário, valor da horas extras e quantidade de horas extras 
printf("Digite o valor do salário bruto do funcionário: "); 
scanf("%f",&bruto); 
printf("Digite o valor das horas extras: "); 
scanf("%f",&valor_extra); 
printf("Digite a quantidade de horas extras trabalhadas pelo funcionário: "); 
scanf("%d", &horas); 
 
//Calculo do salário liquido 
liquido = 0.92 * (bruto + horas * valor_extra); 
 
//Impresão com duas casa decimais 
printf("O salário líquido do funcionário é de: %.2f", liquido); 
 
return 0; 
} 
 
 
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 
*/ 
 
#include <stdio.h> 
#include <stdlib.h> 
 
int main() 
{ 
/* 
Declaração de Variáveis 
Kw é a quantidade de kw consumido 
valor é o valor a pagar 
*/ 
float Kw,valor; 
 
//Leitura dos Kw consumidos 
printf("Informe a quantidade de KW consumidos: "); 
scanf("%f",&Kw); 
 
//1º cálculo: valor por Kw consumido 
valor = Kw * 0.12; 
 
//2º cálculo: volor por Kw + 18% de ICMS 
valor = valor * 1.18; 
 
//Impressão: 
printf("O total a pagar é %.2f",valor); 
 
return 0; 
} 
 
 
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. 
*/ 
 
#include <stdio.h> 
#include <stdlib.h> 
 
int main() 
{ 
//declaração das variáveis reais (float) 
float km,comb,media; 
 
//leitura da quantidade de km rodados 
printf("Quantidade de KM rodados: "); 
scanf("%f",&km); 
 
//leitura da quantidade de combustivel consumido printf("Quantidade de 
Combustivel consumido: "); scanf("%f",&comb); 
 
//cálculo da média (resultado real) 
media=comb/km; 
 
//impressão da media com duas casas decimais 
printf("A media de combustivel por km eh: %.2f",media); 
 
return 0; 
} 
 
 
EXERCÍCIO 13: 
 
/* 
Efetuar a leitura de uma nota e, se o valor for maior ou iguala 60, imprimir na tela 
"APROVADO". 
*/ 
 
#include <stdio.h> 
#include <stdlib.h> 
 
int main() 
{ 
//declaração da variavel nota 
int nota; 
 
//leitura da nota 
printf("Nota do aluno(a): "); 
scanf("%d",&nota); 
 
//comparação e impressão da mensagem 
if(nota>=60) 
printf("APROVADO"); 
 
/* 
Como se tem somente um comando dentro do if, pode-se escrevê-lo direto sem uso do 
{ e } Pode-se optar por 
if(nota>=60) 
{ 
printf("APROVADO"); 
} 
*/ 
 
return 0; 
} 
 
 
EXERCÍCIO 14: 
 
/* 
Leia uma nota 
nota >= 60 -> APROVADO 
nota < 60 -> REPROVADO 
*/ 
 
#include <stdio.h> 
#include <stdlib.h> 
 
int main() 
{ 
//Declaração da variável nota 
float nota; 
 
//Leitura da Nota 
printf ("Digite a nota:"); 
scanf("%f",&nota); 
 
//Verificar se nota é maior ou igual a 60 
if(nota>=60) 
{ 
 //caso a condição em if for verdadeira 
printf ("O aluno está aprovado.\n"); 
} 
else 
{ 
//caso a condição em if for falsa 
printf ("O aluno está reprovado.\n"); 
} 
 
return 0; 
} 
 
 
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". 
*/ 
 
#include <stdio.h> 
#include <stdlib.h> 
 
int main() 
{ 
/* 
declaração da variavel nota 
Motivo de ser float: 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 float ele não comete este erro 
*/ 
float nota; 
 
//leitura 
printf("Nota do aluno(a): "); 
scanf("%f",&nota); 
 
//comparação e impressão da mensagem 
if((nota<0)||(nota>100)) 
{ 
printf("NOTA INVÁLIDA"); 
} 
else 
{ 
if(nota<60) 
{ 
printf("REPROVADO"); 
 } 
else 
{ 
printf("APROVADO"); 
} 
} 
 
return 0; 
} 
 
 
EXERCÍCIO 16: 
 
/* 
Ler um número inteiro e informar se o número lido é par ou impar. 
*/ 
 
#include <stdio.h> 
#include <stdlib.h> 
 
int main() 
{ 
//Declaraçao da variável inteira 
int num; 
 
//Leitura do numero 
printf("Informe um numero: "); 
scanf("%d",&num); 
 
//Comparação 
if(num%2==0) 
{ 
//se o resto da divisao por 2 é zero, imprima PAR 
printf("PAR"); 
} 
else 
{ 
//senão imprima ÍMPAR 
printf("ÍMPAR"); 
} 
 
return 0; 
} 
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" 
*/ 
 
#include <stdio.h> 
#include <stdlib.h> 
 
int main() 
{ 
//Declaração da variável inteira num 
int num; 
 
//Leitura do numero 
printf("Digite um numero: "); 
scanf("%d",&num); 
 
//Vamos testar se é divisível por 10 
if(num%10==0) 
{ 
//se sim, imprime metade do num 
printf("A metade deste numero eh %d",num/2); 
//Observe que poderíamos criar outra variável conta=num/2 e imprimir ela 
} 
else 
{ 
//se não, imprime a msg 
printf("O numero digitado nao termina com 0"); 
} 
return 0; 
} 
 
 
EXERCÍCIO 18: 
 
/* 
Ler um número e informar se ele é positivo, negativo ou neutro (zero). 
*/ 
 
#include <stdio.h> 
#include <stdlib.h> 
 
int main() 
{ 
//declaração de variáveis do tipo inteiro 
int num; 
 
//leitura e armazenamento do valor 
printf("Digite um numero\n"); 
scanf ("%d", &num); 
 
//compara e avalia se o valor é positivo, negativo ou neutro e imprime o 
resultado 
if (num==0) 
printf ("O valor lido é neutro\n"); 
else 
if (num>0) 
printf ("O valor lido é positivo\n"); 
else 
printf ("O valor lido é negativo\n"); 
 
return 0; 
} 
 
 
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%. 
*/ 
 
#include <stdio.h> 
#include <stdlib.h> 
 
int main() 
{ 
//declaração de variáveis 
float salario; //salario é real 
float tempo; //ao comparar em até 1 ano, pode ser fração de ano 
float novo; //salario reajustado 
 
//leitura do salario 
printf("Informe o salario: "); 
scanf("%f",&salario); 
 
//leitura do tempo de serviço 
printf("Informe o tempo de servico em anos: "); 
scanf("%f",&tempo); 
 
/* 
1ª parte do if 
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 if 
reajuste de 20%, novo salário é 120%, salário antigo por 
*/ 
 
if(tempo<=1) 
{ 
novo=1.1*salario; 
printf("O novo salario eh de %.2f",novo); 
} 
else 
{ 
novo=1.2*salario; 
printf("O novo salario eh de %.2f",novo); 
} 
 
return 0; 
} 
 
 
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 
*/ 
 
#include <stdio.h> 
#include <stdlib.h> 
 
int main() 
{ 
//Declaração de Variáveis (dois anos e uma idade inteiros) 
int ano_atual,ano_nasc,idade; 
 
//Leitura de ambos anos 
printf("Informe o ano atual: "); 
scanf("%d",&ano_atual); 
printf("Informe o ano de nascimento: "); 
scanf("%d",&ano_nasc); 
 
//Cálculo da idade 
idade = ano_atual - ano_nasc; 
 
//Exibir idade 
printf("Sua idade é: %d \n\n",idade); 
//soltamos dois ENTER's no final pelo \n 
 
//Exibir Classificação 
if(idade<0) 
{ 
printf("Idade Inválida \n"); //não existe idade negativa 
} 
else 
{ 
if((0<=idade)&&(idade<=3)) 
{ 
 
printf("Bebê \n"); 
} 
else 
{ 
if((4<=idade)&&(idade<=10)) 
{ 
//Se está no intervalo [4,10] 
printf("Criança \n"); 
} 
else 
{ 
if((10<idade)&&(idade<19)) 
{ 
//Se está no intervalo [10,19] 
printf("Adolescente \n"); 
} 
else 
{ 
if((18<idade)&&(idade<51)) 
{ 
//Se está no intervalo [18,51] 
printf("Adulto \n"); 
 } 
else //o quê restou foi 51 ou mais 
printf("Idoso \n"); 
} 
} 
 } 
 } 
return 0; 
} 
 
 
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". 
*/ 
 
#include <stdio.h> 
#include <stdlib.h> 
 
int main() 
{ 
//declaração da variável mes que será de 1 a 12 
int mes; 
 
//leitura do numero do mes 
printf("Informe o numero do mes: "); 
scanf("%d",&mes); 
 
/* 
comando switch com 12 casos + default 
de 1 a 12, irá imprimir o mes correspondente 
o default informa que o numero é inválido, ou seja, se não estar em [1,12], é 
inválido 
Lembre-se do break 
*/ 
switch(mes) 
{ 
case 1: printf("Janeiro"); 
break; 
case 2: printf("Fevereiro"); 
break; 
case 3: printf("Marco"); 
break; 
case 4: printf("Abril"); 
break; 
case 5: printf("Maio"); 
break; 
case 6: printf("Junho"); 
break; 
case 7: printf("Julho"); 
break; 
case 8: printf("Agosto"); 
break; 
case 9: printf("Setembro"); 
break; 
case 10: printf("Outubro"); 
break; 
case 11: printf("Novembro"); 
break; 
case 12: printf("Dezembro"); 
break; 
default: printf("Mes Invalido"); 
} 
return 0; 
} 
 
 
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". 
*/ 
 
#include <stdio.h> 
#include <stdlib.h> 
 
int main() 
{ 
//declaração de variáveis 
float salario,financ; 
float razao; //razão entre financiamento e salario 
 
//leitura do salario e financiamento 
printf("Digite o salario e o valor do financiamento: "); 
scanf("%f %f",&salario,&financ); 
 
//cálculo da razão entre financ e salario 
razao=financ/salario;//se a razao for > 5, será negado. Se não, será concedido 
if (razao>5) printf("Financiamento Negado"); 
else printf("Financiamento Concedido"); 
return 0; 
} 
 
 
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. 
*/ 
 
#include <stdio.h> 
#include <stdlib.h> 
 
int main() 
{ 
//Declaração de Variável (horas é inteiro e salário é float) 
int horas; 
float salario; 
 
//Leitura da quantidade de horas 
printf("Numero de horas trabalhadas: "); 
scanf("%d",&horas); 
 
//Cálculo do Salário 
if(horas<40) 
{ 
//se horas < 40, salario é R$15.00 por hora 
salario=horas*15; 
} 
else 
{ 
//senão, vai ser 600 + R$21.00 por hora excedente 
salario=600+21*(horas-40); //ou seja, hora_excedente = horas - 40 
} 
 
//Impressão do salário 
printf("O salario semanal desta pessoa eh %.2f",salario); 
return 0; 
} 
 
 
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. 
*/ 
 
#include <stdio.h> 
#include <stdlib.h> 
 
int main() 
{ 
//Declaração de Variável (horas é inteiro e salário é float) 
int horas; 
float salario; 
 
//Leitura da quantidade de horas 
printf("Numero de horas trabalhadas: "); 
scanf("%d",&horas); 
 
//Cálculo do Salário 
if(horas<40) 
{ 
 //se horas < 40, salario é R$15.00 por hora 
salario=horas*15; 
} 
else 
{ 
//senão, vai ser 600 + R$21.00 por hora excedente 
salario=600+21*(horas-40); 
//ou seja, hora_excedente = horas - 40 
} 
 
//Impressão do salário 
printf("O salario semanal desta pessoa eh %.2f",salario); 
return 0; 
} 
 
 
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. 
*/ 
 
#include <stdio.h> 
#include <stdlib.h> 
 
int main() 
{ 
/* 
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 correpondente. 
Por isso, duas variáveis: meses (inteiro) e anos (float). 
*/ 
int meses; 
float anos; 
 
//Leitura dos meses 
printf("Informe o tempo em meses em que os fundos foram mantidos em 
deposito: "); 
scanf("%d",&meses); 
 
/* 
Cálculo da fração de ano correspondente: 
Se colocássemos ano=meses/12; estaria errado. Aqui é uma divisao de dois 
inteiros. 
Ele fornece um numero inteiro. Ex.: 18/12 daria 1. Como anos é float, anos 
receberia 1.00 
No entanto, anos deve receber 1.5. Logo, convertemos a divisão inteira para 
divisão float 
Basta colocar (float) na frente 
*/ 
anos=(float)meses/12; 
 
/* 
Impressão dos valores correspondentes 
 
Esta é outra maneira de encadear IF's. Repare que no último else, ainda colocamos 
uma condição if. Se não o tivéssemos feito, anos negativos poderiam ser 
considerados 
*/ 
if(anos>=5) 
{ 
printf("Taxa de Juros de 0.95"); 
 } 
else 
{ 
if(anos<5 && anos>=4) 
{ 
printf("Taxa de Juros de 0.90"); 
} 
else 
{ 
if(anos<4 && anos>=3) 
{ 
printf("Taxa de Juros de 0.85"); 
} 
else 
{ 
if(anos<3 && anos>=2) 
{ 
printf("Taxa de Juros de 0.75"); 
} 
else 
{ 
if(anos<2 && anos>=1) 
{ 
printf("Taxa de Juros de 0.65"); 
} 
else 
{ 
if(anos<1 && anos>0) 
{ 
printf("Taxa de Juros de 0.55"); 
} 
} 
 } 
 } 
 } 
 } 
return 0; 
} 
 
 
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 
*/ 
 
#include <stdio.h> 
#include <stdlib.h> 
 
int main() 
{ 
//Declaração de Variáveis 
int ano; 
float peso; 
 
//Leitura de ambas 
printf("Informe o ano do carro: "); 
scanf("%d",&ano); 
printf("Informe o peso do carro: "); 
scanf("%f",&peso); 
 
//Comparações e Impressões dos Valores Correspondentes 
if(ano<=1970) 
{ 
//1º caso (observe esta maneira de encadear IF's) 
if(peso<1200) 
printf("Classe: 1 Taxa de Registro: R$16.50"); 
else 
if(peso>=1200 && peso<=1700) 
printf("Classe: 2 Taxa de Registro: R$25.50"); 
else 
//senão > 1700 (situação que restou) 
printf("Classe: 3 Taxa de Registro: R$46.50"); 
 } 
else if(ano>1970 && ano<1980) 
//Podemos colocar um "senão se" direto ou colocar este "se" dentro do "senão" 
{ 
 
 if(peso<1200) 
 printf("Classe: 4 Taxa de Registro: R$27.00"); 
 else if(peso>=1200 && peso<=1700) 
 printf("Classe: 5 Taxa de Registro: R$30.50"); 
 else 
 printf("Classe: 6 Taxa de Registro: R$52.50"); 
} 
else 
//aqui não precisa de outro if. O quê restou foi ano > = 1980 
{ 
 if(peso<3600) 
 printf("Classe: 7 Taxa de Registro: R$19.50"); 
 else 
 printf("Classe: 8 Taxa de Registro: R$52.50"); 
 } 
return 0; 
} 
 
 
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 
*/ 
 
#include <stdio.h> 
#include <stdlib.h> 
 
int main() 
{ 
 /* 
 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 dividido por 10 é a média freq: total de ausências 
 */ 
 float p1,p2,trab,media; 
 int freq; 
 
 //Leitura dos Dados 
 printf("Informe a nota da 1ª prova: "); 
 scanf("%f",&p1); 
 printf("Informe a nota da 2ª prova: "); 
 scanf("%f",&p2); 
 printf("Informe a nota do trabalho: "); 
 scanf("%f",&trab); 
 printf("Informe a frequência (total de ausências): "); 
 scanf("%d",&freq); 
 
 //Cálculo da Média 
 media=(3*p1+5*p2+2*trab)/10; 
 
 //1º Teste: frequência 
 if(freq>15) printf("REPROVADO"); 
 
 else 
 //não foi reprovado por frequência. Agora é a média que qualifica 
 { 
 if(media>=6) printf("APROVADO"); 
 else printf("PROVA FINAL"); 
 } 
 return 0; 
} 
 
 
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 
*/ 
 
#include <stdio.h> 
#include <stdlib.h> 
 
int main() 
{ 
 //criação da variável a ser utilizada na múltipla escolha 
 int codigo; 
 
 //Leitura do Código 
 printf("Digite o código do cargo do funcionário: "); 
 scanf("%d", &codigo); 
 
 //código da múltipla escolha 
 switch(codigo) 
 { 
 case 101: printf("Cargo: Vendedor"); 
 //Se a variável for igual a 101 
 break; 
 //interrompe aqui. Se não o tiver, continuará executando todas as 
tarefas dos outros case 
 
 case 102: printf("Cargo:Atendente"); 
 break; 
 
 case 103: printf("Cargo: Auxiliar Técnico"); 
 break; 
 
 case 104: printf("Cargo: Assistente"); 
 break; 
 
 case 105: printf("Cargo: Coordenador de Grupo"); 
 break; 
 
 case 106: printf("Cargo: Gerente"); 
 break; 
 
 default: printf("Código Inválido."); //não precisa de break; 
 } 
 return 0; 
} 
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 codigo e informe o tipo correto de unidade de disco. 
*/ 
 
#include <stdio.h> 
#include <stdlib.h> 
 
int main() 
{ 
 //Declaração da variável codigo que será usado na múltipla escolha 
 int codigo; 
 
 //Leitura do Codigo 
 printf("Informe o código: "); 
 scanf("%d",&codigo); 
 
 //múltipla escolha entre 4 casos específicos e um default 
 switch(codigo) 
 { 
 case 1: printf("CD-ROM (700MB)"); //caso codigo= =1 
 break; 
 
 case 2: printf("DVD-ROM (4.7GB)"); //caso codigo= =2 
 break; 
 
 case 3: printf("DVD-9 (8.54 GB)"); //caso codigo= =3 
 break; 
 case 4: printf("Blu-Ray (25 GB)"); //caso= =4 
 break; 
 
 default: printf("Código Inválido"); 
 //caso codigo não seja 1,2,3 nem 4 
 } 
 return 0; 
} 
 
 
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". 
*/ 
 
#include <stdio.h> 
#include <stdlib.h> 
 
int main() 
{ 
 //declaração dos dois numeros reais e resultado da operação realizada 
 float a,b,result; 
 
 //declaração do codigo de seleção 
 int cod; 
 
 //leitura dos dois numeros 
 printf("Insira dois numeros reais : "); 
 scanf("%f %f",&a,&b); 
 
 //leitura do codigo 
 printf("Insira o codigo: "); 
 scanf("%d",&cod); 
 
 /* 
 Opções disponíveis: 
 cod = 1 : somar 
 cod = 2 : multiplicar 
 cod = 3 : dividir 
 outro cod = invalido 
 */ 
 switch(cod) 
 { 
 case 1: 
 { 
 result=a+b; 
 printf("A soma eh: %.2f",result); 
 } 
 break; 
 case 2: 
 { 
 result=a*b; 
 printf("O produto eh: %.2f",result); 
 } 
 break; 
 case 3: 
 { 
 if(b!=0) 
 { 
 result=a/b; 
 printf("O quociente eh: %.2f",result); 
 } 
 else 
 { 
 printf("Divisao impossivel”); 
 } 
 } 
 break; 
 default: printf("Codigo Invalido"); 
 } 
 return 0; 
} 
 
 
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. 
*/ 
 
#include <stdio.h> 
#include <stdlib.h> 
 
int main() 
{ 
 //declaração de variaveis 
 int nota; 
 
 //leitura da nota do aluno 
 printf ("Informe o valor da nota\n"); 
 scanf ("%d", &nota); 
 
 //compara a nota e atribui o conceito correspondente 
 if (nota<0 || nota>10) 
 printf ("Nota invalida\n"); 
 else 
 if (nota==9 || nota==10) 
 printf ("Conceito A\n"); 
 else 
 if (nota==8 || nota==7) 
 printf ("Conceito B\n"); 
 else 
 if (nota==6 || nota==5) 
 printf ("Conceito C\n"); 
 else 
 printf ("Conceito D\n"); 
 return 0; 
} 
 
 
EXERCÍCIO 31: 
 
/* 
2 valore 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 
*/ 
 
#include <stdio.h> 
#include <stdlib.h> 
 
int main() 
{ 
 //declaração de variáveis 
 int n1, n2, soma, produto, aux; 
 float media, quociente; 
 
 //leitura dos inteiros excluindo fora do intervalo [1,10] 
 do{ 
 printf("Digite dois inteiros entre 1 e 10: "); 
 scanf ("%d %d",&n1,&n2); 
 }while((n1<1)||(n1>10)||(n2<1)||(n2>10)); 
 //n1 e n2 menor que 1 e maior que 10 estão fora 
 
 //calcula a soma 
 soma=n1+n2; 
 //se a soma for menor que 8, pede-se a média 
 if(soma<8) 
 { 
 media=(n1+n2)/2; //cálculo da média 
 printf("A média eh %.2f",media); 
 } 
 else //se a soma não é menor que 8, então 
 { 
 if(soma==8) //se soma = 8, pede-se o produto 
 { 
 produto=n1*n2; //cálculo do produto 
 printf("O produto eh %d",produto); 
 } 
 else 
 //senão a soma é maior 
 { 
 //precisamos ver quem é o maior 
 if (n1<n2) 
 //queremos jogar o maior no n1. 
 //Então se o maior for n2, trocamos 
 { 
 aux=n1; //auxiliar recebe n1 
 n1=n2; //n1 recebe n2 
 n2=aux; 
 /*n2 recebe auxiliar, 
 ou seja, n2 recebeu o valor de n1*/ 
 } 
 //O quociente pode ser float 
 quociente=(float)n1/n2; 
 //colocando (float), nós convertemos a divisão inteira 
 //n1/n2 
 
 printf("O quociente eh %.2f",quociente); 
 
 } 
 
 } 
 return 0; 
} 
 
 
EXERCÍCIO 32: 
 
/* 
Escrever um algoritmo que lê 10 valores e conte quantos destes valores são 
negativos, escrevendo esta informação. 
*/ 
 
#include <stdio.h> 
#include <stdlib.h> 
 
int main() 
{ 
 /* 
 Declaração de Variáveis 
 numero: numero digitado, que é float 
 i: variável que será usado no for como variável de controle 
 cont: contador de números negativos. Começa com 0, pois não existe nenhum 
negativo inicialmente 
*/ 
 float numero; 
 int i,cont=0; 
 
 for(i=1;i<=10;i++) 
 /* 
 i começa com 1 e vai até 10 aumentando de 1 em 1 
 Ou seja, iremos realizar os comandos abixo 10X, para 10 numeros 
 */ 
 { 
 //Leitura do numero (ocorrerá 10X) 
 printf("Digite o %dº numero: ",i); 
 //%dº é um recurso estilístico. Aparece 1º,2º,... 
 scanf("%f",&numero); 
 
 if(numero<0) cont++; //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 for 
 
 /*ao chegar aqui, 
 cont terá recebido a quantidade de negativos entre os 10 numeros*/ 
 
 //Impressão da quantidade 
 printf("A quantidade de numeros negativos são %d",cont); 
 return 0; 
} 
 
 
EXERCÍCIO 33: 
 
/* 
Escreva um algoritmo que leia 20 valores e encontre o maior e o menor 
deles. Mostre o resultado. 
*/ 
 
#include <stdio.h> 
#include <stdlib.h> 
int main() 
{ 
 /* 
 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 
 */ 
 int maior,menor,valor,cont=1; 
 
 //Leitura do 1º Valor 
 printf("Digite o valor 1: "); 
 scanf("%d",&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++; 
 /*incrementa contador. 
 Aqui eu já tive um valor. O próximo será o 2. Logo, cont=2*/ 
 
 do //faça uma vez primeiro... 
 { 
 //Leitura dos novos valores 
 printf("Digite o valor %d: ",cont); 
 scanf("%d", &valor); 
 
 /*Vamos comparar com a variavel maior 
 que armazena o maior valor até aqui*/ 
 if(valor > maior) //se o valor é maior que o maior valor, então 
 maior = valor; //a variável maior armazena o novo valor 
 if(valor < menor) //de forma análoga para o menor 
 menor = valor; 
 
 cont++; //Vamos ler o próximo numero 
 
 }while(cont<=20); 
 //... e continuaremos repetindo tudo até que cont ultrapasse 20 
 
 //Poderíamos ter usado somente while aqui. Seria while(cont<=20){...} 
 
 //impressão do maior valor e do menor 
 printf("\n\nMaior: %d\nMenor: %d\n", maior, menor); 
 return 0; 
} 
 
 
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 negativoe o exercício não permite de zero 
*/ 
 
#include <stdio.h> 
#include <stdlib.h> 
 
int main() 
{ 
 /* 
 Declaração de Variáveis 
 N foi iniciado com 0 para que entre no 1º while 
 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. 
 */ 
 int N=0,res=1; 
 
 /* 
 Comando While: 
 enquanto N<=0, vai ficar solicitando um numero positivo 
 irá fazer a verificação se este N é > 0. Aí vai parar. 
 */ 
 while(N<=0) 
 { 
 printf("Informe N: "); 
 scanf("%d",&N); 
 } 
 
 //Imprimir a mensagem abaixo 
 printf("O fatorial de %d eh: ",N); 
 
 //Código (explicação no final): 
 while(N>=1) 
 { 
 res*=N; 
 //res=res*N; 
 if(N!=1) 
 printf("%d * ",N); 
 else 
 printf("%d = ",N); 
 N--; 
 } 
 printf("%d",res); 
 return 0; 
} 
 
/* 
 
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 
 
Percebe-se que iremos diminuir de 1 unidade o N a cada loop. 
Aí iremos imprimir este novo N mais um sinal *. 
Quando ele chegar a 1, será o último loop. Imprimiremos 1 = 
No próximo, N será zero. Aí pára. Por isso no while, está enquanto N>=1 
 
3) O resultado res receberá ele mesmo multiplicado pelo novo N a cada loop 
até chegar a N=1 
 
4) Como dito em (2), se N é diferente de 1, iremos imprimir N e o sinal * 
Quando N for 1, ou seja, NÃO(DIFERENTE), aí iremos imprimir N e = 
 
5) Depois retiramos uma unidade de N. 
 
6) Logo em seguida, imprimimos o resultado final já multiplicado por todos os N's 
Note que a impressão ocorre sem saltar "ENTER's" 
 
*/ 
 
 
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. 
*/ 
 
#include <stdio.h> 
#include <stdlib.h> 
int main() 
{ 
 /* 
 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 % 
 */ 
 int filhos,contp=0; 
 float salario,mediaF=0,mediaS=0,maior=0,perc=0; 
 
 do{ //faremos uma vez... 
 
 //Leitura do 1º salário 
 printf("Informe o salário: "); 
 scanf("%f",&salario); 
 
 if(salario>=0) 
 { //se salario for positivo ou nulo, faz o restante 
 
 contp++; 
 //população aumentou em uma unidade 
 mediaS+=salario; 
 //somaremos o salario em mediaS (mediaS = mediaS + salario) 
 
 /*se o salario é maior que o maior anteriormente registrado, 
 maior recebe ele*/ 
 
 if(salario>maior) maior=salario; 
 
 //Ver se enquadra na parte menor de 100 
 if(salario<=100) perc++; //mais um igual ou abaixo de 100 
 
 //Leitura do numero de filhos 
 printf("Numero de Filhos: "); 
 scanf("%d",&filhos); 
 
 mediaF+=filhos; 
 //somaremos os filhos aqui (mediaF = mediaF + filhos) 
 
 } 
 //se salario menor que 0 não entra no if 
 }while(salario>=0); 
 //...e continuamos repetindo pra sempre até que salario seja negativo 
 //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 
 if(contp!=0) 
 //contp pode ser 0 se o 1º salario for negativo. Logo não tem que informar nada 
 { 
 printf("\n Média de Salário: %.2f \n",mediaS); 
 printf("\n Média de Filhos: %.2f \n",mediaF); 
 printf("\n Maior salário: %.2f \n",maior); 
 printf("\n Percentual de pessoas com salário até 100: %.2f \n",perc); 
 } 
 return 0; 
} 
 
 
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. 
*/ 
 
#include <stdio.h> 
#include <stdlib.h> 
 
int main() 
{ 
 //declaração de variáveis 
 int anos=0; //quantidade de anos que se passam até zé ficar maior 
 float chico=1.5,ze=1.3; //altura de cada um 
 
 //enquanto chico maior que ze, ambos aumentam e passa 1 ano por loop 
 while(chico>=ze) 
 { 
 chico=chico+0.02; 
 //chico cresce 0.02 
 
 ze+=0.03; 
 /*ze cresce 0.03 -> Repare que ze+=0.03; 
 é a mesma coisa que ze=ze+0.03;*/ 
 
 anos++; //passou 1 ano 
 } 
 
 /* 
 só saiu do while quando ze ficou maior. anos irá valer a quantidade de anos 
 necessários para isso 
 */ 
 
 printf("Anos: %d",anos); //imprime-se a quantidade de anos 
 return 0; 
} 
 
 
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. 
*/ 
 
#include <stdio.h> 
#include <stdlib.h> 
 
int main() 
{ 
 
 /* 
 declaração de variáveis n: numero digitado 
 cont: quantos numeros foram (inicialmente é zero) 
 soma: a soma de todos (inicialmente é zero) A média é soma/cont que pode ser 
 float 
 Por isso, o cont OU o soma deve ser float. Escolhemos o soma Se quiser fazer soma 
 como int, media deve ser: media=(float)soma/cont; 
 -> (float) converte a divisão inteira para real 
 */ 
 int n,cont=0; 
 float soma=0; 
 
 //Iremos ler o 1º numero e ficar repetindo enquanto n >= 0 
 //(quando n<0, interrompe) 
 
 do{ 
 printf("Informe o numero inteiro e positivo: "); 
 scanf("%d",&n); //leitura de n 
 if(n>=0) 
 //se n não é negativo, iremos fazer a soma e acrescentar 1 no contador 
 { 
 soma+=n; //é a mesma coisa que soma=soma+n; 
 cont++; //é a mesma coisa que cont=cont+1; 
 } 
 }while(n>=0); //iremos ficar repetindo até que n torne-se negativo 
 
 //Agora, n foi negativo. Já somamos todos os anteriores e contamos quantos foram 
 
 if(cont!=0) 
 //se cont for igual a 0, quer dizer que não houve numero nenhum. 
 //O negativo foi o 1º 
 printf("A media aritmetica eh: %.2f",soma/cont); //imprimimos a media 
 /* 
 observe que podíamos criar uma variável media=soma/cont; 
 depois colocaríamos media no printf 
 Aqui mostro outro jeito: colocar a operação direta no printf 
 */ 
 return 0; 
} 
 
 
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. 
*/ 
 
#include <stdio.h> 
#include <stdlib.h> 
 
int main() 
{ 
 /* 
 Declaração de Variáveis 
 codigo: codigo de votação 
 c1,c2,c3,c4,nulo,branco: contadores para os candidatos 1,2,3 e 4 e para nulo e 
 branco 
 */ 
 int codigo,c1=0,c2=0,c3=0,c4=0,nulo=0,branco=0; 
 
 do{ //faça uma vez.... 
 //Leitura do código 
 printf("Informe o codigo: "); 
 scanf("%d",&codigo); 
 //se codigo é diferente de zero, faça: 
 if(codigo!=0) 
 { 
 switch(codigo) //múltipla escolha{ 
 case 1: c1++; //+1 voto para o 1 
 break; 
 case 2: c2++; //+1 voto para o 2 
 break; 
 case 3: c3++; //+1 voto para o 3 
 break; 
 case 4: c4++; //+1 voto para o 4 
 break; 
 case 5: nulo++; //+1 voto nulo 
 break; 
 case 6: branco++; //+1 voto branco 
 break; 
 default: printf("\n Código Inválido \n\n"); 
 //codigos negativos e maiores que 6 
 } 
 } 
 
 }while(codigo!=0); //... continua repetinfo até codigo ser 0 
 
 //Impressão dos resultados 
 printf("\nTotal de votos para o candidato 1: %d \n",c1); 
 printf("Total de votos para o candidato 2: %d \n",c2); 
 printf("Total de votos para o candidato 3: %d \n",c3); 
 printf("Total de votos para o candidato 4: %d \n",c4); 
 printf("Total de votos nulos: %d \n",nulo); 
 printf("Total de votos brancos: %d \n",branco); 
 return 0; 
} 
 
 
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: 
1xn=n 
2 x n = 2n 
3 x n = 3n 
............... 
n x n = n2 
*/ 
 
#include <stdio.h> 
#include <stdlib.h> 
 
int main() 
{ 
 //declaração de variáveis (n é o número e i é usado no for) 
 int n,i; 
 
 //leitura do n 
 printf("Informe n: "); 
 scanf("%d",&n); 
 
 /* 
 FOR: 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) 
 PRINTF: 3 números inteiros impressos: i, n e o resultado i*n 
 */ 
 
 for(i=1;i<=n;i++) 
 { 
 printf("%d X %d = %d \n",i,n,i*n); 
 } 
 return 0; 
} 
 
 
EXERCÍCIO 40: 
 
/* Lê os valores n1 e n2 e imprime o intervalo fechado entre esses dois valores. */ 
 
#include <stdio.h> 
#include <stdlib.h> 
 
int main() 
{ 
 //declaração de variaveis 
 int n1, n2, aux; 
 
 //leitura dos inteiros 
 printf("Digite dois valores inteiros\n"); 
 scanf ("%d %d",&n1,&n2); 
 
 //compara n1 e n2 e atribui o menor valor à variavel n1 
 if (n1>n2) 
 { 
 aux=n2; 
 n2=n1; 
 n1=aux; 
 } 
 
 printf ("Intervalo fechado entre %d e %d:\n\n", 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*/ 
 
 while (n1<=n2) 
 { 
 printf ("%d\n", n1); 
 n1++; //n1=n1+1; 
 } 
 return 0; 
} 
 
 
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) 
*/ 
 
#include <stdio.h> 
#include <stdlib.h> 
 
int main() 
{ 
 /* 
 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 
 */ 
 int n,result,fator,numero,repetir=1; 
 
 //Leitura da qtd de valores 
 printf("Quantidade de Valores: "); 
 scanf("%d",&n); 
 
 do{ //faça uma vez... 
 
 //"resetando" o resultado e a fator para cada numero 
 result=1; 
 fator=1; 
 
 //Leia o numero a ser fatorado 
 printf("Valor: "); 
 scanf("%d",&numero); 
 if(numero==0 || numero==1) //fatoriais de 0 e 1 é 1 
 { 
 result=1; //resultado direto 
 } 
 else //caso seja 2 pra frente... 
 { 
 while(fator<=numero) 
 //... result = result * fator até que fator se iguale ao numero 
 { 
 result=result*fator; 
 fator++; 
 } 
 } 
 
 /* 
 aqui, o fatorial do numero já foi calculado 
 antes de passar para o próximo, temos que imprimir em forma de tabela 
 Usaremos tabulação: \t 
 */ 
 
 printf("\n Numero: %d \t Fatorial: %d \n\n",numero,result); 
 
 repetir++; //repetir aumenta uma unidade. Vamos para o próximo numero 
 
 }while(repetir<=n); //... e continue até que repetir se iguale a n (última 
vez) 
 
 //chegando aqui, todos os n valores tiveram seu fatorial calculado e impresso 
 return 0; 
} 
 
 
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 
*/ 
 
#include <stdio.h> 
#include <stdlib.h> 
 
int main() 
{ 
 /* 
 Declaração de Variáveis 
 numero: numero inteiro lido 
 cont: quantidade total de numeros lidos (inteiro) 
 media: no 1º momento, será a soma de todos os números e no 2º momento, media = 
 media/cont. Assim, media será a média aritmética dos numeros (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)/cont, ou seja, c1 será o PERCENTUAL de valores positivos 
 em (cont) numeros lidos. Aqui ele será float. Por isso, foi declarado como float 
 */ 
 int numero,cont=0; 
 float media=0,c1=0,c2=0; 
 
 do //faça uma vez... 
 { 
 //Leia o numero 
 printf("Digite um numero: "); 
 scanf("%d",&numero); 
 
 if(numero!=0) //se o numero for diferente de zero, faça: 
 { 
 media+=numero; //a media recebe a soma de todos os numeros 
 cont++; //cont contará a qtd de numeros lidos 
 if(numero>0) //se numero é positivo... 
 { 
 c1++; //...contador dos positivos c1 recebe +1 
 
 }else c2++; //De forma análoga, c2 recebe +1 se for negativo 
 } 
 }while(numero!=0); //... até que numero seja 0 
 //Aqui a media tem a soma de todos os numeros 
 
 //Cálculo da Média aritmética 
 media=media/cont; 
 
 //Impressão 
 printf("\n Média Aritmética: %f",media); 
 
 //Aqui c1 e c2 são as quantidades de numeros positivos e negativos 
 //estou imprimindo valores float com 0 casas decimais. É como se fossem inteiros 
 printf("\n Quantidade de Valores Positivos: %.0f",c1); 
 printf("\n Quantidade de Valores Negativos: %.0f",c2); 
 
 //Aqui eu modificarei os valores de c1 e c2. Eles virarão percentuais. 
 c1=(c1*100)/cont; 
 c2=(c2*100)/cont; 
 
 //Agora c1 e c2 mudaram de valor. Irei imprimí-los com 2 casas decimais: 
 printf("\n Percentual de Valores Positivos: %.2f",c1); 
 printf("\n Percentual de Valores Negativos: %.2f",c2); 
 return 0; 
} 
 
 
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 for lido um número negativo. 
*/ 
 
#include <stdio.h> 
#include <stdlib.h> 
 
int main() 
{ 
 /* 
 Declaração de Variáveis numero: numero lido 
 c1,c2,c3,c4: contadores de cada intervalo 
 */ 
 int num=1, c1=0, c2=0, c3=0, c4=0; 
 while(num >= 0) 
 { 
 //Leitura do numero 
 printf("Digite um número: "); 
 scanf("%d", &num); 
 // Testes 
 if(num >= 0 && num <= 25) 
 c1++; 
 else if(num >= 26 && num <= 50) 
 c2++; 
 else if(num >= 51 && num <= 75) 
 c3++; 
 else if(num >= 76 && num <= 100) 
 c4++; 
 } 
 printf("No intervalo 1 foram digitados %d números.\n", c1); 
 printf("No intervalo 2 foram digitados %d números.\n", c2); 
 printf("No intervalo 3 foram digitados %d números.\n", c3); 
 printf("No intervalo4 foram digitados %d números.\n", c4); 
 return 0; 
} 
 
 
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. 
*/ 
 
#include <stdio.h> 
#include <stdlib.h> 
 
int main() 
{ 
 /* 
 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 float mediap: 
 média dos pares 
 mediat: média total (Observe que a quantidade total é contp + conti) 
 */ 
 int n,contp=0,conti=0,somap=0,somat=0; //inicialização na declaração 
 float mediap,mediat; 
 
 do{ 
 printf("Informe n positivo: "); 
 scanf("%d",&n); //leitura do 1º n 
 if(n>0) //Se n for positivo realiza-se as contas 
 { 
 somat+=n; //some o n na soma total 
 if(n%2==0) //se n for par 
 { 
 contp++; //iremos acrescentar +1 no contador de pares 
 somap+=n; //iremos somar o n par ao somap (somap=somap+n) 
 } 
 else conti++; //se n for ímpar, somente some +1 no conti 
 } 
 }while(n!=0); //continua solicitando n's até que digite 0 
 //Cálculo da média 
 mediap=(float)somap/contp; //converti divisão 
 mediat=(float)somat/(contp+conti); //idem a. 
 
 //Impressão 
 printf("\n Quantidade de Pares: %d",contp); 
 printf("\n Quantidade de Ímpares: %d",conti); 
 printf("\n Média dos Pares: %.2f",mediap); 
 printf("\n Média Total: %.2f",mediat); 
 return 0; 
} 
 
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. 
*/ 
 
#include <stdio.h> 
#include <stdlib.h> 
 
int main() 
{ 
 /* 
 Declaração de Variáveis 
 codigo: código do produto (negativo sai) 
 cont: quantidade de produtos 
 preco: primeiramente será preço atual do produto. Depois será o preço novo do 
 produto (120% do atual) 
 media1: primeiramente será a soma dos preços sem aumento. Depois será a média 
 deles 
 media2: primeiramente será a soma dos preços com aumento. Depois será a média 
 deles 
 */ 
 int codigo,cont=0; 
 float preco,media1=0,media2=0; 
 
 //Leitura do código 
 printf("Codigo: "); 
 scanf("%d",&codigo); 
 
 while(codigo>=0) //códigos negativos são inválidos 
 { 
 cont++; //temos +1 produto 
 
 //Leitura do preço atual 
 printf("Preço atual: "); 
 scanf("%f",&preco); 
 
 media1+=preco; //A media1 = media1 + preco (soma dos preços sem aumento) 
 
 //Cálculo do novo preço zlterando o valor de preco 
 preco=1.2*preco; 
 
 media2+=preco; 
 // media2 = media2 + preco, sendo este o NOVO preço COM aumento 
 
 //Impressão do código e do novo preço 
 printf("\n Codigo: %d Preço Novo: %.2f \n\n",codigo,preco); 
 
 //Leitura do código 
 printf("Codigo: "); 
 scanf("%d",&codigo); 
 } 
 /* 
 aqui a media1 e media2 somaram todos os preços possíveis 
 temos de calcular as médias verdadeira, que é a soma/cont 
 perceba que se eu colocar um codigo negativo "de cara", 
 a divisão será 0/0, que é indeterminado e dará erro 
 */ 
 
 if(cont!=0) //evitaremos o 0/0 
 { 
 media1=media1/cont; //cálculo da média dos preços antigos 
 media2/=cont; //cálculo da média dos novos preços 
 
 /* 
 Observe as reduções abaixo: 
 soma=soma+numero; -> soma+=numero 
 diferenca=diferenca-numero; -> diferenca-=numero 
 mult=mult*numero -> mult*=numero 
 div=div/numero -> div/=numero 
 Tudo isso é válido e muito útil 
 */ 
 
 //Impressão das Médias: 
 printf("\n\n Média dos Preços Antigos: %.2f",media1); 
 printf("\n\n Média dos Preços Novos: %.2f \n",media2); 
 } 
 return 0; 
} 
 
 
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. 
*/ 
 
#include <stdio.h> 
#include <stdlib.h> 
 
int main() 
{ 
 //declaração de variáveis (n será o número que vai de 1000 a 1999) 
 int n; 
 for(n=1000;n<=1999;n++) //1000<=n<=1999 e n vai aumentando de 1 a cada loop 
 { 
 if(n%11==5) 
 //lembre-se que o resto da divisão é %. Se este for 5 entra no if 
 printf("%d \n",n); //iremos imprimir o numero n específico onde n%11==5 
 } 
 return 0; 
} 
 
 
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. 
*/ 
 
#include <stdio.h> 
#include <stdlib.h> 
 
int main() 
{ 
 /* 
 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 pode 
 ser 1 ou um numero maior que 1. Em todos, S irá valer pelo menos 1 
 */ 
 int n,i; 
 float S=1.0; 
 
 /* 
 Leitura do numero n 
 n deve ser positivo. Pede-se o n uma vez. Se for <= 0, continua pedindo 
 */ 
 do 
 { 
 printf("Informe n positivo: "); 
 scanf("%d",&n); 
 }while(n<=0); 
 
/* 
 1º CASO: n= =1 
 Irei imprimir: S = 1 (cada termo gerado) 
 S = 1 (valor final de S) 
 */ 
 if(n==1) 
 printf("\n S := 1 \n\n S := 1 \n"); 
 
 //2º CASO: explicação no final 
 else 
 { 
 printf("\n S := 1 + "); 
 for(i=2;i<=n;i++) 
 { 
 S+=(float)1/i; 
 if(i!=n) printf("1/%d + ",i); 
 else printf("1/%d",i); 
 } 
 printf("\n\n S := %.2f \n",S); 
 } 
 return 0; 
} 
 
/* 
 
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 
S é float. Para que a divisão 1/i não seja a parte inteira, 
deve-se converter a divisão para float colocando (float) na frente 
Se o i for diferente de n (não é o último termo), imprime 1/i e o sinal + 
Senão (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, com duas casas decimais (escolha arbitrária) 
 
*/ 
 
 
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. 
*/ 
 
#include <stdio.h> 
#include <stdlib.h> 
 
int main() 
{ 
 /* 
 Declaração de Variáveis numero: numero lido 
 i: variável de controle do comando de repetição for 
 cont1: contador de quantos numeros estão no intervalo [10,20] 
 cont2: contados de quantos estão fora 
 */ 
 int numero,i,cont1=0,cont2=0; 
 
 //Código que repetirá os comandos 10X 
 for(i=1;i<=10;i++) //i valerá de 1 a 10 
 { 
 //Leitura do numero 
 printf("Numero: "); 
 scanf("%d",&numero); 
 
 //Teste do intervalo 
 if(numero>=10 && numero<=20) cont1++; 
 //se está no inetrvalo, cont1 recebe +1 
 else cont2++; //senão cont2 recebe +1 
 } 
 
 //Impressão do resultado 
 printf("\n %d numeros estão no intervalo [10,20] e %d numeros estão fora 
\n",cont1,cont2); 
 
 return 0; 
} 
 
 
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). 
*/ 
 
#include <stdio.h> 
#include <stdlib.h> 
 
int main() 
{ 
 /* 
 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 osdivisores 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 
 */ 
 int numero=1,cont=0,soma,i; 
 
 do //Faça uma vez... 
 { 
 soma=0; //resetei a soma para cada numero a ser experimentado 
 
 //i irá correr todos os prováveis divisores de numero exceto ele mesmo 
 for(i=1;i<numero;i++) //não precisa de { }, pois há só um comando, o if 
 
 //se o numero for divisível por i, achamos um divisor 
 if(numero%i==0) soma+=i; //soma dos divisores recebe o divisor i 
 
 //aqui a soma de todos os divisores já foi feita 
 
 if (soma==numero) //se a soma for igual ao numero, achamos um perfeito 
 { 
 printf(" %d ",numero); //impressão do perfeito 
 cont++; //achamos um perfeito 
 } 
 
 numero++; //Vamos verificar o próximo número 
 
 }while(cont<4); 
 
/* 
ATENÇÃO: 
O exercício pediu os 5 primeiros. O correto seria while(cont<5) 
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 
*/ 
 return 0; 
} 
 
 
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! 
*/ 
 
#include <stdio.h> 
#include <stdlib.h> 
 
int main() 
{ 
 /* 
 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 
 */ 
 int N,cont=1,aux=1; 
 float E=1; 
 
 //leitura do numero até ser >0 
 do{ 
 printf("Digite um numero inteiro positivo :"); 
 scanf("%d",&N); 
 }while(N<=0); 
 
 //explicação no final 
 while(cont<=N) 
 { 
 aux*=cont; 
 E+=(float)1/aux; 
 cont++; 
 } 
 
 //imprimindo o valor de E 
 printf("E = %.2f",E); 
 return 0; 
} 
 
/* 
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 em float de 1/1 
cont++ 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 = 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 float 1/6 
cont++ -> cont = 4, saindo do while 
 
*/ 
 
Outras Formas de Solução (Não Comentado): 
 
A) Exercício 34: 
 
#include <stdio.h> 
#include <stdlib.h> 
 
int main( ) 
{ 
 int N,i,result=1; 
 
 do{ 
 printf("Digite un numero inteiro positivo: "); 
 scanf("%d",&N); 
 }while(N<=0); 
 
 for(i=1;i<=N;i++) 
 { 
 result=result*i; 
 } 
 
 printf("O fatorial é %d",result); 
 
 return 0; 
 
} 
 
B) Exercício 50: 
 
#include <stdio.h> 
#include <stdlib.h> 
 
int main() 
{ 
 int N,cont,aux=1; 
 float E=1; 
 
 do{ 
 printf("Digite um numero inteiro positivo :"); 
 scanf("%d",&N); 
 }while(N<=0); 
 
 for(cont=1;cont<=N;cont++) 
 //agrupei o "cont=1", "while(cont<=N)" e cont++" em um único for 
 { 
 aux*=cont; 
 E+=(float)1/aux; 
 } 
 
 printf("E = %.2f",E); 
 return 0; 
}