Dados dos números N y A, encuentre la raíz N-ésima de A. En matemáticas, la raíz N-ésima de un número A es un número real que da A, cuando lo elevamos a la potencia entera N. Estas raíces se usan en teoría de números y otros ramas avanzadas de las matemáticas.
Consulte la página Wiki para obtener más información.
Ejemplos:
Input : A = 81
N = 4
Output : 3
3^4 = 81
Como este problema involucra una función de valor real A^(1/N), podemos resolver esto usando el método de Newton , que comienza con una suposición inicial y se desplaza iterativamente hacia el resultado.
Podemos derivar una relación entre dos valores consecutivos de iteración usando el método de Newton de la siguiente manera,
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))
Usando la relación anterior, podemos resolver el problema dado. En el siguiente código, iteramos sobre los valores de x, hasta que la diferencia entre dos valores consecutivos de x sea menor que la precisión deseada.
A continuación se muestra la implementación del enfoque anterior:
C++
// C++ program to calculate Nth root of a number
#include <bits/stdc++.h>
using namespace std;
// method returns Nth power of A
double nthRoot(int A, int N)
{
// initially 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 until 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)
{
// initially 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 until 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 until 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();
// initially 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 until 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
<?php
// PHP program to calculate
// Nth root of a number
// method returns
// Nth power of A
function nthRoot($A, $N)
{
// initially guessing a
// random number between
// 0 and 9
$xPre = rand() % 10;
// smaller eps, denotes
// more accuracy
$eps = 0.001;
// initializing difference
// between two roots by INT_MAX
$delX = PHP_INT_MAX;
// xK denotes current
// value of x
$xK;
// loop until we reach
// desired accuracy
while ($delX > $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
<script>
// Javascript program for the above approach
// method returns Nth power of A
function nthRoot(A, N)
{
// initially 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 until 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);
</script>
Producción:
Nth root is 3
Este artículo es una contribución de Utkarsh Trivedi . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.
Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.
Publicación traducida automáticamente
Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA