Given a quadratic equation in the form ax² + bx + c, (Only the values of a, b and c are provided). We have to find its roots. If the equation has real roots, then print floor value of each root in decreasing order, If the roots are imaginary print Imaginary.

Examples:

Input: a = 1, b = -2, c = 1
Output: [ 1, 1]
Explanation: For a = 1, b = -2, c = 1, the discriminant is 0, so the quadratic equation has one repeated real root: x =−b²a=1 x = \frac{-b}{2a} = 1.
Input : a = 1, b = 7, c = 12
Output: [ -3, -4]
Explanation: For a = 1, b = 7, c = 12, the discriminant is 49 - 48 = 1, so the roots are real and distinct: so the roots are -3 and -4.
Input : a = 1, b = 1, c = 1
Output : Roots are Imaginary
Explanation: For input a = 1, b = 1, c = 1, the discriminant D=b²−4ac=1−4(1)(1)=−3D = b² - 4ac = 1 - 4(1)(1) = -3, which is negative, so the roots are imaginary (no real roots).

Try It Yourself

The roots could be found using the below formula (It is known as the formula of Sridharacharya)

x=\frac{-b\pm \sqrt{b^2-4ac}}{2a}

The values of the roots depends on the term (b² - 4ac) which is known as the discriminant (D).

If D > 0:
=> This occurs when b² > 4ac.
=> The roots are real and unequal.
=> The roots are {-b + (b² - 4ac)}/2a and {-b - (b² - 4ac)}/2a.
If D = 0:
=> This occurs when b² = 4ac.
=> The roots are real and equal.
=> The roots are (-b/2a).
If D < 0:
=> This occurs when b² < 4ac.
=> The roots are imaginary and unequal.
=> The discriminant can be written as (-1 * -D).
=> As D is negative, -D will be positive.
=> The roots are {-b ± ?(-1*-D)} / 2a = {-b ± i?(-D)} / 2a = {-b ± i?-(b² - 4ac)}/2a where i = ?-1.

Use the following pseudo algorithm to find the roots of the

Pseudo algorithm:

Start
Read the values of a, b, c
If a == 0
Print "imaginary" // Not a quadratic equation
Exit'
Compute d = b² - 4ac // Discriminant
If d > 0
root1 = floor((-b + √d) / (2a))
root2 = floor((-b - √d) / (2a))
Print root1 and root2 in decreasing order
Else If d == 0
root1 = root2 = floor(-b / (2a))
Print root1 and root2
Else
Print "imaginary" // Complex roots
End

Below is the implementation of the above formula.

C++

#include <iostream>
#include <cmath>    
#include <algorithm> 

using namespace std;

void findRoots(int a, int b, int c)
{
    // If a is zero, it's not 
    // a quadratic equation
    if (a == 0) {
        cout << "imaginary";
        return;
    }

    // Calculate discriminant D = b^2 - 4ac
    int D = b * b - 4 * a * c;

    // If discriminant is negative,
    // roots are imaginary
    if (D < 0) {
        cout << "imaginary";
        return;
    }

    // Compute square root of discriminant
    int sqrtD = sqrt(D);

    // Compute both roots using 
    // quadratic formula
    int r1 = floor((-b + sqrtD) / (2.0 * a));
    int r2 = floor((-b - sqrtD) / (2.0 * a));

    // Ensure roots are printed 
    // in decreasing order
    if (r1 < r2)
        swap(r1, r2);

    // Print both roots
    cout << r1 << " " << r2;
}

int main()
{
    int a = 1, b = -7, c = 12;
    findRoots(a, b, c);

    return 0;
}

#include <stdio.h>
#include <math.h>

void findRoots(int a, int b, int c)
{
    // If a is zero, it's not 
    // a quadratic equation
    if (a == 0) {
        printf("imaginary");
        return;
    }

    // Calculate discriminant D = b^2 - 4ac
    int D = b * b - 4 * a * c;

    // If discriminant is negative,
    // roots are imaginary
    if (D < 0) {
        printf("imaginary");
        return;
    }

    // Compute square root of discriminant
    int sqrtD = (int)sqrt(D);

    // Compute both roots using 
    // quadratic formula
    int r1 = (int)floor((-b + sqrtD) / (2.0 * a));
    int r2 = (int)floor((-b - sqrtD) / (2.0 * a));

    // Ensure roots are printed 
    // in decreasing order
    if (r1 < r2) {
        int temp = r1;
        r1 = r2;
        r2 = temp;
    }

    // Print both roots
    printf("%d %d", r1, r2);
}

int main()
{
    int a = 1, b = -7, c = 12;
    findRoots(a, b, c);
    return 0;
}

Java

import java.util.*;

