Importante

Você está vendo a versão anterior da nova experiência da Alura que estamos preparando para você. Em breve, ela ganha uma identidade visual novinha totalmente pensada em potencializar seus estudos!

1
resposta

Desafio: hora da prática - exercício 5

Eu tive uma certa dificuldade de compreender esta solução:

# Coletamos os preços dos três produtos
p1 = float(input('Digite o preço do primeiro produto: '))
p2 = float(input('Digite o preço do segundo produto: '))
p3 = float(input('Digite o preço do terceiro produto: '))

# Verificamos qual produto é o mais barato usando o operador lógico 'and'
if p1 < p2 and p1 < p3:
    print('O primeiro produto é o mais barato.')
elif p2 < p1 and p2 < p3:
    print('O segundo produto é o mais barato.')
elif p3 < p1 and p3 < p2:
    print('O terceiro produto é o mais barato.')
elif p1 == p2 == p3:
    print('Os produtos possuem o mesmo preço.')
else:
    # Identificamos quais produtos possuem o mesmo preço, se for o caso
    if p1 == p2:
        print('O primeiro e o segundo produtos são os mais baratos.')
    elif p2 == p3:
        print('O segundo e terceiro produtos são os mais baratos.')
    elif p1 == p3:
        print('O primeiro e o terceiro produtos são os mais baratos.')

Porém se desenharmos o fluxo daquele código errado como uma árvore, fica transparente o exato momento em que o galho quebra:

                [Início]
                    |
        (p1 < p2 e p1 < p3?)
                /           \
           Sim /             \ Não
              /                \
[1º é o mais barato]   (p2 < p1 e p2 < p3?)
                         /           \
                    Sim /             \ Não
                       /               \
             [2º é o mais barato]   (p3 < p1 e p3 < p2?)
                                       /           \
                                   Sim /             \ Não
                                     /                \
                           [3º é o mais barato]   (p1 == p2 == p3?)
                                                     /          \
                                                 Sim /            \ Não
                                                   /               \
                                        [Todos são iguais]     [Cai no ELSE]
                                                                    |
                                                              (p1 == p2?)
                                                                /     \
                                                            Sim /       \ Não
                                                              /          ...
                                            [1º e 2º mais baratos]  (ERRO AQUI!)
                                            


                            [Início]
                                 |
                      --- (Menor Único?) ---
                     /           |          \
                   Sim          Sim         Sim
                   /             |            \
              [p1 < ...]    [p2 < ...]    [p3 < ...]
                 /               |              \
           [1º Mais Barato] [2º Mais Barato] [3º Mais Barato]
                                 |
                                Não
                                 |
                     --- (Empate Duplo?) ---
                    /            |          \
                  Sim           Sim         Sim
                  /              |            \
          [p1==p2 e p1<p3]  [p2==p3 e p2<p1]  [p1==p3 e p1<p2]
                /                |                \
        [1º e 2º Menores]  [2º e 3º Menores]  [1º e 3º Menores]
                                 |
                                Não
                                 |
                       [Todos São Iguais]
1 resposta

Olá Esperidião, tudo bem?

Que análise detalhada! Dá pra ver que você foi fundo no raciocínio antes de perguntar, e isso faz toda a diferença no aprendizado.

Você identificou corretamente o ponto fraco do código original: o else final não garante, por si só, que estamos lidando com um empate entre dois produtos mais baratos. Ele apenas cobre "o que sobrou" depois de todas as condições anteriores. Se, por exemplo, p1 = 1, p2 = 2 e p3 = 1, o código entra no else e acaba verificando p1 == p2 (falso), depois p2 == p3 (falso) e por fim p1 == p3 (verdadeiro), o que resulta em "1º e 3º mais baratos". Isso, por sorte, está correto nesse caso. Mas a lógica não é robusta: ela não garante que o par identificado seja realmente o menor, como você percebeu.

Sua árvore revisada resolve exatamente isso, adicionando a condição extra (p1 < p3, p2 < p1, p1 < p2) para confirmar que o par empatado também é o menor dentre os três. Isso é um raciocínio de qualidade.

Uma observação adicional: em casos assim, vale pensar também no uso de min() para deixar o código mais legível. Por exemplo, verificar se p1 == p2 == min(p1, p2, p3) comunica a intenção de forma mais direta, mas a abordagem que você modelou é igualmente correta e mostra domínio real do fluxo de controle.

Conte com a Alura para evoluir seus estudos. Em caso de dúvidas, fico à disposição.

Bons estudos!

Sucesso

Imagem da comunidade