 Open in App
Not now

# Square root of a number without using sqrt() function

• Difficulty Level : Easy
• Last Updated : 19 Mar, 2023

Given a number N, the task is to find the square root of N without using sqrt() function.

Examples:

Input: N = 25
Output: 5

Input: N = 3
Output: 1.73205

Input: N = 2.5
Output: 1.58114

Approach 1:

We can consider (√x-√x)2  = 0.
Replacing one of the √x‘s with y, then the equation becomes (y-√x)2 => y2 – 2y√x + x = 0
=> √x = (y2 + x) / 2y
=> √x = (y + x/y) / 2

In the above equation, we are considering √x as z.
So, to get a required decimal value we can compare the difference of y and z to 10-p (to get the result upto 5 decimal digits, compare y-z to 10-5=0.00001). Until y-z exceeds it, the iteration continues.

Below is the implementation of the above idea:

## C

 `// C Program to find square``// root of a number``#include ``#include ``#include ` `double` `findSqrt(``double` `x)``{``    ``// for 0 and 1, the square roots are themselves``    ``if` `(x < 2)``        ``return` `x;` `    ``// considering the equation values``    ``double` `y = x;``    ``double` `z = (y + (x / y)) / 2;` `    ``// as we want to get upto 5 decimal digits, the absolute``    ``// difference should not exceed 0.00001``    ``while` `(``fabs``(y - z) >= 0.00001) {``        ``y = z;``        ``z = (y + (x / y)) / 2;``    ``}``    ``return` `z;``}` `int` `main()``{``    ``double` `n = 3;``    ``double` `ans = findSqrt(n);``    ``printf``(``"%.5f is the square root of 3\n"``, ans);``    ``return` `0;``}`

## C++

 `// C++ Program to find square``// root of a number``#include ``using` `namespace` `std;` `double` `findSqrt(``double` `x)``{``    ``// for 0 and 1, the square roots are themselves``    ``if` `(x < 2)``        ``return` `x;` `    ``// considering the equation values``    ``double` `y = x;``    ``double` `z = (y + (x / y)) / 2;` `    ``// as we want to get upto 5 decimal digits, the absolute``    ``// difference should not exceed 0.00001``    ``while` `(``abs``(y - z) >= 0.00001) {``        ``y = z;``        ``z = (y + (x / y)) / 2;``    ``}``    ``return` `z;``}` `int` `main()``{` `    ``double` `n = 3;` `    ``double` `ans = findSqrt(n);``    ``cout << setprecision(6) << ans``         ``<< ``" is the square root of 3"` `<< endl;``    ``return` `0;``}`

## Java

 `/// Java Program to find square``// root of a number``import` `java.io.*;``import` `java.util.*;` `class` `GFG {` `  ``public` `static` `double` `findSqrt(``double` `x)``  ``{``    ``// for 0 and 1, the square roots are themselves``    ``if` `(x < ``2``)``      ``return` `x;` `    ``// considering the equation values``    ``double` `y = x;``    ``double` `z = (y + (x / y)) / ``2``;` `    ``// as we want to get upto 5 decimal digits, the``    ``// absolute difference should not exceed 0.00001``    ``while` `(Math.abs(y - z) >= ``0.00001``) {``      ``y = z;``      ``z = (y + (x / y)) / ``2``;``    ``}``    ``return` `z;``  ``}` `  ``public` `static` `void` `main(String[] args)``  ``{``    ``double` `n = ``3``;` `    ``double` `ans = findSqrt(n);` `    ``System.out.println(String.format(``"%.5f"``, ans)``                       ``+ ``" is the square root of 3"``);``  ``}``}`

## Python3

 `# Python Program to find square``# root of a number``def` `findSqrt(x):``  ``# for 0 and 1, the square roots are themselves``  ``if` `x < ``2``:``    ``return` `x``  ` `  ``# considering the equation values``  ``y ``=` `x``  ``z ``=` `(y ``+` `(x``/``y)) ``/` `2``  ` `  ``# as we want to get upto 5 decimal digits, the absolute difference should not exceed``  ``# 0.00001``  ``while` `abs``(y ``-` `z) >``=` `0.00001``:``    ``y ``=` `z``    ``z ``=` `(y ``+` `(x``/``y)) ``/` `2``  ` `  ``return` `z``    `  `if` `__name__ ``=``=` `'__main__'``:``  ``n ``=` `323242``  ` `  ``ans ``=` `findSqrt(n)``  ``print``(ans)`

