Square root of a number without using sqrt() function

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)²  = 0.
Replacing one of the ?x's with y, then the equation becomes (y-?x)² => y² - 2y?x + x = 0
=> ?x = (y² + 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 Program to find square
// root of a number
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

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++ Program to find square
// root of a number
#include <bits/stdc++.h>
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 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");
  }
}

# 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# 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 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");

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 implementation of the approach
#include<stdio.h>
#include<math.h>
#include <stdbool.h>

// 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++ implementation of the approach
#include <bits/stdc++.h>
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 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 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# 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

<script>

// Javascript implementation of the approach

// Recursive function that returns
// square root of a number with
// precision upto 5 decimal places
function Square(n, i, j)
{
    var mid = ((i + j) / 2);
    var 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
function findSqrt(n)
{
    var i = 1;

    // While the square root is not found
    var found = false;
    while (!found)
    {
        
        // If n is a perfect square
        if (i * i == n)
        {
            document.write(i);
            found = true;
        }

        else if (i * i > n) 
        {
            
            // Square root will lie in the
            // interval i-1 and i
            var res = Square(n, i - 1, i);
            document.write(res.toFixed(5));
            found = true;
        }
        i++;
    }
}

// Driver code
var n = 3;

findSqrt(n);

// This code is contributed by todaysgaurav

</script>

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.

#include <iostream>
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;
}

// 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));
    } 
}

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))

using System;

class Program {
    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;
    }

    static void Main(string[] args) {
        int n = 25;
        Console.WriteLine(Sqrt(n));
    }
}

function sqrt(n) {
  if (n < 2) {
    return n;
  }
  let low = 1, high = n;
  while (low <= high) {
    let mid = Math.floor((low + high) / 2);
    if (mid * mid === n) {
      return mid;
    } else if (mid * mid < n) {
      low = mid + 1;
    } else {
      high = mid - 1;
    }
  }
  return high;
}

let n = 25;
console.log(sqrt(n)); // expected output: 5

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).