Buscar

[RESOLUÇÃO] Exercícios de Estruturas de Seleção Encadeada (Programação de Computadores/C)

Prévia do material em texto

Instituto Federal de Santa Catarina – Jaraguá do Sul - RAU 
Rua dos Imigrantes, 445 | Rau | Jaraguá do Sul /SC | CEP: 89254-430 
Fone: (47) 3276-9600 | www.gw.ifsc.edu.br | CNPJ 11.402.887/0005-94 
 Programação de Computadores | 3ª Fase - Engenharia Elétrica | Matheus Willian Sprotte 
 Lista de Exercícios 2 - Estruturas de Seleção Encadeada 
 1. Elabore um programa que calcule a media aritmetica de 3 notas de um aluno. Arredonde 
esta media para uma casa decimal. Em seguida, mostre as mensagens 
- "APROVADO" caso a media seja igual ou superior a 7 
- "EM EXAME" se estiver entre 5 e 7 
- senao mostre a mensagem "REPROVADO" 
 
 Código fonte da resolução: 
 
#include<stdio.h> 
#include<math.h> 
#include<stdlib.h> 
#include<locale.h> 
int main () 
{ 
 setlocale(LC_ALL,"portuguese"); 
 printf("\n*******************************************\n"); 
 printf(" Cálculo da Aprovação do Aluno \n"); 
 printf("*******************************************\n\n"); 
 printf(" Qual a primeira nota dele? -> "); 
 float n1; 
 scanf("%f", & n1); 
 fflush(stdin); 
 printf(" Qual a segunda nota dele? -> "); 
 float n2; 
 scanf("%f", & n2); 
 fflush(stdin); 
 printf(" Qual a terceira nota dele? -> "); 
 float n3; 
 scanf("%f", & n3); 
 fflush(stdin); 
 float m = (n1+n2+n3)/3; 
 if (m >= 7) 
 { 
 printf("\n O aluno está aprovado, com média %.1f.\n", m); 
 printf("\n*******************************************\n\n"); 
 } 
 if (m >= 5 && m<7) 
 { 
 printf("\n O aluno está em exame, com média %.1f.\n", m); 
 printf("\n*******************************************\n\n"); 
 } 
 if (m < 5) 
 { 
 printf("\n O aluno está reprovado, com média %.1f.\n", m); 
 printf("\n*******************************************\n\n"); 
 } 
 system("PAUSE"); 
 return 0; 
} 
 
 2.Considere que em um exame de selecao, foram feitas tres provas: Portugues, Matematica e 
 
Instituto Federal de Santa Catarina – Jaraguá do Sul - RAU 
Rua dos Imigrantes, 445 | Rau | Jaraguá do Sul /SC | CEP: 89254-430 
Fone: (47) 3276-9600 | www.gw.ifsc.edu.br | CNPJ 11.402.887/0005-94 
Conhecimentos Gerais. Para cada candidato tem-se um registro com seu nome e as notas. 
Construa um algoritmo que leia estes dados de entrada e calcule sua media. 
Alem disso, o algoritmo deve exibir uma mensagem contendo: 
Nome, Media, APROVADO/REPROVADO 
A media deve ser arredondada para 1 casa decimal 
A mensagem “APROVADO” sera selecionada caso a media seja igual ou superior a 7,0 e que ele nao 
tenha nenhuma nota abaixo de 5,0. 
Caso contrario o programa deve informar a mensagem “REPROVADO” 
 
 Código fonte da resolução: 
 
#include<stdio.h> 
#include<math.h> 
#include<stdlib.h> 
#include<locale.h> 
int main () 
{ 
 setlocale(LC_ALL,"portuguese"); 
 printf("\n******************************************\n"); 
 printf(" Cálculo do Processo Seletivo \n"); 
 printf("******************************************\n\n"); 
 printf(" Qual a nota do candidato na prova de português? -> "); 
 float npt; 
 scanf("%f",&npt); 
 fflush(stdin); 
 printf(" Qual a nota do candidato na prova matemática? -> "); 
 float nmt; 
 scanf("%f",&nmt); 
 fflush(stdin); 
 printf(" Qual a nota do candidato na prova de conhecimentos gerais? -> "); 
 float ncg; 
 scanf("%f",&ncg); 
 fflush(stdin); 
 float m = (npt + nmt + ncg)/3; 
 if (npt >= 5 && nmt >= 5 && ncg >= 5 && m >= 7) 
 { 
 printf("\n O candidato está APROVADO, com média: %.1f.\n\n", m); 
 printf("******************************************\n\n"); 
 } 
 else 
 { 
 printf("\n O candidato está REPROVADO, com média de %.1f\n\n", m); 
 printf("******************************************\n\n"); 
 } 
 system("PAUSE"); 
 return 0; 
} 
 
 3. Desenvolva um algoritmo que, a partir da altura e do peso de uma pessoa, determine seu 
Indice de Massa Corporal, que e calculado a partir da divisao do peso pelo quadrado da altura. Em 
seguida exiba sua classificacao de acordo com a tabela: 
 
 Código fonte da resolução: 
 
#include<stdio.h> 
 
