数的第N个根

给定两个数字N和A，找到A的第N个根。在数学中，数字A的第N个根是一个实数，当我们将其提高为整数幂N时，它们得到A。数学的高级分支。
有关更多信息，请参阅Wiki页面。
例子：

Input : A = 81
        N = 4
Output : 3 
3^4 = 81

由于此问题涉及实数值函数A ^(1 / N)，因此我们可以使用牛顿法解决该问题，该方法从初始猜测开始，然后逐步向结果求值。
我们可以使用牛顿法得出两个连续的迭代值之间的关系，如下所示：

according to newton’s method
x(K+1) = x(K) – f(x) / f’(x)        
here    f(x)  = x^(N) – A
so    f’(x) = N*x^(N - 1)
and     x(K) denoted the value of x at Kth iteration
putting the values and simplifying we get,
x(K + 1) = (1 / N) * ((N - 1) * x(K) + A / x(K) ^ (N - 1))

使用上面的关系，我们可以解决给定的问题。在下面的代码中，我们遍历x的值，直到x的两个连续值之间的差变得低于期望的精度。
下面是上述方法的实现：

C++

// C++ program to calculate Nth root of a number
#include 
using namespace std;
 
//  method returns Nth power of A
double nthRoot(int A, int N)
{
    // intially guessing a random number between
    // 0 and 9
    double xPre = rand() % 10;
 
    //  smaller eps, denotes more accuracy
    double eps = 1e-3;
 
    // initializing difference between two
    // roots by INT_MAX
    double delX = INT_MAX;
 
    //  xK denotes current value of x
    double xK;
 
    //  loop untill we reach desired accuracy
    while (delX > eps)
    {
        //  calculating current value from previous
        // value by newton's method
        xK = ((N - 1.0) * xPre +
              (double)A/pow(xPre, N-1)) / (double)N;
        delX = abs(xK - xPre);
        xPre = xK;
    }
 
    return xK;
}
 
//    Driver code to test above methods
int main()
{
    int N = 4;
    int A = 81;
 
    double nthRootValue = nthRoot(A, N);
    cout << "Nth root is " << nthRootValue << endl;
 
    /*
        double Acalc = pow(nthRootValue, N);
        cout << "Error in difference of powers "
             << abs(A - Acalc) << endl;
    */
 
    return 0;
}

Java

// Java program to calculate Nth root of a number
class GFG
{
     
    // method returns Nth power of A
    static double nthRoot(int A, int N)
    {
         
        // intially guessing a random number between
        // 0 and 9
        double xPre = Math.random() % 10;
     
        // smaller eps, denotes more accuracy
        double eps = 0.001;
     
        // initializing difference between two
        // roots by INT_MAX
        double delX = 2147483647;
     
        // xK denotes current value of x
        double xK = 0.0;
     
        // loop untill we reach desired accuracy
        while (delX > eps)
        {
            // calculating current value from previous
            // value by newton's method
            xK = ((N - 1.0) * xPre +
            (double)A / Math.pow(xPre, N - 1)) / (double)N;
            delX = Math.abs(xK - xPre);
            xPre = xK;
        }
     
        return xK;
    }
     
    // Driver code
    public static void main (String[] args)
    {
        int N = 4;
        int A = 81;
     
        double nthRootValue = nthRoot(A, N);
        System.out.println("Nth root is "
        + Math.round(nthRootValue*1000.0)/1000.0);
     
        /*
            double Acalc = pow(nthRootValue, N);
            cout << "Error in difference of powers "
                << abs(A - Acalc) << endl;
        */
    }
}
 
// This code is contributed by Anant Agarwal.

Python3

# Python3 program to calculate
# Nth root of a number
import math
import random
 
# method returns Nth power of A
def nthRoot(A,N):
 
    # initially guessing a random number between
    # 0 and 9
    xPre = random.randint(1,101) % 10
  
    #  smaller eps, denotes more accuracy
    eps = 0.001
  
    # initializing difference between two
    # roots by INT_MAX
    delX = 2147483647
  
    #  xK denotes current value of x
    xK=0.0
  
    #  loop untill we reach desired accuracy
    while (delX > eps):
 
        # calculating current value from previous
        # value by newton's method
        xK = ((N - 1.0) * xPre +
              A/pow(xPre, N-1)) /N
        delX = abs(xK - xPre)
        xPre = xK;
         
    return xK
 
# Driver code
N = 4
A = 81
nthRootValue = nthRoot(A, N)
 
print("Nth root is ", nthRootValue)
 
## Acalc = pow(nthRootValue, N);
## print("Error in difference of powers ",
##             abs(A - Acalc))
 
# This code is contributed
# by Anant Agarwal.

C#

// C# program to calculate Nth root of a number
using System;
class GFG
{
     
    // method returns Nth power of A
    static double nthRoot(int A, int N)
    {
        Random rand = new Random();
        // intially guessing a random number between
        // 0 and 9
        double xPre = rand.Next(10);;
     
        // smaller eps, denotes more accuracy
        double eps = 0.001;
     
        // initializing difference between two
        // roots by INT_MAX
        double delX = 2147483647;
     
        // xK denotes current value of x
        double xK = 0.0;
     
        // loop untill we reach desired accuracy
        while (delX > eps)
        {
            // calculating current value from previous
            // value by newton's method
            xK = ((N - 1.0) * xPre +
            (double)A / Math.Pow(xPre, N - 1)) / (double)N;
            delX = Math.Abs(xK - xPre);
            xPre = xK;
        }
     
        return xK;
    }
     
    // Driver code
    static void Main()
    {
        int N = 4;
        int A = 81;
     
        double nthRootValue = nthRoot(A, N);
        Console.WriteLine("Nth root is "+Math.Round(nthRootValue*1000.0)/1000.0);
    }
}
 
// This code is contributed by mits

PHP

 $eps)
    {
        // calculating current
        // value from previous
        // value by newton's method
        $xK = ((int)($N - 1.0) *
                     $xPre + $A /
                     (int)pow($xPre,
                              $N - 1)) / $N;
        $delX = abs($xK - $xPre);
        $xPre = $xK;
    }
 
    return floor($xK);
}
 
// Driver code
$N = 4;
$A = 81;
 
$nthRootValue = nthRoot($A, $N);
echo "Nth root is " ,
      $nthRootValue ,"\n";
 
// This code is contributed by akt_mit
?>

Javascript

 
// Javascript program for the above approach
   
    // method returns Nth power of A
    function nthRoot(A, N)
    {
           
        // intially guessing a random number between
        // 0 and 9
        let xPre = Math.random() % 10;
       
        // smaller eps, denotes more accuracy
        let eps = 0.001;
       
        // initializing difference between two
        // roots by INT_MAX
        let delX = 2147483647;
       
        // xK denotes current value of x
        let xK = 0.0;
       
        // loop untill we reach desired accuracy
        while (delX > eps)
        {
            // calculating current value from previous
            // value by newton's method
            xK = ((N - 1.0) * xPre +
            A / Math.pow(xPre, N - 1)) / N;
            delX = Math.abs(xK - xPre);
            xPre = xK;
        }
       
        return xK;
    }
        
 
// Driver Code
     
        let N = 4;
        let A = 81;
       
        let nthRootValue = nthRoot(A, N);
        document.write("Nth root is "+Math.round(nthRootValue*1000.0)/1000.0);
         

输出：

Nth root is 3