Elaborar um programa Python para calcular as raízes da equação do segundo grau. Seu programa deverá perguntar ao usuário se deseja fazer outro cálculo e só terminará quando o usuário responder que não deseja continuar calcular as raízes de outras equações. Lembrando que, as raízes complexas também serão impressas.

Passo 1

O enunciado pede que eu elabore um programa em Python que:
  • Pergunte ao usuário os coeficientes da equação do segundo grau (ou seja, os valores de a, b e c).
  • Calcule as raízes da equação e as imprima — lembrando que raízes complexas também devem ser mostradas.
  • Pergunte ao usuário se ele deseja fazer outro cálculo e só termine quando o usuário responder que não deseja continuar.
Informações relevantes fornecidas pelo enunciado:
  • Precisamos lidar com equações do tipo ax^2 + bx + c = 0, com a, b, c informados pelo usuário.
  • Devemos mostrar raízes reais e complexas.
  • Deve existir um loop que repete o processo até o usuário dizer que não quer continuar.

Passo 2

Vamos entender a fórmula que realmente usamos para calcular as raízes. Para uma equação ax^2 + bx + c = 0 (com a \neq 0), definimos o discriminante \Delta como
\Delta = b^{2} - 4ac.
As raízes são dadas pela fórmula de Bhaskara:
x = \frac{-b \pm \sqrt{\Delta}}{2a}.
Explicando cada símbolo:
  • a, b, c são os coeficientes informados pelo usuário.
  • \Delta indica a “natureza” das raízes:
    • Se \Delta > 0: duas raízes reais distintas.
    • Se \Delta = 0: uma raiz real dupla (raiz repetida).
    • Se \Delta < 0: duas raízes complexas conjugadas (por isso precisamos lidar com números complexos).

Passo 3

Como tratar \sqrt{\Delta} quando \Delta < 0? Em Python, o módulo padrão para radiciação retorna erro para raiz de número negativo se usarmos apenas floats. Para simplificar, usamos o módulo que já trabalha com números complexos: o módulo cmath. Com cmath.sqrt(\Delta) obtemos corretamente a raiz quadrada, seja \Delta positivo, zero ou negativo — e o resultado será do tipo complexo quando necessário.

Passo 4

Devemos também considerar o caso em que o usuário, por engano, informa a = 0. Nesse caso:
  • Se a = 0 e b \neq 0: a equação não é quadrática, é linear bx + c = 0 e a solução é x = -\frac{c}{b}.
  • Se a = 0, b = 0 e c = 0: qualquer x é solução (infinitas soluções).
  • Se a = 0, b = 0 e c \neq 0: não existe solução (contradição c = 0 é falsa).
É importante deixar claro isso para que o programa trate bem entradas inesperadas.

Passo 5

Estrutura do programa (em palavras, passo a passo):
  1. Abrir um loop principal que só termina quando o usuário responder que não quer continuar.
  2. Pedir a, b e c ao usuário. Converter para número (usar float para permitir termos decimais).
  3. Tratar o caso a = 0 (ver Passo 4).
  4. Para a \neq 0:
    • Calcular \Delta = b^{2} - 4ac.
    • Calcular \sqrt{\Delta} com cmath.sqrt.
    • Calcular x_1 e x_2 por x_{1} = \frac{-b + \sqrt{\Delta}}{2a},\qquad x_{2} = \frac{-b - \sqrt{\Delta}}{2a}.
    • Imprimir as raízes. Se a parte imaginária for praticamente zero (por exemplo, muito próxima de zero por erro numérico), podemos imprimir só a parte real para ficar mais legível.
  5. Perguntar ao usuário se deseja repetir. Aceitar respostas como ‘s’, ‘sim’, ‘n’, ‘não’ (tratando maiúsculas/minúsculas). Repetir a pergunta até receber uma resposta válida.

Passo 6

Boas práticas de entrada/saída:
  • Envolver a conversão em try/except para capturar entradas inválidas (por exemplo, o usuário digitou “abc” em vez de um número).
  • Usar mensagens informativas ao imprimir o resultado, por exemplo: “Raízes: x1 = …, x2 = …”.
  • Quando as raízes forem complexas, imprimir no formato Python (ex.: (1+2j)) ou formatar para (1 + 2i) se preferir; aqui usaremos o formato padrão de complexos do Python (com j).

Passo 7

Exemplos numéricos para fixar:
  • Se o usuário der a=1, b=-3, c=2, então \Delta = (-3)^2 - 4\cdot1\cdot2 = 9 - 8 = 1. As raízes serão x = \frac{3 \pm 1}{2} \Rightarrow x_{1}=2,\; x_{2}=1.
  • Se der a=1, b=2, c=1, então \Delta = 4 - 4 = 0 e a raiz dupla é x = -1.
  • Se der a=1, b=0, c=1, então \Delta = -4 < 0 e as raízes são complexas: x = \frac{0 \pm \sqrt{-4}}{2} = \pm i.
  • Se der a=0, b=2, c=-4, trataremos como linear e a raiz será x = 2.
Esses exemplos ajudam a conferir se o programa está funcionando.

Passo 8

Dicas finais para a prova (rápido e prático):
  • Memorize a expressão do discriminante \Delta = b^{2}-4ac e a fórmula de Bhaskara.
  • Se precisar programar no exame, lembre-se de usar cmath para raízes de \Delta<0.
  • Sempre verifique a=0 antes de aplicar a fórmula quadrática.
Vai dar certo — respira, faz um exercício de cada vez e treina alguns exemplos parecidos com os do Passo 7 para fixar.

Resposta

import cmath

def calcular_raizes():
    while True:
        # Leitura dos coeficientes
        try:
            a = float(input("Coeficiente a: ").strip())
            b = float(input("Coeficiente b: ").strip())
            c = float(input("Coeficiente c: ").strip())
        except ValueError:
            print("Entrada inválida. Por favor, digite números (ex.: 1, 2.5, -3).")
            continue

        # Caso a == 0: tratar como linear ou casos degenerados
        if a == 0.0:
            if b == 0.0:
                if c == 0.0:
                    print("Infinitas soluções (equação 0 = 0).")
                else:
                    print("Sem solução (equação inconsistente).")
            else:
                x = -c / b
                print(f"Equação linear. Raiz: x = {x}")
        else:
            # Calcula discriminante e raízes usando cmath para suportar complexos
            delta = b * b - 4 * a * c
            raiz_delta = cmath.sqrt(delta)
            x1 = (-b + raiz_delta) / (2 * a)
            x2 = (-b - raiz_delta) / (2 * a)

            # Se a parte imaginária for numericamente quase zero, mostrar só a parte real
            def limpa_complex(z):
                if abs(z.imag) < 1e-12:
                    return z.real
                return z

            x1_print = limpa_complex(x1)
            x2_print = limpa_complex(x2)

            print(f"Raízes: x1 = {x1_print}, x2 = {x2_print}")

        # Pergunta ao usuário se deseja continuar
        while True:
            resp = input("Deseja calcular outra equação? (s/n): ").strip().lower()
            if resp in ("s", "sim"):
                break  # volta ao início do loop principal
            if resp in ("n", "nao", "não", "nao"):
                print("Encerrando o programa. Até mais!")
                return
            print("Resposta inválida. Digite 's' para sim ou 'n' para não.")

if __name__ == "__main__":
    calcular_raizes()

Exercícios relacionados