Instituto Federal de Santa Catarina – Jaraguá do Sul - RAU 
Rua dos Imigrantes, 445 | Rau | Jaraguá do Sul /SC | CEP: 89254-430 
Fone: (47) 3276-9600 | www.gw.ifsc.edu.br | CNPJ 11.402.887/0005-94 
#include<math.h> 
#include<stdlib.h> 
#include<locale.h> 
int main () 
{ 
 setlocale(LC_ALL,"portuguese"); 
 printf("\n***********************************************************\n"); 
 printf(" Calculadora do Índice de Massa Corporal (IMC) \n"); 
 printf("***********************************************************\n\n"); 
 printf(" Qual a altura da pessoa? -> "); 
 float h; scanf("%f", &h); fflush(stdin); 
 printf(" Qual a massa dela? -> "); 
 float m; scanf("%f", &m); fflush(stdin); 
 float imc = m/(h*h); 
 if (imc < 12) { 
 printf(" Inválido.\n"); 
 printf("\n***********************************************************\n\n"); 
 } 
 if (imc >= 12 && imc < 25) { 
 printf(" Está magrinha, com IMC de %.1f.\n", imc); 
 printf("\n***********************************************************\n\n"); 
 } 
 if (imc >= 25 && imc < 30) { 
 printf(" Está regular, com IMC de %.1f.\n", imc); 
 printf("\n***********************************************************\n\n"); 
 } 
 if (imc >= 30 && imc < 35) { 
 printf(" Está gordita, com IMC de %.1f.\n", imc); 
 printf("\n***********************************************************\n\n"); 
 } 
 if (imc >= 35) { 
 printf(" Está GORDASSSAA, com IMC de %.1f.\n", imc); 
 printf("\n***********************************************************\n\n"); 
 } 
 system("PAUSE"); 
 return 0; 
} 
 
 4.Construa um algoritmo/programa para calcular as raizes de uma equacao do 2o grau, sendo 
que os valores dos coeficientes A, B, e C devem ser fornecidos pelo usuario atraves do teclado. 
 
 Código fonte da resolução: 
 
#include<stdio.h> 
#include<math.h> 
#include<stdlib.h> 
#include<locale.h> 
int main () 
{ 
 setlocale(LC_ALL,"portuguese"); 
 printf("\n*******************************************\n"); 
 printf(" Cálculo da Equação Quadrática \n"); 
 printf("*******************************************\n\n"); 
 printf(" Seja uma equação do tipo: ax² + bx + c = 0\n\n"); 
 printf(" Qual o valor de a? -> "); 
 
Instituto Federal de Santa Catarina – Jaraguá do Sul - RAU 
Rua dos Imigrantes, 445 | Rau | Jaraguá do Sul /SC | CEP: 89254-430 
Fone: (47) 3276-9600 | www.gw.ifsc.edu.br | CNPJ 11.402.887/0005-94 
 float a; 
 scanf("%f",&a); 
 fflush(stdin); 
 printf(" Qual o valor de b? -> "); 
 float b; 
 scanf("%f",&b); 
 fflush(stdin); 
 printf(" Qual o valor de c? -> "); 
 float c; 
 scanf("%f",&c); 
 fflush(stdin); 
 float d = pow(b, 2) -(4 * a * c); 
 float x1 = ( -b +sqrt(d)) / (2 * a); 
 float x2 = ( -b -sqrt(d)) / (2 * a); 
 if (d<0) 
 { 
 printf("\n A solução não pentence ao conjunto dos números reais.\n\n"); 
 printf("*******************************************\n\n"); 
 } 
 else 
 { 
 printf("\n Os valores de x que satisfazem a equação são: %.2f e %.2f. O determiante é %.2f.\n\n", x1, 
x2, d); 
 printf("*******************************************\n\n"); 
 } 
 system("PAUSE"); 
 return 0; 
} 
 
 5. Escreva um algoritmo que, para uma conta bancaria, o usuario informe seu saldo. Suponha 
que a seguir o cliente fara um (D)eposito ou um (S)aque (Tipo da Operacao) de um determinado 
valor. Dadas estas informacoes, determine o novo saldo e se este fornegativo, exiba uma 
mensagem.: “SALDO DEVEDOR” 
→ Imprima o saldo sempre com duas casas decimais 
→ Se a operacao nao for nem (S)aque nem (D)eposito, mostrar a msg "Operacao Invalida" 
 
 Código fonte da resolução: 
 
#include<stdio.h> 
#include<math.h> 
#include<stdlib.h> 
#include<locale.h> 
int main () 
{ 
 setlocale(LC_ALL,"portuguese"); 
 printf("\n\t\t***************************************\n"); 
 printf("\t\t* Calculadora da conta bancária *\n"); 
 printf("\t\t***************************************\n\n"); 
 printf("\tQual o saldo do cliente? -> "); 
 float s; 
 scanf("%f", &s); 
 fflush(stdin); 
 printf("\tE qual é o tipo da operação? (digite 'd' para depósito ou 's' para saldo) -> "); 
 char t [2]; 
 scanf("%s", &t); 
 
Instituto Federal de Santa Catarina – Jaraguá do Sul - RAU 
Rua dos Imigrantes, 445 | Rau | Jaraguá do Sul /SC | CEP: 89254-430 
Fone: (47) 3276-9600 | www.gw.ifsc.edu.br | CNPJ 11.402.887/0005-94 
 fflush(stdin); 
 if (strcmp(t,"d")==0) 
 { 
 printf("\tQual é o valor a ser depositado? -> "); 
 float vd; 
 scanf("%f", &vd); 
 fflush(stdin); 
 float sd = s + vd; 
 if (sd > 0) 
 { 
 printf("\tO novo saldo é: %.2f.\n\n", sd); 
 } 
 else 
 { 
 printf("\tO novo saldo é: %.2f.\n\n", sd); 
 printf("\tSALDO DEVEDOR.\n\n"); 
 } 
 } 
 else if (strcmp(t,"s")==0) 
 { 
 printf("\tQual é o valor a ser saqueado? -> "); 
 float vs; 
 scanf("%f", &vs); 
 fflush(stdin); 
 float ss = s - vs; 
 if (ss > 0) 
 { 
 printf("\tO novo saldo é: %.2f.\n\n", ss); 
 } 
 else 
 { 
 printf("\tO novo saldo é: %.2f.\n", ss); 
 printf("\tSALDO DEVEDOR.\n\n"); 
 } 
 } 
 else 
 { 
 printf("\tOperação inválida!\n\n"); 
 } 
 system("PAUSE"); 
 return 0; 
} 
 
 6. Uma empresa do ramo financeiro deseja saber se um determinado cliente possui limite 