## C#

 `// C# Program to find square``// root of a number``using` `System;``using` `System.Collections.Generic;` `public` `class` `GFG {` `  ``public` `static` `double` `findSqrt(``double` `x)``  ``{` `    ``// for 0 and 1, the square roots are themselves``    ``if` `(x < 2)``      ``return` `x;` `    ``// considering the equation values``    ``double` `y = x;``    ``double` `z = (y + (x / y)) / 2;` `    ``// as we want to get upto 5 decimal digits, the``    ``// absolute difference should not exceed 0.00001``    ``while` `(Math.Abs(y - z) >= 0.00001) {``      ``y = z;``      ``z = (y + (x / y)) / 2;``    ``}``    ``return` `z;``  ``}` `  ``static` `public` `void` `Main()``  ``{``    ``double` `n = 3;` `    ``double` `ans = findSqrt(n);``    ``ans = Math.Round(ans, 5);``    ``Console.WriteLine(ans + ``" is the square root of 3"``);``  ``}``}`

## Javascript

 `// Javascript Program to find square``// root of a number``    ``function` `findSqrt(x){``        ``if``(x < 2){``            ``return` `x;``        ``}``        ``let y = x;``        ``let z = (y + (x/y))/2;``        ` `        ``while``(Math.abs(y-z)>=0.00001){``            ``y = z;``            ``z = (y + (x/y))/2;``        ``}``        ``return` `z;``    ``}``    ` `    ``let n = 3;``    ``let ans = findSqrt(n);``    ``console.log(ans.toPrecision(6) + ``" is the square root of 3"``);`

Output

`1.73205 is the square root of 3`

Time Complexity: O(log N)
Auxiliary Space: O(1)

Approach 2:

• Start iterating from i = 1. If i * i = n, then print i as n is a perfect square whose square root is i.
• Else find the smallest i for which i * i is strictly greater than n.
• Now we know square root of n lies in the interval i – 1 and i and we can use Binary Search algorithm to find the square root.
• Find mid of i – 1 and i and compare mid * mid with n, with precision upto 5 decimal places.
1. If mid * mid = n then return mid.
2. If mid * mid < n then recur for the second half.
3. If mid * mid > n then recur for the first half.

Below is the implementation of the above approach:

