LISTA 01 - GABARITO OFICIAL

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 + S1 < 5 
 
Substituindo os valores de A e S1, temos: 
2 + "noite" < 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; 
 
 //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); 
 
 
 //a variável produto recebe o produto de a por b 
 produto=a*b; 
 
 //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 das Informações 
 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); 
 
 /* 
 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 com duas casas 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 e valor é o valor a pagar 
 */ 
 float Kw,valor;printf("Informe a quantidade de KW consumidos: "); 
 scanf("%f",&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: 
 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 igual a 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) 
 { 
 printf ("O aluno está aprovado.\n"); //caso a condição em if for verdadeira 
 } 
 else 
 { 
 printf ("O aluno está reprovado.\n"); //caso a condição em if for falsa 
 } 
 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 da nota 
 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); 
 
 if(num%2==0) printf("PAR"); //se o resto da divisao por 2 é zero, imprima PAR 
 else printf("ÍMPAR"); //senão imprima Í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) 
 { 
 printf("A metade deste numero eh %d",num/2); //se sim, imprime metade do 
num 
 //Observe que poderíamos criar outra variável conta=num/2 e imprimir ela 
 } 
 else 
 { 
 printf("O numero digitado nao termina com 0"); //se não, imprime a msg 
 } 
 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 1.2 
 */ 
 
 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 
 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"); //comparei como >=0 e <=3 
 
 else if((4<=idade)&&(idade<=10)) printf("Criança \n"); //comparei como >=4 e 
<=10 
 
 else if((10<idade)&&(idade<19)) printf("Adolescente \n"); //comparei como >10 
e <19, que é 11 a 18 
 
 else if((18<idade)&&(idade<51)) printf("Adulto\n"); //19 a 50 
 
 else printf("Idoso \n"); //o quê restou foi 51 ou mais 
 
 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 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 
printf("Classe: 3 Taxa de Registro: R$46.50"); //senão > 1700 (situação 
que restou) 
 
 } 
 
 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ÍCIO26: 
 
/* 
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() 
{ 
 int codigo; //criação da variável a ser utilizada na múltipla escolha 
 
 //Leitura do Código 
 printf("Digite o código do cargo do funcionário: "); 
 scanf("%d", &codigo); 
 
 switch(codigo) //código da múltipla escolha 
 { 
 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; 
 
 // Caso a variável não assuma os valores acima, o DEFAULT é executado. 
 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() 
{ 
 int codigo; //Declaração da variável codigo que será usado na múltipla escolha 
 
 //Leitura do Codigo 
 printf("Informe o código: "); 
 scanf("%d",&codigo); 
 
 switch(codigo){ //múltipla escolha entre 4 casos específicos e um default 
 
 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 codigo= =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: result=a/b; 
 printf("O quociente eh: %.2f",result); 
 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 e pede-se o quociente do maoir pelo menor 
 { 
 //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); //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++; //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){...} 
 
 printf("\n\nMaior: %d\nMenor: %d\n", maior, menor); //impressão do maior 
valor e do 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 negativo e 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); //...econtinuamos 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 
 
 while(chico>=ze) //enquanto chico maior que ze, ambos aumentam e passa 1 ano por 
loop 
 { 
 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)cont/soma; -> (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 
cont 
 { 
 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: 
1 x n = 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 numero,c1=0,c2=0,c3=0,c4=0; 
 
 do{ //faça uma vez... 
 
 //Leia o numero 
 printf("Numero: "); 
 scanf("%d",&numero); 
 
 if(numero>=0) //se o numero não é negativo, faça: 
 { 
 if (numero>=0 && numero<=25) c1++; //intervalo 1 
 
 else if(numero>=26 && numero<=50) c2++; //intervalo 2 
 
 else if(numero>=51 && numero<=75) c3++; //intervalo 3 
 
 else if(numero>=76 && numero<=100) c4++; //intervalo 4 
 } 
 
 }while(numero>=0); //... enquanto numero >= 0 
 
 //Impressão dos resultados 
 printf("\n No intervalo [0,25] tem %d numeros lidos",c1); 
 printf("\n No intervalo [26,50] tem %d numeros lidos",c2); 
 printf("\n No intervalo [51,75] tem %d numeros lidos",c3); 
 printf("\n No intervalo [76,100] tem %d numeros lidos",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 das Médias 
 mediap=(float)somap/contp; //converti a divisão inteira para float 
 mediat=(float)somat/(contp+conti); //idem a anterior. 
 
 //Impressão dos Valores 
 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; 
 
 do //Faça uma vez... 
 { 
 //Leitura do código 
 printf("Codigo: "); 
 scanf("%d",&codigo); 
 
 if(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áluclo 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); 
 
 } 
 
 }while(codigo>=0); //...enquanto codigo >= 0 
 
 /* 
 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 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 
 */ 
 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 divisoresde 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); //até que cont torne-se 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; 
}