public class Main {
    static void findRoots(int a, int b, int c) {
        // If a is zero, it's not 
        // a quadratic equation
        if (a == 0) {
            System.out.print("imaginary");
            return;
        }

        // Calculate discriminant D = b^2 - 4ac
        int D = b * b - 4 * a * c;

        // If discriminant is negative,
        // roots are imaginary
        if (D < 0) {
            System.out.print("imaginary");
            return;
        }

        // Compute square root of discriminant
        int sqrtD = (int)Math.sqrt(D);

        // Compute both roots using 
        // quadratic formula
        int r1 = (int)Math.floor((-b + sqrtD) / (2.0 * a));
        int r2 = (int)Math.floor((-b - sqrtD) / (2.0 * a));

        // Ensure roots are printed 
        // in decreasing order
        if (r1 < r2) {
            int temp = r1;
            r1 = r2;
            r2 = temp;
        }

        // Print both roots
        System.out.print(r1 + " " + r2);
    }

    public static void main(String[] args) {
        int a = 1, b = -7, c = 12;
        findRoots(a, b, c);
    }
}

Python

import math

def findRoots(a, b, c):
    # If a is zero, it's not 
    # a quadratic equation
    if a == 0:
        print("imaginary")
        return

    # Calculate discriminant D = b^2 - 4ac
    D = b * b - 4 * a * c

    # If discriminant is negative,
    # roots are imaginary
    if D < 0:
        print("imaginary")
        return

    # Compute square root of discriminant
    sqrtD = math.sqrt(D)

    # Compute both roots using 
    # quadratic formula
    r1 = math.floor((-b + sqrtD) / (2.0 * a))
    r2 = math.floor((-b - sqrtD) / (2.0 * a))

    # Ensure roots are printed 
    # in decreasing order
    if r1 < r2:
        r1, r2 = r2, r1

    # Print both roots
    print(r1, r2)

if __name__ == "__main__":
    a = 1
    b = -7
    c = 12
    findRoots(a, b, c)

// C# program to find roots
// of a quadratic equation
using System;

class Quadratic {

    // Prints roots of quadratic
    // equation ax * 2 + bx + x
    void findRoots(int a, int b, int c)
    {

        // If a is 0, then equation is
        // not quadratic, but linear

        if (a == 0) {
            Console.Write("Invalid");
            return;
        }

        int d = b * b - 4 * a * c;
        double sqrt_val = Math.Abs(d);

        if (d > 0) {
            Console.Write(
                "Roots are real and different \n");

            Console.Write(
                (double)(-b + sqrt_val) / (2 * a) + "\n"
                + (double)(-b - sqrt_val) / (2 * a));
        }

        // d < 0
        else {
            Console.Write("Roots are complex \n");

            Console.Write(-(double)b / (2 * a) + " + i"
                          + sqrt_val / (2 * a) + "\n"
                          + -(double)b / (2 * a) + " - i"
                          + sqrt_val / (2 * a));
        }
    }

    // Driver code
    public static void Main()
    {
        Quadratic obj = new Quadratic();
        int a = 1, b = -7, c = 12;

        // Function call
        obj.findRoots(a, b, c);
    }
}

// This code is contributed by nitin mittal.

JavaScript

function findRoots(a, b, c) {
    // If a is zero, it's not 
    // a quadratic equation
    if (a === 0) {
        console.log("imaginary");
        return;
    }

    // Calculate discriminant D = b^2 - 4ac
    let D = b * b - 4 * a * c;

    // If discriminant is negative,
    // roots are imaginary
    if (D < 0) {
        console.log("imaginary");
        return;
    }

    // Compute square root of discriminant
    let sqrtD = Math.sqrt(D);

    // Compute both roots using 
    // quadratic formula
    let r1 = Math.floor((-b + sqrtD) / (2.0 * a));
    let r2 = Math.floor((-b - sqrtD) / (2.0 * a));

    // Ensure roots are printed 
    // in decreasing order
    if (r1 < r2) {
        let temp = r1;
        r1 = r2;
        r2 = temp;
    }

    // Print both roots
    console.log(r1 + " " + r2);
}

// driver code

let a = 1, b = -7, c = 12;
findRoots(a, b, c);

PHP

<?php
function findRoots($a, $b, $c)
{
    // If a is zero, it's not 
    // a quadratic equation
    if ($a == 0) {
        echo "imaginary";
        return;
    }

    // Calculate discriminant D = b^2 - 4ac
    $D = $b * $b - 4 * $a * $c;

    // If discriminant is negative,
    // roots are imaginary
    if ($D < 0) {
        echo "imaginary";
        return;
    }

    // Compute square root of discriminant
    $sqrtD = (int)sqrt($D);

    // Compute both roots using 
    // quadratic formula
    $r1 = (int)floor((-$b + $sqrtD) / (2.0 * $a));
    $r2 = (int)floor((-$b - $sqrtD) / (2.0 * $a));

    // Ensure roots are printed 
    // in decreasing order
    if ($r1 < $r2) {
        $temp = $r1;
        $r1 = $r2;
        $r2 = $temp;
    }

    // Print both roots
    echo $r1 . " " . $r2;
}

// driver code
$a = 1; $b = -7; $c = 12;
findRoots($a, $b, $c);
?>

Output

4 3

Time Complexity: O(1)
Auxiliary Space: O(1)

Program to find the Roots of a Quadratic Equation

Explore