Algoritmo:
este método se puede derivar (pero es anterior) del método de Newton-Raphson.
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
Implementación:
C++
#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();
}
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
<?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.
?>
Javascript
<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>
Producción :
Square root of 50 is 7.071068
Complejidad de tiempo: O (n 1/2 )
Espacio Auxiliar: O(1)
Ejemplo:
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.
Si estamos seguros de que n es un cuadrado perfecto, podemos usar el siguiente método. El método puede ir en bucle infinito para números cuadrados no perfectos. Por ejemplo, para 3, el siguiente ciclo while nunca terminará.
C++
// 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
// 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
<?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.
?>
Javascript
<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>
Producción :
root of 49 is 7
Complejidad del tiempo: O(n 1/2 )
Espacio Auxiliar: O(1)
Referencias;
http://en.wikipedia.org/wiki/Square_root
http://en.wikipedia.org/wiki/Babylonian_method#Babylonian_method
Preguntado por Snehal
Escriba comentarios si encuentra algún error en el programa/algoritmo anterior, o si lo desea para compartir más información sobre el método babilónico.
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