Skip to content
Related Articles

Related Articles

Improve Article

Calculating n-th real root using binary search

  • Difficulty Level : Medium
  • Last Updated : 06 May, 2021

Given two number x and n, find n-th root of x. 

Examples: 

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

Input : 5 2
Output : 2.2360679768025875

Input :  x = 5, n = 3
Output : 1.70997594668



In order to calculate nth root of a number, we can use the following procedure.  

  1. If x lies in the range [0, 1) then we set the lower limit low = x and upper limit high = 1, because for this range of numbers the nth root is always greater than the given number and can never exceed 1.
    eg- $\sqrt{0.09} = 0.3$.
  2. Otherwise, we take low = 1 and high = x.
  3. Declare a variable named epsilon and initialize it for accuracy you need. 
    Say epsilon=0.01, then we can guarantee that our guess for nth root of the given number will be 
    correct up to 2 decimal places.
  4. Declare a variable guess and initialize it to guess=(low+high)/2.
  5. Run a loop such that: 
    • if the absolute error of our guess is more than epsilon then do: 
      1. if guessn > x, then high=guess
      2. else low=guess
      3. Making a new better guess i.e., guess=(low+high)/2.
    • If the absolute error of our guess is less than epsilon then exit the loop.

Absolute Error: Absolute Error can be calculated as abs(guessn -x) 

C++




// C++ Program to find
// n-th real root of x
#include <bits/stdc++.h>
using namespace std;
 
void findNthRoot(double x, int n)
{
 
    // Initialize boundary values
    double low, high;
    if (x >= 0 and x <= 1)
    {
        low = x;
        high = 1;
    }
    else
    {
        low = 1;
        high = x;
    }
 
    // Used for taking approximations
    // of the answer
    double epsilon = 0.00000001;
 
    // Do binary search
    double guess = (low + high) / 2;
    while (abs((pow(guess, n)) - x) >= epsilon)
    {
        if (pow(guess, n) > x)
        {
            high = guess;
        }
        else
        {
            low = guess;
        }
        guess = (low + high) / 2;
    }
 
    cout << fixed << setprecision(16) << guess;
}
 
// Driver code
int main()
{
    double x = 5;
    int n = 2;
    findNthRoot(x, n);
}
 
// This code is contributed
// by Subhadeep
Java



// Java Program to find n-th real root of x
class GFG
{
    static void findNthRoot(double x, int n)
    {
 
        // Initialize boundary values
        double low, high;
        if (x >= 0 && x <= 1)
        {
            low = x;
            high = 1;
        }
        else
        {
            low = 1;
            high = x;
        }
 
        // used for taking approximations
        // of the answer
        double epsilon = 0.00000001;
 
        // Do binary search
        double guess = (low + high) / 2;
        while (Math.abs((Math.pow(guess, n)) - x)
               >= epsilon)
        {
            if (Math.pow(guess, n) > x)
            {
                high = guess;
            }
            else
            {
                low = guess;
            }
            guess = (low + high) / 2;
        }
 
        System.out.println(guess);
    }
 
    // Driver code
    public static void main(String[] args)
    {
        double x = 5;
        int n = 2;
        findNthRoot(x, n);
    }
}
 
// This code is contributed
// by mits
Python3



# Python Program to find n-th real root
# of x
 
 
def findNthRoot(x, n):
 
    # Initialize boundary values
    x = float(x)
    n = int(n)
    if (x >= 0 and x <= 1):
        low = x
        high = 1
    else:
        low = 1
        high = x
 
    # used for taking approximations
    # of the answer
    epsilon = 0.00000001
 
    # Do binary search
    guess = (low + high) / 2
    while abs(guess ** n - x) >= epsilon:
        if guess ** n > x:
            high = guess
        else:
            low = guess
        guess = (low + high) / 2
    print(guess)
 
 
# Driver code
x = 5
n = 2
findNthRoot(x, n)
C#



// C# Program to find n-th real root of x
 
using System;
 
public class GFG {
    static void findNthRoot(double x, int n)
    {
 
        // Initialize boundary values
        double low, high;
        if (x >= 0 && x <= 1)
        {
            low = x;
            high = 1;
        }
        else
        {
            low = 1;
            high = x;
        }
 
        // used for taking approximations
        // of the answer
        double epsilon = 0.00000001;
 
        // Do binary search
        double guess = (low + high) / 2;
        while (Math.Abs((Math.Pow(guess, n)) - x)
               >= epsilon)
        {
            if (Math.Pow(guess, n) > x)
            {
                high = guess;
            }
            else
            {
                low = guess;
            }
            guess = (low + high) / 2;
        }
 
        Console.WriteLine(guess);
    }
 