disponivel para um determinado emprestimo. O cliente deve informar sua renda liquida, o valor 
do emprestimo e o numero de parcelas. Considere uma taxa de juros de 2.5% a.m. O software 
deve calcular o valor de cada parcela com base na seguinte formula: 
Val. Parcela=Val . Solicitado∗ 
(1+Taxa)Num. Parcelas 
Num.Parcelas 
O emprestimo so sera aceito se o valor da parcela for inferior a 30% do Salario Liquido. 
O programa devera mostrar na saida o Valor Maximo da Parcela, o Valor Calculado da Parcela e 
a mensagem Emprestimo Liberado ou Margem Insuficiente 
 
 Código fonte da resolução: 
 
Instituto Federal de Santa Catarina – Jaraguá do Sul - RAU 
Rua dos Imigrantes, 445 | Rau | Jaraguá do Sul /SC | CEP: 89254-430 
Fone: (47) 3276-9600 | www.gw.ifsc.edu.br | CNPJ 11.402.887/0005-94 
 
#include<stdio.h> 
#include<math.h> 
#include<stdlib.h> 
#include<locale.h> 
int main () 
{ 
 setlocale(LC_ALL,"portuguese"); 
 printf("\n\t\t**********************************0*\n"); 
 printf("\t\t* Calculadora do Empréstimo *\n"); 
 printf("\t\t***********************************\n\n"); 
 printf("\tQual é a renda líquida do cliente? -> "); 
 float rl; 
 scanf("%f", &rl); 
 fflush(stdin); 
 printf("\tQual é o valpor do empréstimo? -> "); 
 float ve; 
 scanf("%f", &ve); 
 fflush(stdin); 
 printf("\tE qual é o número de parcelas (a.m.)? -> "); 
 float np; 
 scanf("%f", &np); 
 fflush(stdin); 
 float vpc = 0.3*rl; 
 float vp = ve*pow(1 + 0.025, np)/np; 
 if(vpc >= vp ) 
 { 
 printf("\n\tO valor máximo da parcela é: R$%.2f.", vpc); 
 printf("\n\tO valor da parcela é R$%.2f.", vp); 
 printf("\n\tEmpréstimo liberado!\n\n"); 
 } 
 if(vpc < vp ) 
 { 
 printf("\n\tO valor máximo da parcela é: R$%.2f.", vpc); 
 printf("\n\tO valor da parcela é R$%.2f.", vp); 
 printf("\n\tMargem insuficiente!\n\n"); 
 } 
 system("PAUSE"); 
 return 0; 
} 
 
 7. Crie um algoritmo que leia dois numeros e determine se estes sao multiplos entre si. 
* Um numero A e multiplo de um numero B quando o resto da divisao de A por B for zero 
** Um numero B e multiplo de um numero A quando o resto da divisao de B por A for zero 
 
 Código fonte da resolução: 
 
#include<stdio.h> 
#include<math.h> 
#include<stdlib.h> 
#include<locale.h> 
int main () 
{ 
 setlocale(LC_ALL,"portuguese"); 
 printf("\n\t\t********************************\n"); 
 
Instituto Federal de Santa Catarina – Jaraguá do Sul - RAU 
Rua dos Imigrantes, 445 | Rau | Jaraguá do Sul /SC | CEP: 89254-430 
Fone: (47) 3276-9600 | www.gw.ifsc.edu.br | CNPJ 11.402.887/0005-94 
 printf("\t\t* Verificador de Múltiplos *\n"); 
 printf("\t\t********************************\n\n"); 
 printf("\tDigite um número qualquer: -> "); 
 int a; 
 scanf("%d", &a); 
 fflush(stdin); 
 printf("\tDigite outro número: -> "); 
 int b; 
 scanf("%d", &b); 
 fflush(stdin); 
 int r = a % b; 
 int ri = b % a; 
 if (r == 0 || ri == 0) 
 { 
 printf("\n\tOs números são múltiplos entre si.\n\n"); 
 } 
 else 
 { 
 printf("\n\tOs números não são múltiplos entre si.\n\n"); 
 } 
 system("PAUSE"); 
 return 0; 
} 
 
 8. Desenvolva um algoritmo que leia um ano de nascimento e retorne true se este ano foi 
bissexto ou false caso contrario. 
* Um ano bissexto ocorre de quatro em quatro anos. 
** Exceto anos multiplos de 100 que nao sao multiplos de 400 
 
 Código fonte da resolução: 
 
#include<stdio.h> 
#include<math.h> 
#include<stdlib.h> 
#include<locale.h> 
int main() 
{ 
 setlocale(LC_ALL,"portuguese"); 
 printf("\n\t\t********************************\n"); 
 printf("\t\t* Verificador de Múltiplos *\n"); 
 printf("\t\t********************************\n\n"); 
 printf("\tDigite algum ano: "); 
 int ano; 
 scanf("%d", &ano); 
 fflush(stdin); 
 if(ano % 4 == 0 && (ano % 400 == 0 || ano % 100 != 0)) 
 { 
 printf("\n\tO ano é bissexto\n\n"); 
 } 
 else 
 { 
 printf("\n\tO ano não é bissexto\n\n"); 
 } 
 system("PAUSE"); 
 return 0; 
 
Instituto Federal de Santa Catarina – Jaraguá do Sul - RAU 
Rua dos Imigrantes, 445 | Rau | Jaraguá do Sul /SC | CEP: 89254-430 
Fone: (47) 3276-9600 | www.gw.ifsc.edu.br | CNPJ 11.402.887/0005-94 
} 
 
 9. Crie um algoritmo/programa que leia a idade de uma pessoa e informe a sua classe eleitoral: 
→ nao eleitor (abaixo de 16 anos); 
→ eleitor obrigatorio (entre a faixa de 18 e menor de 65 anos); 
→ eleitor facultativo (16 ou 17 anos ou maior de 65 anos, inclusive). 
 
 Código fonte da resolução: 
 
