lista03(com respostas)

Prévia do material em texto

Universidade Tecnológica Federal do Paraná
Departamento Acadêmico de Informática
IF61C – Fundamentos de Programação 1 (2013-2)
Prof. Bogdan Tomoyuki Nassu
Lista de Exercícios – Aula 3
(*) 1. Escreva um programa que use a estrutura condicional para mostrar qual entre 3 números inteiros
dados é o maior. Os números devem ser informados uma única vez, e armazenados em variáveis.
(*) 2. Escreva um programa que receba uma temperatura em graus Celsius e a apresente convertida
para graus Fahrenheit. A fórmula de conversão é: F = (9 x C + 160) / 5, sendo F a temperatura em
Fahrenheit e C a temperatura em Celsius.
(*) 3. Escreva um programa que recebe 2 números distintos n1 e n2, e diz se n1 é divisível por n2, se
n2 é divisível por n1, ou se nenhum dos dois casos ocorre.
(**) 4. Escreva um programa que receba o ano de nascimento de uma pessoa e mostre a sua idade ao
final do ano atual. O programa também deve indicar se a pessoa terá ou não idade para votar e para
ter carteira de habilitação.
(**) 5. Escreva um programa que receba a velocidade máxima em uma avenida e a velocidade com
que um motorista estava dirigindo nela. Calcule a multa que o motorista vai receber, considerando que
são pagos 5 reais por cada km/h que estiver acima da velocidade permitida (considere apenas
números inteiros). Se a velocidade do motorista estiver dentro do limite, o programa deve informar que
não há multa.
(**) 6. Escreva um programa que atribua um número entre 0 e 999 a uma variável e o imprima
invertido, na ordem UDC (Unidade Dezena Centena). (Exemplo: se a entrada é 123, a saída é 321).
Atenção: os dígitos não devem ser informados separadamente.
(**) 7. Considere o código abaixo:
#include <stdio.h>
int main ()
{
 int n1, n2, n3, aux;
 if (n2 >= n3)
 {
 aux = n2;
 n2 = n3;
 n3 = aux;
 }
 if (n1 >= n2)
 {
 aux = n1;
 n1 = n2;
 n2 = aux;
 if (n2 >= n3)
 {
 aux = n2;
 n2 = n3;
 n3 = aux;
 }
 }
 printf ("%d %d %d\n", n1, n2, n3);
 return (0);
}
Sem executar o programa, responda:
a) Qual será a saída se atribuirmos no início os valores 1, 2 e 3 a n1, n2 e n3, respectivamente?
b) Qual será a saída se atribuirmos no início os valores 20, 10 e 30 a n1, n2 e n3, respectivamente?
c) Qual será a saída se atribuirmos no início os valores 5*5, n1/2 e n2+1 a n1, n2 e n3,
respectivamente?
d) (****) O que o programa faz, exatamente? Explique o funcionamento do algoritmo.
(***) 8. Suponha que você está programando um módulo contador de cédulas para caixas eletrônicos.
Escreva um programa que informa com quantas cédulas de Real podemos representar um dado valor.
Exemplo de resposta: R$ 218 = 2 cédulas de 100, 1 cédula de 10, 1 cédula de 5, 1 cédula de 2 e 1
cédula de 1. Considere que existem cédulas de 1, 2, 5, 10, 20, 50 e 100 Reais. Procure minimizar o
número de cédulas usadas. Desconsidere valores com centavos, e suponha que a máquina sempre
tem disponíveis as cédulas necessárias.
(***) 9. Ainda considerando o seu trabalho com caixas eletrônicos, você deve escrever um programa
que recebe um número de conta-corrente com três dígitos e mostra o seu dígito verificador. O dígito
verificador é calculado da seguinte forma (utilizando o número 235 como exemplo):
- Some o número da conta com seu inverso. Exemplo: 235 + 532 = 767 (o algoritmo para realizar esta
inversão foi criado em outro exercício).
- A soma anterior for maior ou igual a 1000, desconsidere o milhar.
- Separe os 3 dígitos do número resultante, multiplicando a centena por 1, a dezena por 2, e a unidade
por 3. Some os 3 valores. Exemplo: 7 (posição 1), 6 (posição 2) e 7 (posição 3): (7 x 1) + (6 x 2) + (7 x
3) = 7 + 12 + 21 = 40.
- O último dígito desse resultado é o dígito verificador da conta. Exemplo: 0.
(***) 10. A Companhia de Táxi Tabajara (CTT) é uma das maiores empresas de transporte do país.
Possui uma vasta frota de carros e opera em todas as grandes cidades. Recentemente a CTT
modernizou a sua frota, adquirindo um lote de 500 carros bicombustíveis (carros que podem utilizar
como combustível tanto álcool quanto gasolina). Além do maior conforto para os passageiros e o
menor gasto com manutenção, com os novos carros é possível uma redução adicional de custo: como
o preço da gasolina está sujeito a variações muito bruscas, pode ser vantagem, em certos momentos,
utilizar álcool como combustível. Entretanto, os carros possuem um melhor desempenho utilizando
gasolina, ou seja, em geral, um carro percorre mais quilômetros por litro de gasolina do que por litro de
álcool.
Escreva um programa que recebe o preço do litro de álcool, o preço do litro de gasolina e os
quilômetros por litro que um carro bicombustível realiza com cada um desses combustíveis. O
programa deve informar se é mais econômico abastecer os carros da CTT com álcool ou com
gasolina. No caso de não haver diferença de custo entre abastecer com álcool ou gasolina, a CTT
prefere utilizar gasolina.
Universidade Tecnológica Federal do Paraná
Departamento Acadêmico de Informática
IF61C – Fundamentos de Programação 1 (2013-2)
Prof. Bogdan Tomoyuki Nassu
Lista de Exercícios - Aula 3 - Respostas
1. Vou dar aqui 2 soluções. Note como elas são até certo ponto análogas às
soluções dadas para o problema das pepitas de ouro na 1a lista.
/* Solução 1: compara 2 valores, faz uma segunda comparação dependendo do 
 resultado da primeira comparação. */
#include <stdio.h>
int main ()
{
 int n1 = 10;
 int n2 = 15;
 int n3 = 13;
 if (n1 > n2)
 {
 if (n1 > n3)
 printf ("%d\n", n1);
 else
 printf ("%d\n", n3);
 }
 else
 {
 if (n2 > n3)
 printf ("%d\n", n2);
 else
 printf ("%d\n", n3);
 }
 return (0);
}
/* Solução 2: guarda em uma variável n1, e compara esta variável com n2, e 
 depois com n3. Esta solução é estruturalmente mais simples, e é mais parecida
 com a solução para o problema mais geral, que teria um número arbitrário de
 valores. */
#include <stdio.h>
int main ()
{
 int n1 = 10;
 int n2 = 15;
 int n3 = 13;
 int maior;
 maior = n1;
 if (n2 > maior)
 maior = n2;
 if (n3 > maior)
 maior = n3;
 printf ("%d\n", maior);
 return (0);
}
2.
/* O programa é minúsculo, e a fórmula é usada diretamente. */
#include <stdio.h>
int main ()
{
 double c = 10;
 printf ("%.2f\n", (9*c + 160)/5);
 return (0);
}
3.
/* Uso bem direto da estrutura condicional. */
#include <stdio.h>
int main ()
{
 int n1 = 9, n2 = 3;
 if (n1 % n2 == 0)
 printf ("%d eh divisivel por %d.\n", n1, n2);
 else if (n2 % n1 == 0)
 printf ("%d eh divisivel por %d.\n", n2, n1);
 else
 printf ("Nenhum eh divisivel pelo outro.");
 return (0);
}
4.
#include <stdio.h>
main ()
{
 int ano_nascimento = 1980;
 int ano_atual = 2013;
 int idade;
 /* Calcula e mostra a idade ao final do ano atual. */
 idade = ano_atual – ano_nascimento;
 printf ("Idade ao fim do ano atual: %d\n", idade);
 /* Vota a partir dos 16 anos. */
 if (idade >= 16)
 printf ("Podera votar.\n");
 else
 printf ("Nao podera votar.\n");
 /* Dirige a partir dos 18. */
 if (idade >= 18)
 printf ("Podera ter habilitacao.\n");
 else
 printf ("Nao podera ter habilitacao.\n");
}
5.
#include <stdio.h>
int main ()
{
 int velocidade_maxima = 60;
 int velocidade_motorista = 70;
 /* A conta para o valor da multa é simples. Se você teve dificuldades para
 chegar a esta conta, procure ajuda: sem ter um bom domínio de matemática 
 básica, você terá problemas para programar.*/if (velocidade_motorista > velocidade_maxima)
 printf ("Multa: R$ %d\n", (velocidade_motorista - velocidade_maxima)*5);
 else
 printf ("Sem multa.\n");
 return (0);
}
6.
/* Como sabemos que são 3 dígitos, podemos usar a mesma estratégia que já 
 tínhamos usado para separar um número de segundos em horas, minutos e
 segundos – aqui, separamos as unidades em centenas, dezenas e unidades. Repare
 também que o problema não exige o uso da estrutura condicional! */