## C

 `// C implementation of the approach``#include``#include``#include ` `// Recursive function that returns square root``// of a number with precision upto 5 decimal places``double` `Square(``double` `n, ``double` `i, ``double` `j)``{``    ``double` `mid = (i + j) / 2;``    ``double` `mul = mid * mid;` `    ``// If mid itself is the square root,``    ``// return mid``    ``if` `((mul == n) || (``fabs``(mul - n) < 0.00001))``        ``return` `mid;` `    ``// If mul is less than n, recur second half``    ``else` `if` `(mul < n)``        ``return` `Square(n, mid, j);` `    ``// Else recur first half``    ``else``        ``return` `Square(n, i, mid);``}` `// Function to find the square root of n``void` `findSqrt(``double` `n)``{``    ``double` `i = 1;` `    ``// While the square root is not found``    ``bool` `found = ``false``;``    ``while` `(!found) {` `        ``// If n is a perfect square``        ``if` `(i * i == n) {``            ``printf``(``"%.0lf"``,i);``            ``found = ``true``;``        ``}``        ``else` `if` `(i * i > n) {` `            ``// Square root will lie in the``            ``// interval i-1 and i``            ``double` `res = Square(n, i - 1, i);``            ``printf``(``"%.5lf"``, res);``            ``found = ``true``;``        ``}``        ``i++;``    ``}``}` `// Driver code``int` `main()``{``    ``double` `n = 3;``    ``findSqrt(n);``    ``return` `0;``}`

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;` `// Recursive function that returns square root``// of a number with precision upto 5 decimal places``double` `Square(``double` `n, ``double` `i, ``double` `j)``{``    ``double` `mid = (i + j) / 2;``    ``double` `mul = mid * mid;` `    ``// If mid itself is the square root,``    ``// return mid``    ``if` `((mul == n) || (``abs``(mul - n) < 0.00001))``        ``return` `mid;` `    ``// If mul is less than n, recur second half``    ``else` `if` `(mul < n)``        ``return` `Square(n, mid, j);` `    ``// Else recur first half``    ``else``        ``return` `Square(n, i, mid);``}` `// Function to find the square root of n``void` `findSqrt(``double` `n)``{``    ``double` `i = 1;` `    ``// While the square root is not found``    ``bool` `found = ``false``;``    ``while` `(!found) {` `        ``// If n is a perfect square``        ``if` `(i * i == n) {``            ``cout << fixed << setprecision(0) << i;``            ``found = ``true``;``        ``}``        ``else` `if` `(i * i > n) {` `            ``// Square root will lie in the``            ``// interval i-1 and i``            ``double` `res = Square(n, i - 1, i);``            ``cout << fixed << setprecision(5) << res;``            ``found = ``true``;``        ``}``        ``i++;``    ``}``}` `// Driver code``int` `main()``{``    ``double` `n = 3;` `    ``findSqrt(n);` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach``import` `java.util.*;` `class` `GFG``{` `// Recursive function that returns``// square root of a number with``// precision upto 5 decimal places``static` `double` `Square(``double` `n,``                     ``double` `i, ``double` `j)``{``    ``double` `mid = (i + j) / ``2``;``    ``double` `mul = mid * mid;` `    ``// If mid itself is the square root,``    ``// return mid``    ``if` `((mul == n) ||  ``        ``(Math.abs(mul - n) < ``0.00001``))``        ``return` `mid;` `    ``// If mul is less than n,``    ``// recur second half``    ``else` `if` `(mul < n)``        ``return` `Square(n, mid, j);` `    ``// Else recur first half``    ``else``        ``return` `Square(n, i, mid);``}` `// Function to find the square root of n``static` `void` `findSqrt(``double` `n)``{``    ``double` `i = ``1``;` `    ``// While the square root is not found``    ``boolean` `found = ``false``;``    ``while` `(!found)``    ``{` `        ``// If n is a perfect square``        ``if` `(i * i == n)``        ``{``            ``System.out.println(i);``            ``found = ``true``;``        ``}``        ` `        ``else` `if` `(i * i > n)``        ``{` `            ``// Square root will lie in the``            ``// interval i-1 and i``            ``double` `res = Square(n, i - ``1``, i);``            ``System.out.printf(``"%.5f"``, res);``            ``found = ``true``;``        ``}``        ``i++;``    ``}``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``double` `n = ``3``;` `    ``findSqrt(n);``}``}` `// This code is contributed by PrinciRaj1992`

## Python3

 `# Python3 implementation of the approach``import` `math` `# Recursive function that returns square root``# of a number with precision upto 5 decimal places``def` `Square(n, i, j):` `    ``mid ``=` `(i ``+` `j) ``/` `2``;``    ``mul ``=` `mid ``*` `mid;` `    ``# If mid itself is the square root,``    ``# return mid``    ``if` `((mul ``=``=` `n) ``or` `(``abs``(mul ``-` `n) < ``0.00001``)):``        ``return` `mid;` `    ``# If mul is less than n, recur second half``    ``elif` `(mul < n):``        ``return` `Square(n, mid, j);` `    ``# Else recur first half``    ``else``:``        ``return` `Square(n, i, mid);` `# Function to find the square root of n``def` `findSqrt(n):``    ``i ``=` `1``;` `    ``# While the square root is not found``    ``found ``=` `False``;``    ``while` `(found ``=``=` `False``):` `        ``# If n is a perfect square``        ``if` `(i ``*` `i ``=``=` `n):``            ``print``(i);``            ``found ``=` `True``;``        ` `        ``elif` `(i ``*` `i > n):` `            ``# Square root will lie in the``            ``# interval i-1 and i``            ``res ``=` `Square(n, i ``-` `1``, i);``            ``print` `(``"{0:.5f}"``.``format``(res))``            ``found ``=` `True``        ``i ``+``=` `1``;` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ``n ``=` `3``;` `    ``findSqrt(n);` `# This code is contributed by 29AjayKumar`

## C#

 `// C# implementation of the approach``using` `System;``    ` `class` `GFG``{` `// Recursive function that returns``// square root of a number with``// precision upto 5 decimal places``static` `double` `Square(``double` `n,``                     ``double` `i, ``double` `j)``{``    ``double` `mid = (i + j) / 2;``    ``double` `mul = mid * mid;` `    ``// If mid itself is the square root,``    ``// return mid``    ``if` `((mul == n) ||``        ``(Math.Abs(mul - n) < 0.00001))``        ``return` `mid;` `    ``// If mul is less than n,``    ``// recur second half``    ``else` `if` `(mul < n)``        ``return` `Square(n, mid, j);` `    ``// Else recur first half``    ``else``        ``return` `Square(n, i, mid);``}` `// Function to find the square root of n``static` `void` `findSqrt(``double` `n)``{``    ``double` `i = 1;` `    ``// While the square root is not found``    ``Boolean found = ``false``;``    ``while` `(!found)``    ``{` `        ``// If n is a perfect square``        ``if` `(i * i == n)``        ``{``            ``Console.WriteLine(i);``            ``found = ``true``;``        ``}``        ` `        ``else` `if` `(i * i > n)``        ``{` `            ``// Square root will lie in the``            ``// interval i-1 and i``            ``double` `res = Square(n, i - 1, i);``            ``Console.Write(``"{0:F5}"``, res);``            ``found = ``true``;``        ``}``        ``i++;``    ``}``}` `// Driver code``public` `static` `void` `Main(String[] args)``{``    ``double` `n = 3;` `    ``findSqrt(n);``}``}` `// This code is contributed by Princi Singh`

## Javascript

 ``

Output

`1.73205`

Time complexity: O(log N) where N is the given integer.
Auxiliary space: O(log N) for recursive stack space.

### Method 3: Using binary search

1. This method uses binary search to find the square root of a number.

2. It starts by initializing the search range from 1 to n. It then calculates the mid-point of the search range and checks if the square of the mid-point is equal to the number we want to find the square root of.

3. If it is, the mid-point is the square root of the number. If not, the search range is updated based on whether the square of the mid-point is less than or greater than the number we want to find the square root of.

4. This process continues until we find the square root of the number.

## C++

 `#include ``using` `namespace` `std;``int` `sqrt``(``int` `n) {``    ``if` `(n < 2) {``        ``return` `n;``    ``}``    ``int` `low = 1, high = n;``    ``while` `(low <= high) {``        ``int` `mid = (low + high) / 2;``        ``if` `(mid * mid == n) {``            ``return` `mid;``        ``} ``else` `if` `(mid * mid < n) {``            ``low = mid + 1;``        ``} ``else` `{``            ``high = mid - 1;``        ``}``    ``}``    ``return` `high;``}` `int` `main() {``    ``int` `n = 25;``    ``cout << ``sqrt``(n) << std::endl;``    ``return` `0;``}`

## Python3

 `def` `sqrt(n):``    ``if` `n < ``2``:``        ``return` `n``    ``low, high ``=` `1``, n``    ``while` `low <``=` `high:``        ``mid ``=` `(low ``+` `high) ``/``/` `2``        ``if` `mid ``*` `mid ``=``=` `n:``            ``return` `mid``        ``elif` `mid ``*` `mid < n:``            ``low ``=` `mid ``+` `1``        ``else``:``            ``high ``=` `mid ``-` `1``    ``return` `high`  `n``=``25``print``(sqrt(n))`

## Java

 `// Java code to implement the approach``import` `java.util.*;` `public` `class` `Main {``    ``public` `static` `int` `sqrt(``int` `n)``    ``{``        ``if` `(n < ``2``) {``            ``return` `n;``        ``}``        ``int` `low = ``1``, high = n;``        ``while` `(low <= high) {``            ``int` `mid = (low + high) / ``2``;``            ``if` `(mid * mid == n) {``                ``return` `mid;``            ``}``            ``else` `if` `(mid * mid < n) {``                ``low = mid + ``1``;``            ``}``            ``else` `{``                ``high = mid - ``1``;``            ``}``        ``}``        ``return` `high;``    ``}``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `n = ``25``;``        ``System.out.println(sqrt(n));``    ``}``}`

Output

`5`

Time complexity:
The time complexity of this algorithm is O(log n) since it uses binary search to find the square root of a number.

Auxiliary space:
The algorithm does not use any extra space, so the space complexity is O(1).

My Personal Notes arrow_drop_up