Um motorista acaba de retornar de um feriado prolongado. Em cada parada de reabastecimento ele registrou a leitura de seu odômetro, a quantidade de gasolina comprada (suponha que ele tenha enchido o tanque cada vez) e o preço pago. Além disso, suponha também que ele tenha enchido o tanque antes de partir e imediatamente após retornar. Escreva um programa em C para ler, em primeiro lugar, o número total de reabastecimentos feitos (incluindo o primeiro e o último) e, a seguir, os dados relativos à compra de gasolina e calcular :
a) a quilometragem obtida por litro de gasolina entre cada par de paradas de reabastecimento;
b) a quilometragem obtida por litro de gasolina em toda a viagem
c) custo do combustível por quilometro rodado em toda a viagem
a) a quilometragem obtida por litro de gasolina entre cada par de paradas de reabastecimento;
b) a quilometragem obtida por litro de gasolina em toda a viagem
c) custo do combustível por quilometro rodado em toda a viagem
Passo 1
O que o enunciado pede (resumido, com calma):
- Ler o número total de reabastecimentos
(esse inclui o enchimento antes de partir e o enchimento imediatamente após retornar). - Para cada reabastecimento
ler três informações registradas: a leitura do odômetro , a quantidade de gasolina comprada (assuma que encheu o tanque cada vez) e o preço pago . - Calcular:
- a quilometragem obtida por litro entre cada par de paradas de reabastecimento (ou seja, para cada trecho entre dois enchimentos consecutivos);
- a quilometragem obtida por litro em toda a viagem;
- o custo do combustível por quilômetro rodado em toda a viagem.
Informações relevantes dadas:
-
: número total de reabastecimentos (inteiro, com ). - Para cada
temos , , . - O primeiro registro (
) é o enchimento antes de partir; o último ( ) é o enchimento logo após retornar.
Observação importante (só identificação do que está no enunciado — sem resolver ainda): os abastecimentos intermediários e o último permitem recuperar quanto combustível foi consumido em cada trecho; essa ideia será usada para montar as fórmulas.
Passo 2
Entendendo como calcular a quilometragem por litro em cada trecho (passo a passo didático):
- Considere o trecho entre o abastecimento
e o abastecimento , com . - A distância percorrida nesse trecho é a diferença das leituras do hodômetro:
Expliquei:
e
são as leituras do hodômetro registradas, então a distância rodada é a diferença entre elas. Sempre verifique que
no seu input.
- A quantidade de gasolina consumida nesse trecho é exatamente o volume que foi comprado no abastecimento
(porque ao parar em o motorista encheu o tanque; os litros adicionados ali repõem o que foi gasto desde ). Logo:
Expliquei: quando se enche o tanque em
, o combustível colocado corresponde ao que foi consumido desde o abastecimento anterior.
- Então a quilometragem obtida por litro no trecho
(km por litro) é
Importante: cuide de divisão por zero — normalmente
porque encheu o tanque, mas cheque no programa.
Passo 3
Cálculos para a viagem inteira (passo a passo, com motivação):
- A distância total percorrida na viagem é a diferença entre a última e a primeira leitura do odômetro:
- O total de litros consumidos durante a viagem é a soma dos litros comprados que repõem o que foi gasto em cada trecho; isto é, some
para até :
Expliquei com cuidado: cada
(para
) corresponde ao combustível reposto após o consumo do trecho anterior, então a soma desses
dá o total de combustível efetivamente consumido durante toda a viagem. Note que
(o enchimento antes de partir) não entra nessa soma porque foi pago antes da viagem e não é a forma direta de contabilizar o combustível consumido — o combustível efetivamente “registrado como gasto” é o que foi repondo (comprado) ao longo da viagem, isto é, os
com
.
- A quilometragem média da viagem (km por litro) é:
- O custo total do combustível referente à viagem (o que foi gasto para repor o combustível consumido) é a soma dos valores pagos nos abastecimentos que repuseram o combustível consumido, ou seja:
Expliquei: o pagamento em
corresponde ao combustível que substituiu o gasto do trecho anterior; o pagamento no último abastecimento (em
) também faz parte, pois ele repõe o combustível gasto no trecho anterior ao retorno. O pagamento do primeiro abastecimento
foi antes da partida e não faz parte da soma porque é a compra inicial (a soma das compras que “repuseram” o consumo é a soma de
até
).
- Finalmente, o custo por quilômetro rodado é:
Novamente, atenção para divisão por zero se
.
Passo 4
Algoritmo passo-a-passo que vamos implementar no programa em C (traduzido para estruturas e controles de fluxo, bem explicado):
- Ler
(inteiro). Verificar . Se não, imprimir mensagem de erro ou encerrar. - Criar vetores (arrays) para armazenar
, e para . Podemos usar arrays dinâmicos (malloc) ou arrays estáticos com limite maior. Vou usar alocação dinâmica para ser seguro. Use tipo doublepara, e (assim evitamos perda de precisão ao dividir). - Em um laço de
até ler os três valores , , . Assuma que a entrada é fornecida em linhas ou separada por espaços — usaremos scanf. - Para cada trecho
até : calcular dist = O[i+1] - O[i]elitros = L[i+1]. Selitros <= 0.0então tratar como erro (ou mostrar mensagem de “divisão por zero”). Caso contrário calcularkmpl = dist / litrose imprimir. - Calcular
dist_total = O[n] - O[1]. Calcularlitros_totais = sum(L[i])parai=2..n. Calcularcusto_total = sum(P[i])parai=2..n. Validarlitros_totais > 0edist_total > 0. - Calcular
kmpl_total = dist_total / litros_totais. Calcularcusto_por_km = custo_total / dist_total. Imprimir os valores com formatação adequada (por exemplo, duas casas decimais). - Tratar casos de entrada inválida (odômetro decrescente,
, distância total zero, etc.), imprimindo mensagens claras.
Explicação de tipos e operações em C: quando dividir dois
double o resultado é double. Sempre use double no cálculo para evitar truncamento inteiro. Para somar em loop use acumuladores double litros_totais = 0.0; e double custo_total = 0.0;.Passo 5
Exemplo numérico curto (para fixar a ideia) e calcular à mão — assim você vê que o programa deve dar o mesmo resultado:
Suponha com os registros (peguei esses dados fictícios para exemplificar):
Suponha
-
: km, L, (unidade monetária). -
: km, L, . -
: km, L, .
Cálculos à mão:
- Trecho 1 (entre 1 e 2):
km. L. km/L. - Trecho 2 (entre 2 e 3):
km. L. km/L. - Distância total:
km. - Litros totais consumidos:
L. - kmpl total:
km/L. - Custo total (reposição do combustível consumido):
. - Custo por km:
(unidade monetária por km).
O programa deve imprimir resultados equivalentes a esses cálculos do exemplo.
Passo 6
Casos especiais e validações que o programa fará (pra você não se enrolar na prova):
- Verificar se
. Se não, terminar com mensagem. - Verificar leituras de odômetro não decrescentes:
. Se houver , emitir aviso de entrada inválida. - Verificar que cada
para . Se algum , evitar divisão e avisar. (Se quiser ser permissivo, trate como “quilometragem impossível” e imprima “inf” ou similar.) - Se
ou , imprimir mensagem adequada (não dividir por zero).
Complexidade: O algoritmo passa uma vez pelos registros para ler e outra vez para somas — tempo linear
. Memória: armazena três vetores de tamanho
.
Passo 7
Formato de entrada/saída sugerido e pequenas dicas para a prova:
- Formato de entrada sugerido (um exemplo de como você pode fornecer os dados ao programa):
- Primeiro um inteiro
. - Depois
linhas, cada linha com três números: (separados por espaços).
- Primeiro um inteiro
- Formato de saída sugerido (exemplo): imprimir, para cada trecho
, uma linha do tipo:
Trecho 1: 10.00 km/l
Trecho 2: 10.00 km/l
Em seguida imprimir:
Quilometragem média: 10.00 km/l
Custo por km: 0.40 - Use
printf("%.2f", valor)para imprimir com duas casas decimais se quiser padronizar. Em prova, se o enunciado pedir formato específico siga-o; se não, duas casas decimais é geralmente aceitável.
Agora vou te entregar o programa em C pronto para compilar e executar. Testa com o exemplo do Passo 5 e confirma que os valores batem. Você consegue! Respira fundo — isso é só um problema estruturado; seguindo esses passos dá certinho.
Resposta
#include <stdio.h>
#include <stdlib.h>
int main(void) {
int n;
if (scanf("%d", &n) != 1) {
fprintf(stderr, "Erro ao ler o numero de reabastecimentos.\n");
return 1;
}
if (n < 2) {
fprintf(stderr, "Numero de reabastecimentos deve ser ao menos 2.\n");
return 1;
}
double *O = malloc(n * sizeof(double));
double *L = malloc(n * sizeof(double));
double *P = malloc(n * sizeof(double));
if (!O || !L || !P) {
fprintf(stderr, "Erro de alocacao de memoria.\n");
return 1;
}
for (int i = 0; i < n; ++i) {
if (scanf("%lf %lf %lf", &O[i], &L[i], &P[i]) != 3) {
fprintf(stderr, "Erro ao ler os dados do abastecimento %d.\n", i+1);
free(O); free(L); free(P);
return 1;
}
}
/* Verificacoes basicas */
for (int i = 0; i < n - 1; ++i) {
if (O[i+1] < O[i]) {
fprintf(stderr, "Leitura de odometro decrescente entre %d e %d.\n", i+1, i+2);
free(O); free(L); free(P);
return 1;
}
}
/* Calcula e imprime quilometragem por litro em cada trecho */
for (int i = 0; i < n - 1; ++i) {
double dist = O[i+1] - O[i];
double litros = L[i+1]; /* litros consumidos no trecho i são os litros comprados no abastecimento i+1 */
if (litros <= 0.0) {
printf("Trecho %d: consumo invalido (litros = %.2f)\n", i+1, litros);
} else {
double kmpl = dist / litros;
printf("Trecho %d: %.2f km/l\n", i+1, kmpl);
}
}
/* Calcula totais */
double dist_total = O[n-1] - O[0];
double litros_totais = 0.0;
double custo_total = 0.0;
for (int i = 1; i < n; ++i) {
litros_totais += L[i]; /* soma L[2]..L[n] (indices 1..n-1 em 0-based) */
custo_total += P[i]; /* soma P[2]..P[n] */
}
if (litros_totais <= 0.0) {
printf("Litros totais invalidos (%.2f). Nao e possivel calcular km/l total.\n", litros_totais);
} else {
double kmpl_total = dist_total / litros_totais;
printf("Quilometragem media: %.2f km/l\n", kmpl_total);
}
if (dist_total <= 0.0) {
printf("Distancia total invalida (%.2f). Nao e possivel calcular custo por km.\n", dist_total);
} else {
double custo_por_km = custo_total / dist_total;
printf("Custo por km: %.2f\n", custo_por_km);
}
free(O);
free(L);
free(P);
return 0;
}