#include <stdio.h>
int main ()
{
 int n = 456;
 int c, d, u;
 c = n/100; /* Centenas = quociente da divisão por 100. */
 d = (n%100)/10; /* Dezenas = o resto da divisão por 100 dividido por 10. */
 u = (n%10); /* Unidades = o que não for divisível por 10. */
 printf ("%d\n", c + d*10 + u*100); /* Imprimimos na ordem contrária. */
 return (0);
}
7.
a) 1 2 3
b) 10 20 30
c) 12 13 25
d) O programa reordena n1, n2 e n3 de forma que eles estejam sempre em ordem
crescente. A lógica deste algoritmo é bem “elegante”, e funciona com trocas. O
primeiro if garante que n2 terá valor menor ou igual a n3. O segundo if compara
n1 com este valor. Se n1 <= n2, sabemos que n2 <= n3, portanto n1 <= n3 e os
valores já estão ordenados. Do contrário, trocamos os valores de n1 e n2,
garantindo que o primeiro valor é o menor de todos. Precisamos então comparar
novamente n2 com n3, para verificar se o valor que originalmente estava em n1 e
agora está em n2 é maior que o valor em n3. Para enxergar o funcionamento do
algoritmo, use os valores 1, 2 e 3, em todas as ordens possíveis (são 6 casos).
8.
/* Problema clássico, e muito parecido com aquele das horas. A maior diferença
 aqui é que precisamos quebrar o número inicial em muitos sub-pedaços, então
 fazer todo o cálculo para cada tipo de nota em uma única linha é um pouco
 inconveniente. Em vez disso, podemos ir subtraindo o dinheiro que já "temos"
 do valor total - este é o processo que muita gente usa mentalmente quando faz
 este tipo de coisa na vida real. A solução genérica para um número arbitrário
 de sub-pedaços com pesos variados seria mais complexa, e exigiria uma
 estrutura de dados mais sofisticada, que ainda não vimos. */
#include <stdio.h>
int main ()
{
 int n = 123;
 int n100, n50, n20, n10, n5, n2, n1;
 n100 = n / 100;
 n = n - (n100 * 100);
 n50 = n / 50;
 n = n - (n50 * 50);
 n20 = n / 20;
 n = n - (n20 * 20);
 n10 = n / 10;
 n = n - (n10 * 10);
 n5 = n / 5;
 n = n - (n5 * 5);
 n2 = n / 2;
 n = n - (n2 * 2);
 n1 = n;
 /* Note que eu posso pular uma linha depois da string sem problemas. */
 printf ("100: %d\n50: %d\n20: %d\n10: %d\n5: %d\n2: %d\n1: %d\n",
 n100, n50, n20, n10, n5, n2, n1);
 return (0);
}
9.
#include <stdio.h>
int main ()
{
 int n = 235; /* O número da conta. */
 int n_invertido; /* O número da conta, com os caracteres invertidos. */
 int centenas, dezenas, unidades; /* Nomes mais mnemônicos que c, d e u. */
 int soma_n_n_invertido;
 int final;
 int digito_verificador;
 /* Inverte o n. */
 centenas = n/100;
 dezenas = (n%100)/10;
 unidades = n%10;
 n_invertido = centenas + dezenas*10 + unidades*100;
 /* Soma n com o n invertido. */
 soma_n_n_invertido = n + n_invertido;
 /* Separa de novo os dígitos. Se o resultado for > 999, desconsidera
 o milhar.*/
 soma_n_n_invertido = soma_n_n_invertido % 1000;
 centenas = soma_n_n_invertido/100;
 dezenas = (soma_n_n_invertido %100)/10;
 unidades = soma_n_n_invertido%10;
 /* Multiplica pela ordem posicional e soma tudo. Note que não precisamos
 realmente multiplicar a centena por 1, porque esta multiplicação não 
 teria efeito! */
 final = centenas + (dezenas*2) + (unidades*3);
 /* Pegamos o último dígito. */
 digito_verificador = final % 10;
 printf ("%d\n", digito_verificador);
 return (0);
}
10.
/* O algoritmo para este exercício é MUITO mais simples do que o enunciado
 faz parecer. Apesar de isso parecer um "golpe baixo", este tipo de situação é
 extremamente comum - os problemas reais sempre envolvem reflexão sobre o que
 é relevante e o que faz parte da solução do problema. Acostume-se com 
 enunciados, especificações e descrições com bastante texto: eles acompanharão
 você para sempre. */
#include <stdio.h>
main ()
{
 float preco_a = 1.899; /* reais/litro */
 float preco_g = 2.699; /* reais/litro */
 float rendimento_a = 8; /* km/litro */
 float rendimento_g = 11; /* km/litro */
 float reais_por_km_alcool = preco_a / rendimento_a; /* reais/km */
 float reais_por_km_gasolina = preco_g / rendimento_g; /* reais/km */
 if (reais_por_km_alcool < reais_por_km_gasolina)
 printf ("Melhor usar alcool.\n");
 else
 printf ("Melhor usar gasolina.\n");
}