Babylonian method for square root (original) (raw)

Last Updated : 23 Jul, 2025

Algorithm:
This method can be derived from (but predates) Newton–Raphson method.

1 Start with an arbitrary positive start value x (the closer to the root, the better). 2 Initialize y = 1. 3. Do following until desired approximation is achieved. a) Get the next approximation for root using average of x and y b) Set y = n/x

Implementation:

C++ `

#include using namespace std; class gfg { /*Returns the square root of n. Note that the function */ public: float squareRoot(float n) { /We are using n itself as initial approximation This can definitely be improved / float x = n; float y = 1; float e = 0.000001; / e decides the accuracy level/ while (x - y > e) { x = (x + y) / 2; y = n / x; } return x; } };

/* Driver program to test above function*/ int main() { gfg g; int n = 50; cout << "Square root of " << n << " is " << g.squareRoot(n); getchar(); }

C

#include <stdio.h>

/*Returns the square root of n. Note that the function */ float squareRoot(float n) { /We are using n itself as initial approximation This can definitely be improved / float x = n; float y = 1; float e = 0.000001; / e decides the accuracy level/ while (x - y > e) { x = (x + y) / 2; y = n / x; } return x; }

/* Driver program to test above function*/ int main() { int n = 50; printf("Square root of %d is %f", n, squareRoot(n)); getchar(); }

Java

class GFG {

/*Returns the square root of n.
Note that the function */
static float squareRoot(float n)
{

    /*We are using n itself as 
    initial approximation This 
    can definitely be improved */
    float x = n;
    float y = 1;

    // e decides the accuracy level
    double e = 0.000001;
    while (x - y > e) {
        x = (x + y) / 2;
        y = n / x;
    }
    return x;
}

/* Driver program to test
above function*/
public static void main(String[] args)
{
    int n = 50;

    System.out.printf("Square root of "
                      + n + " is " + squareRoot(n));
}

}

// This code is contributed by // Smitha DInesh Semwal

Python 3

Returns the square root of n.

Note that the function

def squareRoot(n):

# We are using n itself as
# initial approximation This
# can definitely be improved 
    x = n
    y = 1
    
    # e decides the accuracy level
    e = 0.000001
    while(x - y > e):

        x = (x + y)/2
        y = n / x

    return x

Driver program to test

above function

n = 50

print("Square root of", n, "is", round(squareRoot(n), 6))

This code is contributed by

Smitha Dinesh Semwal

C#

// C# Program for Babylonian // method of square root using System;

class GFG {

// Returns the square root of n.
// Note that the function
static float squareRoot(float n)
{

    // We are using n itself as
    // initial approximation This
    // can definitely be improved
    float x = n;
    float y = 1;

    // e decides the
    // accuracy level
    double e = 0.000001;
    while (x - y > e) {
        x = (x + y) / 2;
        y = n / x;
    }
    return x;
}

// Driver Code
public static void Main()
{
    int n = 50;
    Console.Write("Square root of "
                  + n + " is " + squareRoot(n));
}

}

// This code is contributed by nitin mittal.

PHP

JavaScript

`

Output :

Square root of 50 is 7.071068

Time Complexity: O(n1/2)

Auxiliary Space: O(1)
Example:

n = 4 /n itself is used for initial approximation/ Initialize x = 4, y = 1 Next Approximation x = (x + y)/2 (= 2.500000), y = n/x (=1.600000) Next Approximation x = 2.050000, y = 1.951220 Next Approximation x = 2.000610, y = 1.999390 Next Approximation x = 2.000000, y = 2.000000 Terminate as (x - y) > e now.

If we are sure that n is a perfect square, then we can use following method. The method can go in infinite loop for non-perfect-square numbers. For example, for 3 the below while loop will never terminate.

C++ `

// C++ program for Babylonian // method for square root #include using namespace std;

class gfg {

/* Returns the square root of 

n. Note that the function will not work for numbers which are not perfect squares*/ public: float squareRoot(float n) { /* We are using n itself as an initial approximation. This can definitely be improved */ float x = n; float y = 1;

    while (x > y) {
        x = (x + y) / 2;
        y = n / x;
    }
    return x;
}

};

/* Driver code*/ int main() { gfg g; int n = 49; cout << "Square root of " << n << " is " << g.squareRoot(n); getchar(); }

// This code is edited by Dark_Dante_

C

// C program for Babylonian // method for square root #include <stdio.h>

/* Returns the square root of n. Note that the function will not work for numbers which are not perfect squares*/ unsigned int squareRoot(int n) { int x = n; int y = 1; while (x > y) { x = (x + y) / 2; y = n / x; } return x; }

// Driver Code int main() { int n = 49; printf("root of %d is %d", n, squareRoot(n)); getchar(); }

Java

// Java program for Babylonian // method for square root import java.io.*;

public class GFG {

/* Returns the square root of 
n. Note that the function
will not work for numbers 
which are not perfect 
squares*/
static long squareRoot(int n)
{
    int x = n;
    int y = 1;
    while (x > y) {
        x = (x + y) / 2;
        y = n / x;
    }
    return (long)x;
}

// Driver Code
static public void main(String[] args)
{
    int n = 49;
    System.out.println("root of "
                       + n + " is " + squareRoot(n));
}

}

// This code is contributed by anuj_67.

Python3

python3 program for Babylonian

method for square root

Returns the square root of n.

Note that the function

will not work for numbers

which are not perfect squares

def squareRoot(n): x = n; y = 1; while(x > y): x = (x + y) / 2; y = n / x; return x;

Driver Code

n = 49; print("root of", n, "is", squareRoot(n));

This code is contributed by mits.

C#

// C# program for Babylonian // method for square root

using System;

public class GFG {

/* Returns the square root of 
n. Note that the function
will not work for numbers 
which are not perfect 
squares*/
static uint squareRoot(int n)
{
    int x = n;
    int y = 1;
    while (x > y) {
        x = (x + y) / 2;
        y = n / x;
    }
    return (uint)x;
}

// Driver Code
static public void Main()
{
    int n = 49;
    Console.WriteLine("root of "
                      + n + " is " + squareRoot(n));
}

}

// This code is contributed by anuj_67.

PHP

JavaScript

`

Output :

root of 49 is 7

Time Complexity: O(n1/2)

Auxiliary Space: O(1)
References;
https://en.wikipedia.org/wiki/Square_root
https://en.wikipedia.org/wiki/Babylonian_method#Babylonian_method
Asked by Snehal
Please write comments if you find any bug in the above program/algorithm, or if you want to share more information about Babylonian method.