Considere a tabela com as Classes de Erodibilidade apresentada abaixo:

Classes de Erodibilidade*

Classe de Erodibilidade Índices relativos de Erodibilidade ( \mathrm{i}_{\mathrm{e}} ) Unidade Pedológica
I 8,0 \leq \mathrm{i}_{\mathrm{e}} \leq 10,0
- Cambissolos, solos litólicos
- Solos podzólicos abruptos, textura arenosa/média
- Areias Quartzosas
II 6,0 \leq \mathrm{i}_{\mathrm{e}}<8,0 - Solos podzólicos não abruptos, textura média/argilosa, e textura média
III 4,0 \leq \mathrm{i}_{\mathrm{e}}<6,0 - Solos podzólicos de textura argilosa
IV 2,0 \leq \mathrm{i}_{\mathrm{e}}<4,0
- Latossolos de textura média
- Latossolos de textura argilosa
- Terra Roxa estruturada
V 0,0 \leq \mathrm{i}_{\mathrm{e}} \leq 2,0 - Solos Hidromórficos sem relevo plano
*adaptado de: Gerra, A. J. T. et al (org) “Erosão e Conservação dos Solos”, Bertrand Brasil. p 239.
Desenvolva um programa no qual o usuário digita um número que represente o índice relativo de erodibilidade e sejam realizadas as seguintes operações:
(a) verificar se o valor está entre 0 e 10 , informando ao usuário caso o valor digitado esteja fora dessa faixa;
(b) determinar a classe de erodibilidade, exibindo o número da classe em numerais romanos (ex: Classe II);
(c) perguntar ao usuário se ele quer visualizar as unidades pedológicas correspondentes. Se sim, exibi-las e o programa terminar; caso contrário, o programa deve terminar sem exibir nada.

Passo 1

O que o problema pede:
  • (a) Verificar se o índice relativo de erodibilidade digitado pelo usuário está entre 0 e 10. Se estiver fora dessa faixa, informar o usuário.
  • (b) Determinar a classe de erodibilidade correspondente ao índice e exibir o número da classe em numerais romanos (por exemplo, “Classe II”).
  • (c) Perguntar ao usuário se ele quer visualizar as unidades pedológicas correspondentes; se responder “sim”, exibir essas unidades; se responder “não”, terminar sem exibir mais nada.
Informações relevantes passadas pelo enunciado (retirei estes valores diretamente da tabela fornecida pelo enunciado):
  • Classe I: 8{,}0 \leq i_{e} \leq 10{,}0
  • Classe II: 6{,}0 \leq i_{e} < 8{,}0
  • Classe III: 4{,}0 \leq i_{e} < 6{,}0
  • Classe IV: 2{,}0 \leq i_{e} < 4{,}0
  • Classe V: 0{,}0 \leq i_{e} \leq 2{,}0
Unidades pedológicas correspondentes (também vindo da tabela):
  • Classe I: “Cambissolos, solos litólicos; Solos podzólicos abruptos, textura arenosa/média; Areias Quartzosas”
  • Classe II: “Solos podzólicos não abruptos, textura média/argilosa, e textura média”
  • Classe III: “Solos podzólicos de textura argilosa”
  • Classe IV: “Latossolos de textura média; Latossolos de textura argilosa; Terra Roxa estruturada”
  • Classe V: “Solos Hidromórficos sem relevo plano”

Passo 2

Primeiro passo prático do programa: ler o valor digitado pelo usuário e convertê‑lo para número. Coisas importantes a ensinar:
  • Quando o usuário digita texto, o programa recebe uma string. Para tratar o índice como número precisamos convertê‑la para um tipo numérico (float) para permitir comparações como i_{e} \ge 0.
  • Em Python usamos a função built‑in float() para converter. Como o usuário pode digitar algo inválido (letras, vírgula no lugar do ponto, etc.), devemos envolver a conversão em um bloco try/except para capturar erros de conversão e avisar o usuário.
  • Exemplo didático: se o usuário digitar "7.5", então float("7.5") vira o número 7.5. Se digitar "abc", a conversão lança ValueError e devemos tratar.

Passo 3

Validação do intervalo 0 \leq i_{e} \leq 10:
  • Depois de converter para float, verificamos a condição lógica: o valor está entre 0 e 10 se e somente se ambas as desigualdades são verdadeiras simultaneamente: 0 \leq i_{e} \leq 10.
  • Em código, isso pode ser escrito de forma elegante como 0 <= ie <= 10.
  • Se a condição falhar, imprimimos uma mensagem clara dizendo que o valor está fora da faixa permitida e encerramos (ou podemos pedir reentrada, mas o enunciado só exige informar).
  • Atenção: a entrada pode ter casas decimais; use comparações com <= e < conforme os limites da tabela (por exemplo, o limiar entre Classe II e I é 8{,}0 sendo classe I inclusiva em 8{,}0).

Passo 4

Como determinar a classe a partir de i_{e}:
  • Temos intervalos disjuntos cobrindo todo o intervalo 0 a 10. Vamos testar as faixas de maior para menor (ou vice‑versa) e atribuir a classe assim que a condição for satisfeita.
  • Use as faixas exatamente como dadas:
    • Se 8{,}0 \leq i_{e} \leq 10{,}0 então Classe I.
    • Se 6{,}0 \leq i_{e} < 8{,}0 então Classe II.
    • Se 4{,}0 \leq i_{e} < 6{,}0 então Classe III.
    • Se 2{,}0 \leq i_{e} < 4{,}0 então Classe IV.
    • Se 0{,}0 \leq i_{e} \leq 2{,}0 então Classe V.
  • Em Python isso vira uma sequência de if / elif / else avaliando as condições.
  • Depois de identificar a classe numérica (1 a 5), convertemos para numeral romano usando um pequeno mapeamento:
    • 1 \mapsto “I”, 2 \mapsto “II”, 3 \mapsto “III”, 4 \mapsto “IV”, 5 \mapsto “V”.
  • Exemplo prático: se ie = 7.25, a condição 6 <= ie < 8 é verdadeira, logo é Classe II e imprimimos “Classe II”.

Passo 5

Como exibir a classe formatada exatamente como pedido:
  • O enunciado pede “exibindo o número da classe em numerais romanos (ex: Classe II)”. Então imprima uma linha como:
    • Classe II
  • Mantenha o texto claro e direto. Não mostre o índice novamente a menos que seja útil; foco é mostrar a classe.

Passo 6

Perguntar se o usuário quer ver as unidades pedológicas:
  • Use uma pergunta simples, por exemplo: "Deseja visualizar as unidades pedológicas correspondentes? (s/n): ".
  • Normalize a resposta (ex.: transformar em minúsculas e considerar somente o primeiro caractere) para aceitar variações como "S", "s", "sim", "Sim", "N", "n".
  • Se a resposta começar com "s", mostrar a string das unidades pedológicas correspondentes à classe (veja os textos coletados da tabela no Passo 1).
  • Se começar com "n" ou qualquer outra coisa, não exibir as unidades e terminar (o enunciado exige terminar sem exibir nada nesse caso).

Passo 7

Boas práticas e mensagens amigáveis (didática + tom de incentivo):
  • Sempre informe claramente quando a entrada é inválida: diga o que estava errado (por ex., “Valor fora da faixa 0 10” ou “Entrada inválida, digite um número”).
  • Seja gentil: “Você está indo bem — vamos verificar isso juntos.” (pode incluir mensagem curta amigável).
  • Não trave o programa em erros não tratados; sempre use try/except para evitar crashs que geram ansiedade na hora da prova ou teste.

Passo 8

Exemplos de execução (para reforçar o aprendizado):
  • Entrada: 7.5 → saída: “Classe II” e depois pergunta; se usuário digitar s mostra a unidade pedológica de Classe II.
  • Entrada: 10 → saída: “Classe I” e depois pergunta; se n, termina sem mostrar unidades.
  • Entrada: -1 → saída: mensagem “Valor fora da faixa 0 10”.

Resposta

#!/usr/bin/env python3
# Programa para classificar índice relativo de erodibilidade e opcionalmente mostrar unidades pedológicas

def class_to_roman(n):
    mapping = {1: "I", 2: "II", 3: "III", 4: "IV", 5: "V"}
    return mapping.get(n, "?")

def unidades_pedologicas(classe_num):
    # Textos retirados da tabela fornecida no enunciado
    textos = {
        1: "Cambissolos, solos litólicos; Solos podzólicos abruptos, textura arenosa/média; Areias Quartzosas",
        2: "Solos podzólicos não abruptos, textura média/argilosa, e textura média",
        3: "Solos podzólicos de textura argilosa",
        4: "Latossolos de textura média; Latossolos de textura argilosa; Terra Roxa estruturada",
        5: "Solos Hidromórficos sem relevo plano"
    }
    return textos.get(classe_num, "")

def determinar_classe(ie):
    # Usa as faixas exatamente como na tabela
    if 8.0 <= ie <= 10.0:
        return 1
    elif 6.0 <= ie < 8.0:
        return 2
    elif 4.0 <= ie < 6.0:
        return 3
    elif 2.0 <= ie < 4.0:
        return 4
    elif 0.0 <= ie <= 2.0:
        return 5
    else:
        return None

def main():
    try:
        entrada = input("Digite o índice relativo de erodibilidade (0 a 10): ").strip()
        # Aceitar vírgula como separador decimal é comum em PT-BR;
        # converter vírgula para ponto para permitir entradas como "7,5"
        entrada = entrada.replace(",", ".")
        ie = float(entrada)
    except ValueError:
        print("Entrada inválida: digite um número como, por exemplo, 7.5")
        return

    # Verificação do intervalo [0,10]
    if not (0.0 <= ie <= 10.0):
        print("Valor fora da faixa 0 a 10. Por favor, digite um valor entre 0 e 10.")
        return

    classe_num = determinar_classe(ie)
    if classe_num is None:
        # Isso não deve ocorrer se as faixas cobrirem 0..10 corretamente
        print("Não foi possível determinar a classe para o valor fornecido.")
        return

    roman = class_to_roman(classe_num)
    print(f"Classe {roman}")

    # Perguntar se deseja ver as unidades pedológicas
    resposta = input("Deseja visualizar as unidades pedológicas correspondentes? (s/n): ").strip().lower()
    if resposta.startswith("s"):
        print("\nUnidades pedológicas correspondentes:")
        print(unidades_pedologicas(classe_num))
    # Se não quiser, termina sem mostrar nada (apenas encerra)

if __name__ == "__main__":
    main()

Exercícios relacionados