Encuentra la raíz de un número usando el método de Newton

Dado un número entero N y un nivel de tolerancia L , la tarea es encontrar la raíz cuadrada de ese número utilizando el método de Newton .
Ejemplos: 
 

Entrada: N = 16, L = 0,0001 
Salida: 4 
4 ² = 16
Entrada: N = 327, L = 0,00001 
Salida: 18,0831 
 

Método de Newton: 
Sea N cualquier número, entonces la raíz cuadrada de N puede ser dada por la fórmula: 
 

root = 0.5 * (X + (N / X)) donde X es cualquier conjetura que se puede suponer que es N o 1. 
 

• En la fórmula anterior, X es cualquier raíz cuadrada supuesta de N y raíz es la raíz cuadrada correcta de N.
• El límite de tolerancia es la diferencia máxima permitida entre X y raíz.

Enfoque: Se pueden seguir los siguientes pasos para calcular la respuesta: 
 

1. Asigne X a la propia N.
2. Ahora, inicie un ciclo y siga calculando la raíz que seguramente se moverá hacia la raíz cuadrada correcta de N.
3. Verifique la diferencia entre la X supuesta y la raíz calculada , si aún no está dentro de la tolerancia, actualice la raíz y continúe.
4. Si la raíz calculada se encuentra dentro de la tolerancia permitida, salga del bucle.
5. Imprime la raíz .

A continuación se muestra la implementación del enfoque anterior: 
 

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to return the square root of
// a number using Newtons method
double squareRoot(double n, float l)
{
    // Assuming the sqrt of n as n only
    double x = n;
 
    // The closed guess will be stored in the root
    double root;
 
    // To count the number of iterations
    int count = 0;
 
    while (1) {
        count++;
 
        // Calculate more closed x
        root = 0.5 * (x + (n / x));
 
        // Check for closeness
        if (abs(root - x) < l)
            break;
 
        // Update root
        x = root;
    }
 
    return root;
}
 
// Driver code
int main()
{
    double n = 327;
    float l = 0.00001;
 
    cout << squareRoot(n, l);
 
    return 0;
}

// Java implementation of the approach
class GFG
{
     
    // Function to return the square root of
    // a number using Newtons method
    static double squareRoot(double n, double l)
    {
        // Assuming the sqrt of n as n only
        double x = n;
     
        // The closed guess will be stored in the root
        double root;
     
        // To count the number of iterations
        int count = 0;
     
        while (true)
        {
            count++;
     
            // Calculate more closed x
            root = 0.5 * (x + (n / x));
     
            // Check for closeness
            if (Math.abs(root - x) < l)
                break;
     
            // Update root
            x = root;
        }
     
        return root;
    }
     
    // Driver code
    public static void main (String[] args)
    {
        double n = 327;
        double l = 0.00001;
     
        System.out.println(squareRoot(n, l));
    }
}
 
// This code is contributed by AnkitRai01

# Python3 implementation of the approach
 
# Function to return the square root of
# a number using Newtons method
def squareRoot(n, l) :
 
    # Assuming the sqrt of n as n only
    x = n
 
    # To count the number of iterations
    count = 0
 
    while (1) :
        count += 1
 
        # Calculate more closed x
        root = 0.5 * (x + (n / x))
 
        # Check for closeness
        if (abs(root - x) < l) :
            break
 
        # Update root
        x = root
 
    return root
 
# Driver code
if __name__ == "__main__" :
 
    n = 327
    l = 0.00001
 
    print(squareRoot(n, l))
 
# This code is contributed by AnkitRai01

// C# implementation of the approach
using System;
 
class GFG
{
     
    // Function to return the square root of
    // a number using Newtons method
    static double squareRoot(double n, double l)
    {
        // Assuming the sqrt of n as n only
        double x = n;
     
        // The closed guess will be stored in the root
        double root;
     
        // To count the number of iterations
        int count = 0;
     
        while (true)
        {
            count++;
     
            // Calculate more closed x
            root = 0.5 * (x + (n / x));
     
            // Check for closeness
            if (Math.Abs(root - x) < l)
                break;
     
            // Update root
            x = root;
        }
     
        return root;
    }
     
    // Driver code
    public static void Main()
    {
        double n = 327;
        double l = 0.00001;
     
        Console.WriteLine(squareRoot(n, l));
    }
}
 
// This code is contributed by AnkitRai01

<script>
    // Javascript implementation of the approach
     
    // Function to return the square root of
    // a number using Newtons method
    function squareRoot(n, l)
    {
        // Assuming the sqrt of n as n only
        let x = n;
       
        // The closed guess will be stored in the root
        let root;
       
        // To count the number of iterations
        let count = 0;
       
        while (true)
        {
            count++;
       
            // Calculate more closed x
            root = 0.5 * (x + (n / x));
       
            // Check for closeness
            if (Math.abs(root - x) < l)
                break;
       
            // Update root
            x = root;
        }
       
        return root.toFixed(4);
    }
     
    let n = 327;
    let l = 0.00001;
 
    document.write(squareRoot(n, l));
  
 // This code is contributed by divyesh072019.
</script>

18.0831

Complejidad de tiempo: O (log N)

Espacio Auxiliar: O(1)