Skip to content
Related Articles
Babylonian method for square root
• Difficulty Level : Medium
• Last Updated : 10 Jun, 2021

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 ` `/*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 contriubted 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# Porgram 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 contriubted by nitin mittal.`

## PHP

 ` ``\$e``)``    ``{``        ``\$x` `= (``\$x` `+ ``\$y``)/2;``        ``\$y` `= ``\$n` `/ ``\$x``;``    ``}``    ``return` `\$x``;``}` `// Driver Code``{``    ``\$n` `= 50;``    ``echo` `"Square root of \$n is "``, squareRoot(``\$n``);``}` `// This code is contributed by nitin mittal.``?>`

## Javascript

 ``

Output :

`Square root of 50 is 7.071068`

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 ` `/* 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

 ` ``\$y``)``    ``{``        ``\$x` `= (``\$x` `+ ``\$y``) / 2;``        ``\$y` `=``\$n` `/ ``\$x``;``    ``}``    ``return` `\$x``;``}` `// Driver Code``\$n` `= 49;``echo` `" root of "``, ``\$n``, ``" is "``, squareRoot(``\$n``);``          ` `// This code is contributed by anuj_67.``?>`

## Javascript

 ``

Output :

` root of 49 is 7`

References;
http://en.wikipedia.org/wiki/Square_root
http://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.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer DSA Live Classes

My Personal Notes arrow_drop_up