#include<stdio.h> 
#include<math.h> 
#include<stdlib.h> 
#include<locale.h> 
int main () 
{ 
 setlocale(LC_ALL,"portuguese"); 
 printf("\n\t\t**************************************\n"); 
 printf("\t\t* Definidor da Classe Eleitoral *\n"); 
 printf("\t\t**************************************\n\n"); 
 printf("\tQual a idade do sujeito? -> "); 
 int idade; 
 scanf("%d", &idade); 
 fflush(stdin); 
 if (idade < 16) 
 { 
 printf("\tNão eleitor.\n\n"); 
 } 
 if (idade >= 16 && idade <18 || idade >65 ) 
 { 
 printf("\tEleitor facultativo.\n\n"); 
 } 
 if (idade>=18 && idade <=65) 
 { 
 printf("\tEleitor obrigatório.\n\n"); 
 } 
 system("PAUSE"); 
 return 0; 
} 
 
 10. Ler os valores correspondentes aos lados de um triangulo e: 
→ Verificar se o triangulo e valido ou nao (Invalido): 
* para ser valido a soma de dois quaisquer deve ser maior que o outro lado 
 
 Código fonte da resolução: 
 
#include<stdio.h> 
#include<math.h> 
#include<stdlib.h>#include<locale.h> 
int main() 
{ 
 setlocale(LC_ALL,"portuguese"); 
 printf("\n\t**********************************\n"); 
 printf("\t* Verificador de triângulo *\n"); 
 printf("\t**********************************\n\n"); 
 
Instituto Federal de Santa Catarina – Jaraguá do Sul - RAU 
Rua dos Imigrantes, 445 | Rau | Jaraguá do Sul /SC | CEP: 89254-430 
Fone: (47) 3276-9600 | www.gw.ifsc.edu.br | CNPJ 11.402.887/0005-94 
 printf("\tDigite o valor da aresta do triângulo: ->"); 
 int a; 
 scanf("%d", &a); 
 fflush(stdin); 
 printf("\tDigite o valor outra aresta do triângulo: ->"); 
 int b; 
 scanf("%d", &b); 
 fflush(stdin); 
 printf("\tDigite o valor da última aresta do triângulo: "); 
 int c; 
 scanf("%d", &c); 
 fflush(stdin); 
 if (a + b > c && a + c > b && b + c > a) 
 { 
 printf("\n\tÉ um triângulo.\n\n"); 
 } 
 else 
 { 
 printf("\n\tNão é um triângulo.\n\n"); 
 } 
 system("PAUSE"); 
 return 0; 
} 
 
 11. Crie um algoritmo que peca o nome, a altura e o peso de duas pessoas e apresente o nome 
da mais leve e o nome da mais alta. 
 
 Código fonte da resolução: 
 
#include<stdio.h> 
#include<math.h> 
#include<stdlib.h> 
#include<locale.h> 
int main () 
{ 
 setlocale(LC_ALL,"portuguese"); 
 printf("\n\t\t***********************************************\n"); 
 printf("\t\t* Analizador de Peso e Altura das Pessoas *\n"); 
 printf("\t\t***********************************************\n\n"); 
 printf("\tQual o nome do indivíduo? -> "); 
 char nome1 [20]; 
 gets(nome1);//scanf("%s", &nome); 
 fflush(stdin); 
 printf("\tQual o peso? -> "); 
 int p1; 
 scanf("%d", &p1); 
 fflush(stdin); 
 printf("\tQual é a altura? -> "); 
 float h1; 
 scanf("%f", &h1); 
 fflush(stdin); 
 printf("\tQual o nome da outra pessoa? -> "); 
 char nome2 [20]; 
 gets(nome2);//scanf("%s", &nome); 
 fflush(stdin); 
 
Instituto Federal de Santa Catarina – Jaraguá do Sul - RAU 
Rua dos Imigrantes, 445 | Rau | Jaraguá do Sul /SC | CEP: 89254-430 
Fone: (47) 3276-9600 | www.gw.ifsc.edu.br | CNPJ 11.402.887/0005-94 
 printf("\tQual o peso desta? -> "); 
 int p2; 
 scanf("%d", &p2); 
 fflush(stdin); 
 printf("\tQual é a altura? -> "); 
 float h2; 
 scanf("%f", &h2); 
 fflush(stdin); 
 if (h1 > h2) 
 { 
 printf("\n\tA pessoa mais alta é %s.", nome1); 
 } 
 if (h2 > h1) 
 { 
 printf("\n\tA pessoa mais alta é %s.", nome2); 
 } 
 if (p1 > p2) 
 { 
 printf("\n\tA pessoa mais leve é %s.\n\n", nome2); 
 } 
 if (p2 > p1) 
 { 
 printf("\n\tA pessoa mais leve é %s.\n\n", nome1); 
 } 
 system("PAUSE"); 
 return 0; 
} 
 
 12. Criar um algoritmo/programa que a partir da idade e peso do paciente calcule a dosagem 
de determinado medicamento em gotas. Considere que o medicamento em questao possui 500 mg 
por ml, e que cada ml corresponde a 20 gotas. 
→ E necessario converter a dosagem em miligramas para gotas. 
• Adultos ou adolescentes desde 12 anos, inclusive, se tiverem peso igual ou acima de 60 
quilos devem tomar 1000 mg; com peso abaixo de 60 quilos devem tomar 875 mg. 
• Para criancas e adolescentes abaixo de 12 anos a dosagem e calculada pelo peso corporeo 
conforme a tabela a seguir: 
◦ 5 a 9Kg 125mg 
◦ > 9 a 16Kg 250mg 
◦ > 16 a 24 Kg 375mg 
◦ > 24 a 30Kg 500mg 
◦ > 30Kg 750mg 
 
 Código fonte da resolução: 
 
