Uma jazida possui uma quantidade estimada de minério disponível para extração. Sabendo a taxa anual de exploração, o engenheiro precisa estimar por quanto tempo a jazida poderá ser explorada.
Desenvolva um programa que calcule a vida útil da jazida em anos e depois converta esse tempo para meses.

Passo 1

O enunciado pede que se desenvolva um programa que calcule a vida útil de uma jazida em anos e depois converta esse tempo para meses. Vou listar claramente o que o problema dá e o que se deve devolver.
  • Dados (entradas) que o programa deve receber:
    • A quantidade estimada de minério disponível para extração — vou chamar de Q. (Unidade por exemplo: toneladas.)
    • A taxa anual de exploração — vou chamar de r. (Unidade por exemplo: toneladas por ano.)
  • O que pedir:
    • Calcular a vida útil da jazida em anos (tempo que o estoque Q dura se se extrai r por ano).
    • Converter esse tempo para meses.
  • Observações importantes que já ficam claras:
    • Se r=0 a vida útil é indefinida (divisão por zero) — o programa precisa tratar esse caso.
    • Se Q=0 a vida útil é 0 anos (não há minério).
    • Pode-se devolver o tempo como número com casas decimais, e/ou como anos inteiros mais meses inteiros restantes — ambos são úteis em provas/prática.

Passo 2

Modelo matemático e fórmula principal — aqui explico a “fórmula” de modo bem didático.
  • Intuição: se tenho Q unidades de minério e extraio r unidades por ano, quantos anos durará?
  • Isso é uma regra de três direta: em cada ano sai r, em t anos sai r\cdot t. Queremos r\cdot t = Q. Assim:
r\cdot t = Q
  • Isolando t (o tempo em anos):
t = \frac{Q}{r}.
Aqui t é a vida útil em anos. Explicando cada símbolo:
  • Q = quantidade total de minério (mesma unidade que r por ano).
  • r = taxa anual de extração (unidade por ano).
  • t = tempo em anos.
  • Conversão para meses: como 1 ano = 12 meses, o tempo em meses m é:
m = 12 \cdot t.

Passo 3

Formato de apresentação do resultado e tratamento de partes fracionárias — como apresentar na prova sem calculadora ou no programa.
  • Resultado contínuo (com casas decimais): basta mostrar t com, por exemplo, duas casas decimais e m com uma casa decimal: t \approx \text{(valor numérico com 2 casas)}é
m \approx 12\cdot t
  • Representação “anos inteiros + meses inteiros”: muitas vezes é mais legível dizer “X anos e Y meses”. Para isso:
    • Calcular A = \lfloor t \rfloor (parte inteira dos anos).
    • Calcular a parte fracionária dos anos \{t\} = t - A.
    • Converter a parte fracionária em meses e arredondar para o inteiro mais próximo:
    M = \operatorname{round}\bigl(12 \cdot \{t\}\bigr).
    • Ajuste especial: se M = 12 após o arredondamento, transforme em A = A+1 e M = 0 (pois 12 meses = 1 ano).
  • Exemplo rápido e concreto (para fixar): suponha Q=120000 (ton) e r=15000 (ton/ano). Então t = \frac{120000}{15000} = 8{,}0\\ \text{anos},
m = 12\cdot 8{,}0 = 96{,}0\\ \text{meses}.
Portanto, isso dá exatamente 8 anos e 0 meses.

Passo 4

Casos especiais e validações que o programa deve fazer (isso evita erro na prova/implementação):
  • Se r \le 0: a taxa de extração não pode ser zero ou negativa — tratar como erro de entrada e avisar o usuário.
  • Se Q < 0: quantidade negativa é inválida — avisar também.
  • Se Q = 0: retornar vida útil 0 anos e 0 meses.
  • Precisão e arredondamento: escolha consistente (por exemplo, mostrar anos com 2 casas decimais e meses totais com 1 casa decimal; e também apresentar a decomposição em anos inteiros + meses inteiros arredondados).
  • Se a prova pedir apenas a fórmula, a resposta é t=\dfrac{Q}{r} anos e m=12t meses — mas num programa convém também mostrar a decomposição em anos e meses inteiros como explicado.

Passo 5

Algoritmo passo a passo (pseudocódigo) para implementar no programa:
  1. Ler Q (quantidade total) como número real.
  2. Ler r (taxa anual) como número real.
  3. Verificar entradas:
    • Se r \le 0: exibir mensagem de erro e terminar.
    • Se Q < 0: exibir mensagem de erro e terminar.
  4. Se Q = 0: exibir vida útil zero e terminar.
  5. Calcular t = Q / r.
  6. Calcular m = 12 \cdot t.
  7. Calcular A = \lfloor t \rfloor.
  8. Calcular M = \operatorname{round}(12 \cdot (t - A)).
  9. Se M = 12: fazer A = A + 1 e M = 0.
  10. Exibir resultados:
    • Vida útil em anos com 2 casas decimais: t.
    • Vida útil em meses (total) com 1 casa decimal: m.
    • Vida útil em formato “A anos e M meses” (inteiros).

Resposta

# Programa: calcula vida útil de uma jazida (anos e meses)
# Entrada: Q = quantidade total de minério (float)
#         r = taxa anual de exploração (float)
# Saída: vida útil em anos (float), meses totais (float) e decomposição em anos inteiros + meses inteiros

def main():
    try:
        Q_str = input("Digite a quantidade total de minério (Q), ex: 120000: ").strip()
        r_str = input("Digite a taxa anual de exploração (r), ex: 15000: ").strip()
        Q = float(Q_str.replace(',', '.'))
        r = float(r_str.replace(',', '.'))
    except Exception:
        print("Entrada inválida. Use números (ex: 120000 ou 15000.0).")
        return

    if r <= 0.0:
        print("Erro: a taxa anual de exploração (r) deve ser maior que zero.")
        return
    if Q < 0.0:
        print("Erro: a quantidade total de minério (Q) não pode ser negativa.")
        return

    # Caso trivial
    if Q == 0.0:
        print("Vida útil: 0,00 anos (0,0 meses). Equivale a 0 anos e 0 meses.")
        return

    # Cálculo principal
    t = Q / r                  # anos (pode ser fracionário)
    m_total = 12.0 * t         # meses (pode ser fracionário)

    # Decomposição em anos inteiros e meses inteiros
    anos_inteiros = int(t)  # para t>=0, int() funciona como floor
    meses_restantes = round((t - anos_inteiros) * 12)

    # Ajuste se o arredondamento resultar em 12 meses
    if meses_restantes == 12:
        anos_inteiros += 1
        meses_restantes = 0

    # Impressão dos resultados
    print()
    print(f"Vida útil (anos, decimal): {t:.2f} anos")
    print(f"Vida útil (meses, total): {m_total:.1f} meses")
    print(f"Equivalente a: {anos_inteiros} anos e {meses_restantes} meses")

if __name__ == "__main__":
    main()

Exercícios relacionados