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:
#include <iostream> 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 ();
} |
#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 ();
} |
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 |
# 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# 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 // Returns the square root of n. // Note that the function function 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 Code { $n = 50;
echo "Square root of $n is " , squareRoot( $n );
} // This code is contributed by nitin mittal. ?> |
<script> // javascript Program to find the area // of triangle /*Returns the square root of n. Note that the function */ function squareRoot( n)
{ /*We are using n itself as initial approximation
This can definitely be improved */
let x = n;
let y = 1;
let 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*/ let n = 50;
document.write( "Square root of " +n+ " is " + squareRoot(n).toFixed(6));
// This code is contributed by todaysgaurav </script> |
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++ program for Babylonian // method for square root #include <iostream> 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 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 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 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# 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 // PHP 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 */
function squareRoot( $n )
{ $x = $n ;
$y = 1;
while ( $x > $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. ?> |
<script> // javascript 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
*/
function squareRoot(n) {
var x = n;
var y = 1;
while (x > y) {
x = (x + y) / 2;
y = n / x;
}
return x;
}
// Driver Code
var n = 49;
document.write( "root of " + n + " is " + squareRoot(n));
// This code contributed by shikhasingrajput </script> |
Output :
root of 49 is 7
Time Complexity: O(n1/2)
Auxiliary Space: O(1)
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.