#include<stdio.h> 
#include<math.h> 
#include<stdlib.h> 
#include<locale.h> 
int main () 
{ 
 setlocale(LC_ALL,"portuguese"); 
 printf("\n\t\t*****************************************\n"); 
 printf("\t\t* Cálculo da Dosagem do Medicamento *\n"); 
 printf("\t\t*****************************************\n\n"); 
 printf("\tQual a idade do paciente? -> "); 
 
Instituto Federal de Santa Catarina – Jaraguá do Sul - RAU 
Rua dos Imigrantes, 445 | Rau | Jaraguá do Sul /SC | CEP: 89254-430 
Fone: (47) 3276-9600 | www.gw.ifsc.edu.br | CNPJ 11.402.887/0005-94 
 int i; 
 scanf("%d", &i); 
 fflush(stdin); 
 printf("\tQual o 'peso' (em kg) do paciente? -> "); 
 int p; 
 scanf("%d", &p); 
 fflush(stdin); 
 if (i > 12 && p > 60) 
 { 
 printf("\n\tA dosagem adequada é 40 gotas.\n\n"); 
 } 
 if (i > 12 && p < 60) 
 { 
 printf("\n\tA dosagem adequada é 35 gotas.\n\n"); 
 } 
 if (i < 12 && 5 < p && p < 9) 
 { 
 printf("\n\tA dosagem adequada é 5 gotas.\n\n"); 
 } 
 if (i < 12 && 9 < p && p<16) 
 { 
 printf("\n\tA dosagem adequada é 10 gotas.\n\n"); 
 } 
 if (i < 12 && 16 < p && p <24) 
 { 
 printf("\n\tA dosagem adequada é 15 gotas.\n\n"); 
 } 
 if (i < 12 && 24 < p && p <30) 
 { 
 printf("\n\tA dosagem adequada é 20 gotas.\n\n"); 
 } 
 if (i < 12 && p > 30) 
 { 
 printf("\n\tA dosagem adequada é 30 gotas.\n\n"); 
 } 
 system("PAUSE"); 
 return 0; 
} 
 
 13. Elabore um algoritmo que receba tres valores de entrada e imprima-os em ordem crescente 
 
 Código fonte da resolução: 
 
#include<stdio.h> 
#include<math.h> 
#include<stdlib.h> 
#include<locale.h> 
int main () 
{ 
 setlocale(LC_ALL,"portuguese"); 
 printf("\n\t******************************\n"); 
 printf("\t* Ordenador de Números *\n"); 
 printf("\t******************************\n\n"); 
 printf("\tDigite um número: "); 
 int a; 
 
Instituto Federal de Santa Catarina – Jaraguá do Sul - RAU 
Rua dos Imigrantes, 445 | Rau | Jaraguá do Sul /SC | CEP: 89254-430 
Fone: (47) 3276-9600 | www.gw.ifsc.edu.br | CNPJ 11.402.887/0005-94 
 scanf("%d", &a); 
 fflush(stdin); 
 printf("\tDigite outro número: "); 
 int b; 
 scanf("%d", &b); 
 fflush(stdin); 
 printf("\tDigite mais um número: "); 
 int c; 
 scanf("%d", &c); 
 fflush(stdin); 
 if (a>b && b>c) 
 { 
 printf("\n\tA ordem cresente entre eles é %d %d %d.\n\n", c, b, a); 
 } 
 if (b>c && c>a) 
 { 
 printf("\n\tA ordem cresente entre eles é %d %d %d.\n\n", a, c, b); 
 } 
 if (c>a && a>b) 
 { 
 printf("\n\tA ordem cresente entre eles é %d %d %d.\n\n", b, a, c); 
 } 
 if (c>b && b>a) 
 { 
 printf("\n\tA ordem cresente entre eles é %d %d %d.\n\n", a, b, c); 
 } 
 if (a>c && c>b) 
 { 
 printf("\n\tA ordem cresente entre eles é %d %d %d.\n\n", b, c, a); 
 } 
 if (b>a && a>c) 
 { 
 printf("\n\tA ordem cresente entre eles é %d %d %d.\n\n", c, a, b); 
 } 
 system("PAUSE"); 
 return 0; 
} 
 
 14. Ler os lados de um triangulo e se ele for válido determinar o tipo: 
- equilatero.: possui todos os lados iguais 
- isosceles.: possui 2 lados iguais e outro diferente 
- escaleno.: possui todos os lados diferentes 
 
 Código fonte da resolução: 
 
#include<stdio.h> 
#include<math.h> 
#include<stdlib.h> 
#include<locale.h> 
int main() 
{ 
 setlocale(LC_ALL,"portuguese"); 
 printf("\n\t******************************************\n"); 
 printf("\t* Verificador do Tipo do Triângulo *\n"); 
 printf("\t******************************************\n\n"); 
 
Instituto Federal de Santa Catarina – Jaraguá do Sul - RAU 
Rua dos Imigrantes, 445 | Rau | Jaraguá do Sul /SC | CEP: 89254-430 
Fone: (47) 3276-9600 | www.gw.ifsc.edu.br | CNPJ 11.402.887/0005-94 
 printf("\tDigite o valor da aresta do triângulo: -> "); 
 int a; 
 scanf("%d", &a); 
 fflush(stdin); 
 printf("\tDigite o valor outra aresta do triângulo: -> "); 
 int b; 
 scanf("%d", &b); 
 fflush(stdin); 
 printf("\tDigite o valor da última aresta do triângulo: -> "); 
 int c; 
 scanf("%d", &c); 
 fflush(stdin);if (a + b < c || a + c < b || b + c < a) 
 { 
 printf("\n\tNão é um triângulo.\n\n"); 
 } 
 else 
 { 
 if (a == b && c == a && b == c) 
 { 
 printf("\n\tÉ um triângulo equilátero.\n\n"); 
 } 
 else if (a == b || b == c || c==a) 
 { 
 printf("\n\tÉ um triângulo isóceles.\n\n"); 
 } 
 else 
 { 
 printf("\n\tÉ um triângulo escaleno.\n\n"); 
 } 
 } 
 system("PAUSE"); 
 return 0; 
} 
 
 15. Ler os angulos internos de um triangulo, verificar se ele é válido e classificá-lo como: 