    // Driver code
    static public void Main()
    {
        double x = 5;
        int n = 2;
        findNthRoot(x, n);
    }
}
 
// This code is contributed by akt_mit
Javascript



<script>
 
    // Javascript Program to find n-th
    // real root of x
     
    function findNthRoot(x, n)
    {
  
        // Initialize boundary values
        let low, high;
        if (x >= 0 && x <= 1)
        {
            low = x;
            high = 1;
        }
        else
        {
            low = 1;
            high = x;
        }
  
        // used for taking approximations
        // of the answer
        let epsilon = 0.00000001;
  
        // Do binary search
        let guess = parseInt((low + high) / 2, 10);
        while (Math.abs((Math.pow(guess, n)) - x)
                >= epsilon)
        {
            if (Math.pow(guess, n) > x)
            {
                high = guess;
            }
            else
            {
                low = guess;
            }
            guess = (low + high) / 2;
        }
  
        document.write(guess);
    }
     
    let x = 5;
    let n = 2;
    findNthRoot(x, n);
     
</script>
Output
2.2360679768025875
Explanation of first example with epsilon = 0.01
Since taking too small value of epsilon as taken in our program might not be feasible for
explanation because it will increase the number of steps drastically so for the sake of
simplicity we are taking epsilon = 0.01
The above procedure will work as follows:
Say we have to calculate the $\sqrt{5}$,then x = 5, low = 1, high = 5.
Taking epsilon = 0.01
First Guess:
guess = (1 + 5) / 2 = 3
Absolute error = |32 - 5| = 4 > epsilon
guess2 = 9 > 5(x) then high = guess --> high = 3
Second Guess:
guess = (1 + 3) / 2 = 2
Absolute error = |22 - 5| = 1 > epsilon
guess2 = 4 > 5(x) then low = guess --> low = 2
Third Guess:
guess = (2 + 3) / 2 = 2.5
Absolute error = |2.52 - 5| = 1.25 > epsilon
guess2 = 6.25 > 5(x) then high = guess --> high = 2.5
and proceeding so on we will get the $\sqrt{5}$ correct up to 2 decimal places i.e., $\sqrt{5}$ = 2.23600456
We will ignore the digits after 2 decimal places since they may or may not be correct.



My Personal Notes
arrow_drop_up
Next

N-th root of a number
Recommended Articles
Page :
Calculating Factorials using Stirling Approximation
05, Jul 17
Inbuilt function for calculating LCM in C++
22, Jul 17
Find square root of number upto given precision using binary search
03, Mar 18
Floor value Kth root of a number using Recursive Binary Search
05, Jun 20
Meta Binary Search | One-Sided Binary Search
24, Oct 18
Digital Root (repeated digital sum) of square of an integer using Digital root of the given integer
01, Oct 20
Nth root of a number using log
16, May 20
Find Nth root of a number using Bisection method
12, Oct 21
Smallest root of the equation x^2 + s(x)*x - n = 0, where s(x) is the sum of digits of root x.
12, Nov 17
Find Nth positive number whose digital root is X
18, Feb 19
Interpolation search vs Binary search
12, May 11
Linear Search vs Binary Search
20, Oct 16
Converting a Real Number (between 0 and 1) to Binary String
26, May 17
Repeatedly search an element by doubling it after every successful search
24, Aug 17
Find the real and imaginary part of a Complex number
16, Apr 20
Count triplets from an array which can form quadratic equations with real roots
29, Jan 21
Print path from root to all nodes in a Complete Binary Tree
03, Apr 19
Print path from a node to root of given Complete Binary Tree
20, Dec 20
Queries to calculate sum of the path from root to a given node in given Binary Tree
01, Mar 21
Count of root to leaf paths in a Binary Tree that form an AP
15, Jul 20
Mth bit in Nth binary string from a sequence generated by the given operations
09, Oct 20
Longest Common Prefix using Binary Search
23, Jun 16
Finding minimum vertex cover size of a graph using binary search
05, Jul 16
Binary Search for Rational Numbers without using floating point arithmetic
25, Nov 15
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
Sc00by_d00
@Sc00by_d00
Vote for difficulty
Current difficulty :
Medium





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox