Baixe o app para aproveitar ainda mais
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",¬a); //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",¬a); //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",¬a); //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", ¬a); //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; }
Compartilhar