Acutangulo.: todos os angulos internos sao menores que 90o 
Retangulo.: possui um angulo interno de exatamente 90o 
Obtusangulo.: possui um angulo interno maior que 90o 
* Um triangulo e valido quando a soma dos seus angulos internos for igual a 180o 
 
 Código fonte da resolução: 
 
#include<stdio.h> 
#include<math.h> 
#include<stdlib.h> 
#include<locale.h> 
int main() 
{ 
 setlocale(LC_ALL,"portuguese"); 
 printf("\n\t**************************************************************\n"); 
 printf("\t* Verificador do Tipo do Triângulo Pelos seus Ângulos *\n"); 
 printf("\t**************************************************************\n\n"); 
 printf("\tDigite o valor de algum ângulo do triângulo: -> "); 
 int a; 
 
Instituto Federal de Santa Catarina – Jaraguá do Sul - RAU 
Rua dos Imigrantes, 445 | Rau | Jaraguá do Sul /SC | CEP: 89254-430 
Fone: (47) 3276-9600 | www.gw.ifsc.edu.br | CNPJ 11.402.887/0005-94 
 scanf("%d", &a); 
 fflush(stdin); 
 printf("\tDigite o valor de outro ângulo desse triângulo: -> "); 
 int b; 
 scanf("%d", &b); 
 fflush(stdin); 
 printf("\tDigite o valor do último ângulo dele: -> "); 
 int c; 
 scanf("%d", &c); 
 fflush(stdin); 
 if (a + b + c > 180 || a + b + c < 180) 
 { 
 printf("\n\tNão é um triângulo.\n\n"); 
 } 
 else 
 { 
 if (a < 90 && b < 90 && c < 90) 
 { 
 printf("\n\tÉ um triângulo acutângulo\n\n"); 
 } 
 else if (a == 90 || b == 90 || c == 90) 
 { 
 printf("\n\tÉ um triângulo retângulo.\n\n"); 
 } 
 else 
 { 
 printf("\n\tÉ um triângulo obtusângulo.\n\n"); 
 } 
 } 
 system("PAUSE"); 
 return 0; 
} 
 
 16.Elabore um programa em linguagem C que contenha duas funcoes: 
a) que converta um angulo de graus para radianos ('R') 
b) que converta um angulo de radianos para graus ('G') 
Para converter radianos para graus, divida o valor encontrado por π e multiplique por 180, ou seja: 
graus=180. radianos/π 
* no programa principal, leia o valor de um angulo e tambem que tipo de conversao deseja fazer. 
Em seguida faca a conversao conforme o tipo solicitado. 
Se a opcao informada pelo usuario nao for 'R' nem 'G' mostrar "Opcao Invalida" 
 
 Código fonte da resolução: 
 
#include<stdio.h> 
#include<math.h> 
#include<stdlib.h> 
#include<locale.h> 
int main() 
{ 
 setlocale(LC_ALL,"portuguese"); 
 printf("\n\t******************************************************************\n"); 
 printf("\t* Conversor de Ângulos (grau p/radiano ou radiano p/grau) *\n"); 
 printf("\t******************************************************************\n\n"); 
 printf("\tDigite 'g' para coverter grau ou 'r' para converter radiano: -> "); 
 
Instituto Federal de Santa Catarina – Jaraguá do Sul - RAU 
Rua dos Imigrantes, 445 | Rau | Jaraguá do Sul /SC | CEP: 89254-430 
Fone: (47) 3276-9600 | www.gw.ifsc.edu.br | CNPJ 11.402.887/0005-94 
 char v [2]; 
 scanf("%s", &v); 
 fflush(stdin); 
 if (strcmp(v,"g")==0) 
 { 
 printf("\tQual o valor que desejas conerter para radianos? -> "); 
 float deg; 
 scanf("%f", &deg); 
 fflush(stdin); 
 float vrad = deg / 57.295780; 
 printf("\n\tEste valor equivale a %.6f radianos.\n\n", vrad); 
 } 
 else if (strcmp(v,"r")==0) 
 { 
 printf("\tQual o valor que desejas conerter para graus? -> "); 
 float rad; 
 scanf("%f", &rad); 
 fflush(stdin); 
 float vdeg = rad * 57.295780; 
 printf("\n\tEste valor equivale a %.6f graus.\n\n", vdeg); 
 } 
 else 
 { 
 printf("\n\tNão digitastes 'g' ou 'd', presta atenção.\n\n"); 
 } 
 system("PAUSE"); 
 return 0; 
} 
 
 17. Ler os lados de um triangulo e classifica-los como: 
Acutangulo.: todos os angulos internos sao menores que 90o 
Retangulo.: possui um angulo interno de exatamente 90o 
Obtusangulo.: possui um angulo interno maior que 90o 
 
 Código fonte da resolução: 
 
