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

Passo 1

O que o enunciado pede (resumido, com calma):
  • Ler o número total de reabastecimentos n (esse n inclui o enchimento antes de partir e o enchimento imediatamente após retornar).
  • Para cada reabastecimento i=1,2,\ldots,n ler três informações registradas: a leitura do odômetro O_i, a quantidade de gasolina comprada L_i (assuma que encheu o tanque cada vez) e o preço pago P_i.
  • Calcular:
    1. a quilometragem obtida por litro entre cada par de paradas de reabastecimento (ou seja, para cada trecho entre dois enchimentos consecutivos);
    2. a quilometragem obtida por litro em toda a viagem;
    3. o custo do combustível por quilômetro rodado em toda a viagem.
Informações relevantes dadas:
  • n: número total de reabastecimentos (inteiro, com n\ge 2).
  • Para cada i temos O_i, L_i, P_i.
  • O primeiro registro ( i=1) é o enchimento antes de partir; o último ( i=n) é 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 i e o abastecimento i+1, com i=1,2,\ldots,n-1.
  • A distância percorrida nesse trecho é a diferença das leituras do hodômetro:
\text{dist}_i = O_{i+1} - O_i.
Expliquei: O_{i+1} e O_i são as leituras do hodômetro registradas, então a distância rodada é a diferença entre elas. Sempre verifique que O_{i+1}\ge O_i no seu input.
  • A quantidade de gasolina consumida nesse trecho é exatamente o volume que foi comprado no abastecimento i+1 (porque ao parar em i+1 o motorista encheu o tanque; os litros adicionados ali repõem o que foi gasto desde i). Logo:
\text{consumo}_i = L_{i+1}.
Expliquei: quando se enche o tanque em i+1, o combustível colocado corresponde ao que foi consumido desde o abastecimento anterior.
  • Então a quilometragem obtida por litro no trecho i (km por litro) é
\text{kmpl}_i = \frac{\text{dist}_i}{\text{consumo}_i} = \frac{O_{i+1}-O_i}{L_{i+1}}.
Importante: cuide de divisão por zero — normalmente L_{i+1}>0 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:
\text{distância total} = O_n - O_1.â
  • 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 L_i para i=2 até n:
\text{litros totais} = \sum_{i=2}^{n} L_i.
Expliquei com cuidado: cada L_i (para i\ge 2) corresponde ao combustível reposto após o consumo do trecho anterior, então a soma desses L_i dá o total de combustível efetivamente consumido durante toda a viagem. Note que L_1 (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 L_i com i\ge 2.
  • A quilometragem média da viagem (km por litro) é:
\text{kmpl total} = \frac{\text{distância total}}{\text{litros totais}} = \frac{O_n - O_1}{\sum_{i=2}^{n} L_i}.â
  • 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:
\text{custo total} = \sum_{i=2}^{n} P_i.
Expliquei: o pagamento em i\ge 2 corresponde ao combustível que substituiu o gasto do trecho anterior; o pagamento no último abastecimento (em i=n) também faz parte, pois ele repõe o combustível gasto no trecho anterior ao retorno. O pagamento do primeiro abastecimento P_1 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 P_2 até P_n).
  • Finalmente, o custo por quilômetro rodado é:
\text{custo por km} = \frac{\text{custo total}}{\text{distância total}} = \frac{\sum_{i=2}^{n} P_i}{O_n - O_1}.â
Novamente, atenção para divisão por zero se \text{distância total}=0â.

Passo 4

Algoritmo passo-a-passo que vamos implementar no programa em C (traduzido para estruturas e controles de fluxo, bem explicado):
  1. Ler n (inteiro). Verificar n\ge 2. Se não, imprimir mensagem de erro ou encerrar.
  2. Criar vetores (arrays) para armazenar O_i, L_i e P_i para i=1\ldots n. Podemos usar arrays dinâmicos (malloc) ou arrays estáticos com limite maior. Vou usar alocação dinâmica para ser seguro. Use tipo double para O_i, L_i e P_i (assim evitamos perda de precisão ao dividir).
  3. Em um laço de i=1 até n ler os três valores O_i, L_i, P_i. Assuma que a entrada é fornecida em linhas ou separada por espaços — usaremos scanf.
  4. Para cada trecho i=1 até n-1: calcular dist = O[i+1] - O[i] e litros = L[i+1]. Se litros <= 0.0 então tratar como erro (ou mostrar mensagem de “divisão por zero”). Caso contrário calcular kmpl = dist / litros e imprimir.
  5. Calcular dist_total = O[n] - O[1]. Calcular litros_totais = sum(L[i]) para i=2..n. Calcular custo_total = sum(P[i]) para i=2..n. Validar litros_totais > 0 e dist_total > 0.
  6. Calcular kmpl_total = dist_total / litros_totais. Calcular custo_por_km = custo_total / dist_total. Imprimir os valores com formatação adequada (por exemplo, duas casas decimais).
  7. Tratar casos de entrada inválida (odômetro decrescente, L_i \le 0, 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 n=3 com os registros (peguei esses dados fictícios para exemplificar):
  • i=1: O_1=1000{,}0 km, L_1=50{,}0 L, P_1=200{,}00 (unidade monetária).
  • i=2: O_2=1100{,}0 km, L_2=10{,}0 L, P_2=40{,}00.
  • i=3: O_3=1300{,}0 km, L_3=20{,}0 L, P_3=80{,}00.
Cálculos à mão:
  • Trecho 1 (entre 1 e 2): \text{dist}_1 = O_2-O_1 = 1100{,}0-1000{,}0 = 100{,}0 km. \text{consumo}_1 = L_2 = 10{,}0 L. \text{kmpl}_1 = 100{,}0/10{,}0 = 10{,}0 km/L.
  • Trecho 2 (entre 2 e 3): \text{dist}_2 = O_3-O_2 = 1300{,}0-1100{,}0 = 200{,}0 km. \text{consumo}_2 = L_3 = 20{,}0 L. \text{kmpl}_2 = 200{,}0/20{,}0 = 10{,}0 km/L.
  • Distância total: O_3-O_1 = 1300{,}0-1000{,}0 = 300{,}0 km.
  • Litros totais consumidos: L_2+L_3 = 10{,}0+20{,}0 = 30{,}0 L.
  • kmpl total: 300{,}0/30{,}0 = 10{,}0 km/L.
  • Custo total (reposição do combustível consumido): P_2+P_3 = 40{,}00+80{,}00 = 120{,}00.
  • Custo por km: 120{,}00/300{,}0 = 0{,}40 (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 n \ge 2. Se não, terminar com mensagem.
  • Verificar leituras de odômetro não decrescentes: O_{i+1} \ge O_i. Se houver O_{i+1} < O_i, emitir aviso de entrada inválida.
  • Verificar que cada L_i > 0 para i=2\ldots n. Se algum L_i \le 0, evitar divisão e avisar. (Se quiser ser permissivo, trate L_i==0 como “quilometragem impossível” e imprima “inf” ou similar.)
  • Se \text{litros totais} = 0 ou \text{distância total} = 0â, 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 O(n). Memória: armazena três vetores de tamanho n.

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 n.
    • Depois n linhas, cada linha com três números: O_i L_i P_i (separados por espaços).
  • Formato de saída sugerido (exemplo): imprimir, para cada trecho i, 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;
}

Exercícios relacionados