#include<stdio.h> 
#include<math.h> 
#include<stdlib.h> 
#include<locale.h> 
int main() 
{ 
 setlocale(LC_ALL,"portuguese"); 
 printf("\n\t*****************************************************************\n"); 
 printf("\t* Definição do Tipo do Triângulo a Partir dos Seus Lados *\n"); 
 printf("\t*****************************************************************\n\n"); 
 printf("\n\tDigite um lado do triângulo: -> "); 
 float a; 
 scanf("%f", &a); 
 fflush(stdin); 
 printf("\tDigite outro lado do triângulo: -> "); 
 float b; 
 scanf("%f", &b); 
 fflush(stdin); 
 printf("\tDigite o último lado do triângulo: -> "); 
 
Instituto Federal de Santa Catarina – Jaraguá do Sul - RAU 
Rua dos Imigrantes, 445 | Rau | Jaraguá do Sul /SC | CEP: 89254-430 
Fone: (47) 3276-9600 | www.gw.ifsc.edu.br | CNPJ 11.402.887/0005-94 
 float c; 
 scanf("%f", &c); 
 fflush(stdin); 
 float aga = acos((a*a - b*b - c*c)/(-2*b*c)); 
 float agda = aga * 57.295780; 
 printf("\n\tO ângulo a é %.2f graus.", agda); 
 float agb = acos((b*b - a*a - c*c)/(-2*a*c)); 
 float agdb = agb * 57.295780; 
 printf("\n\tO ângulo b é %.2f graus.", agdb); 
 float agc = acos((c*c - b*b - a*a)/(-2*b*a)); 
 float agdc = agc * 57.295780; 
 printf("\n\tO ângulo c é %.2f graus.", agdc); 
 if (agda + agdb + agdc > 180.001 || agda + agdb + agdc < 179.999) 
 { 
 printf("\n\tNão é um triângulo.\n\n"); 
 } 
 else 
 { 
 if (agda < 90 && agdb < 90 && agdc < 90) 
 { 
 printf("\n\n\tÉ um triângulo acutângulo\n\n"); 
 } 
 else if (agda == 90 || agdb == 90 || agdc == 90) 
 { 
 printf("\n\n\tÉ um triângulo retângulo.\n\n"); 
 } 
 else 
 { 
 printf("\n\n\tÉ um triângulo obtusângulo.\n\n"); 
 } 
 } 
 system("PAUSE"); 
 return 0; 
} 
 
 18. Crie um algoritmo que leia o dia e mes de nascimento de alguem. Em seguida, passe estes 
valores para uma funcao que determine/mostre a estacao do ano em que a pessoa nasceu com 
base na tabela. 
 
 Código fonte da resolução: 
 
#include<stdio.h> 
#include<math.h> 
#include<stdlib.h> 
#include<locale.h> 
int main() 
{ 
 setlocale(LC_ALL,"portuguese"); 
 printf("\n\t**********************************************************\n"); 
 printf("\t* Cálculo da Estação do Ano na Data de Nascimento *\n"); 
 printf("\t**********************************************************\n\n"); 
 printf("\n\tQual o número do dia de nascimento? -> "); 
 int d; 
 scanf("%d", &d); 
 fflush(stdin); 
 
Instituto Federal de Santa Catarina – Jaraguá do Sul - RAU 
Rua dos Imigrantes, 445 | Rau | Jaraguá do Sul /SC | CEP: 89254-430 
Fone: (47) 3276-9600 | www.gw.ifsc.edu.br | CNPJ 11.402.887/0005-94 
 printf("\n\tQual o número do mês? -> "); 
 int m; 
 scanf("%d", &m); 
 fflush(stdin); 
 if (d > 20 && m == 12 || d < 20 && m == 3 || m < 3 ) 
 { 
 printf("\n\tNasceu no verão!\n\n"); 
 } 
 else if (d > 19 && m == 3 || m > 3 && m < 6 || d < 21 && m == 6){ 
 printf("\n\tNasceu no outono.\n\n"); 
 } 
 else if (d < 23 && m == 9 || m > 5 && m < 9 || d > 20 && m == 6) 
 { 
 printf("\n\tNasceu no inverno.\n\n"); 
 } 
 else if (d > 22 && m == 9 || m > 9 && m < 12 || d < 21 && m == 12) 
 { 
 printf("\n\tNasceu na primavera.\n\n"); 
 } 
 system("PAUSE"); 
 return 0; 
} 
 
 19. Faca um programa que leia o salario bruto e do numero de dependentes de um 
colaborador, calcule o salario liquido descontando o INSS e IRPF. O calculo funciona assim: 
- primeiro calcula-se o INSS de acordo com a tabela a seguir 
- porem, existe um valor máximo a ser pago que não pode ultrapassar a última faixa 
portanto, se o salario for superior a ultima faixa da tabela, considere 11% de 5.189,82 
- em seguida calculamos a deducao de R$ 189,59 para cada dependente 
- a base de calculo do IRPF sera o salario bruto descontado do INSS e da deducao por 
dependentes 
- com a base de calculo, calculamos o valor do IRPF multiplicando a base de calculo pelo 
percentual e depois descontando a parcela a deduzir, como base a tabela. 
 
 Código fonte da resolução: 
 
#include<stdio.h> 
#include<math.h> 
#include<stdlib.h> 
#include<locale.h> 
int main() 
{ 
 setlocale(LC_ALL,"portuguese"); 
 printf("\n\t*************************************\n"); 
 printf("\t* Cálculo do Salário Líquido *\n"); 
 printf("\t*************************************\n\n"); 
 printf("\n\tQual o salário bruto? -> "); 
 float sbt; 
 scanf("%f", &sbt); 
 fflush(stdin); 
 printf("\tQual é o número de dependentes? -> "); 
 float ndp; 
 scanf("%f", &ndp); 
 fflush(stdin); 
 
Instituto Federal de Santa Catarina – Jaraguá do Sul - RAU 
Rua dos Imigrantes, 445 | Rau | Jaraguá do Sul /SC | CEP: 89254-430 
Fone: (47) 3276-9600 | www.gw.ifsc.edu.br | CNPJ 11.402.887/0005-94 
 float inss; 
 float slqd; 
 float irpf; 
 if (sbt < 1556.94 ) 
 { 
 inss = sbt * 0.08; 
 printf("\n\tINSS: R$%.2f.", inss); 
 } 
 if (sbt > 1556.95 && sbt < 2594.92) 
 { 
 inss = sbt * 0.09; 
 printf("\n\tINSS: R$%.2f", inss); 
 } 
 if (sbt > 2594.93 && sbt < 5189.82) 
 { 
 inss = sbt * 0.11; 
 printf("\n\tINSS: R$%.2f", inss); 
 } 
 if (sbt > 5189.82) 
 { 
 inss = 570.88; 
 printf("\n\tINSS: R$%.2f.", inss); 
 } 
 float sbs = sbt - inss - (189.59 * ndp); 
 printf ("\n\tSalário base para o IRPF: R$%.2f", sbs); 
 if (sbs < 1903.98) 
 { 
 slqd = sbt - inss; 
 printf("\n\tIRPF: R$00,00\n"); 
 printf("\tO sálario liquido é R$%.2f.\n\n", slqd); 
 } 
 else if (sbs > 1903.99 && sbs < 2826.65) 
 { 
 irpf = sbs*0.075 - 142.80; 
 slqd = sbt - inss - irpf; 
 printf("\n\tIRPF: R$%.2f.", irpf); 
 printf("\n\tO salário líquido é R$%.2f.\n\n", slqd); 
 } 
 else if (sbs > 2826.66 && sbs < 3751.05) 
 { 
 irpf = sbs*0.11 - 354.80; 
 slqd = sbt - inss - irpf; 
 printf("\n\tIRPF: R$%.2f.", irpf); 
 printf("\n\tO salário líquido é R$%.2f.\n\n", slqd); 
 } 
 else if (sbs > 3751.06 && sbs > 4664.68) 
 { 
 irpf = sbs*0.225 - 636.13; 
 slqd = sbt - inss - irpf; 
 printf("\n\tIRPF: R$%.2f.", irpf); 
 printf("\n\tO salário líquido é R$%.2f.\n\n", slqd); 
 } 
 else if (sbs > 4664.68) 
 { 
 irpf = (sbs * 0.275) - 869.36; 
 
Instituto Federal de Santa Catarina – Jaraguá do Sul - RAU 
Rua dos Imigrantes, 445 | Rau | Jaraguá do Sul /SC | CEP: 89254-430 
Fone: (47) 3276-9600 | www.gw.ifsc.edu.br | CNPJ 11.402.887/0005-94 
 slqd = sbt - (inss + irpf); 
 printf("\n\tIRPF: R$%.2f.", irpf); 
 printf("\n\tO salário líquido é R$%.2f.\n\n", slqd); 
 } 
 system("PAUSE"); 
 return 0; 
} 
 
 20. Tux e seus amigos foram jogar boliche no Boliche do Duke. Para calcular a pontuacao de 
um jogador, Duke usa algumas regras doidas. 
No Boliche do Duke ha 12 pinos. 
Quando sao derrubados todos os pinos na primeira jogada a pontuacao e de 30 pontos. 
Quando sao derrubados uma quantidade impar de pinos na primeira jogada, deve-se multiplicar 
o numero de pinos derrubados por 2 para acumular na pontuacao. 
Quando sao derrubados uma quantidade par de pinos na primeira jogada, deve-se multiplicar o 
numero de pinos por 1,5. 
Como nao foram derrubados todos os pinos, o jogador arremessa novamente. 
Caso derrube todos os pinos restantes, recebe 2 pontos por pino e um bonus de 5 pontos. 
Se restarem pinos na segunda tentativa, recebe apenas 1 ponto por pino derrubado. 
Faca um programa que solicite ao usuario o numero de pinos derrubados na primeira jogada e, se 
necessario, na segunda jogada, calcule e retorne a pontuacao total de um jogador apos o(s) 
arremesso(s). 
 
 Código fonte da resolução: 
 
#include<stdio.h> 
#include<math.h> 
#include<stdlib.h> 
#include<locale.h> 
int main() 
{ 
 setlocale(LC_ALL,"portuguese"); 
 printf("\n\t***************************************\n"); 
 printf("\t* Pontuação no Boliche do Duke *\n"); 
 printf("\t***************************************\n\n"); 
 printf("\n\tQuantos pinos foram derrubados na primeira jogada? -> "); 
 int np1; 
 scanf("%d", &np1); 
 fflush(stdin); 
 if (np1 == 12) 
 { 
 printf("\n\tPontuação: 30 pontos.\n\n"); 
 } 
 else if (np1 % 2 == 0) 
 { 
 float pt1 = np1*1.5; 
 printf("\tQuantos pinos foram derrubados na segunda rodada? -> "); 
 int np2; 
 scanf("%d", &np2); 
 fflush(stdin); 
 if (12 - np1 == np2) 
 { 
 int pt2 = np2*2 + 5; 
 float ptt = pt1 + pt2; 
 printf("\n\tA pontuação total é %.0f.\n\n", ptt); 
 
Instituto Federal de Santa Catarina – Jaraguá do Sul - RAU 
Rua dos Imigrantes, 445 | Rau | Jaraguá do Sul /SC | CEP: 89254-430 
Fone: (47) 3276-9600 | www.gw.ifsc.edu.br | CNPJ 11.402.887/0005-94 
 } 
 else 
 { 
 int pt2 = np2; 
 float ptt = pt1 + pt2; 
 printf("\n\tA pontuação total é %.0f.\n\n", ptt); 
 } 
 } 
 else 
 { 
 float pt1 = np1*2; 
 printf("\tQuantos pinos foram derrubados na segunda rodada? -> "); 
 int np2; 
 scanf("%d", &np2); 
 fflush(stdin); 
 if (12 - np1 == np2) 
 { 
 int pt2 = np2*2 + 5; 
 float ptt = pt1 + pt2; 
 printf("\n\tA pontuação total é %.0f.\n\n", ptt); 
 } 
 else 
 { 
 int pt2 = np2; 
 float ptt = pt1 + pt2; 
 printf("\n\tA pontuação total é %.0f.\n\n", ptt); 
 } 
 
 } 
 system("PAUSE"); 
 return 0; 
}

Outros materiais

Materiais relacionados

Perguntas relacionadas

Perguntas Recentes