Related Articles

# Square root of an integer

• Difficulty Level : Easy
• Last Updated : 13 Jul, 2021

Given an integer x, find it’s square root. If x is not a perfect square, then return floor(√x).

Examples :

```Input: x = 4
Output: 2
Explanation:  The square root of 4 is 2.

Input: x = 11
Output: 3
Explanation:  The square root of 11 lies in between
3 and 4 so floor of the square root is 3.```

There can be many ways to solve this problem. For example Babylonian Method is one way.
Simple Approach: To find the floor of the square root, try with all-natural numbers starting from 1. Continue incrementing the number until the square of that number is greater than the given number.

• Algorithm:
1. Create a variable (counter) i and take care of some base cases, i.e when the given number is 0 or 1.
2. Run a loop until i*i <= n , where n is the given number. Increment i by 1.
3. The floor of the square root of the number is i – 1
• Implementation:

## C++

 `// A C++ program to find floor(sqrt(x)``#include``using` `namespace` `std;`` ` `// Returns floor of square root of x``int` `floorSqrt(``int` `x)``{``    ``// Base cases``    ``if` `(x == 0 || x == 1)``    ``return` `x;`` ` `    ``// Staring from 1, try all numbers until``    ``// i*i is greater than or equal to x.``    ``int` `i = 1, result = 1;``    ``while` `(result <= x)``    ``{``      ``i++;``      ``result = i * i;``    ``}``    ``return` `i - 1;``}`` ` `// Driver program``int` `main()``{``    ``int` `x = 11;``    ``cout << floorSqrt(x) << endl;``    ``return` `0;``}`

## Java

 `// A Java program to find floor(sqrt(x))`` ` `class` `GFG {``     ` `    ``// Returns floor of square root of x``    ``static` `int` `floorSqrt(``int` `x)``    ``{``        ``// Base cases``        ``if` `(x == ``0` `|| x == ``1``)``            ``return` `x;`` ` `        ``// Staring from 1, try all numbers until``        ``// i*i is greater than or equal to x.``        ``int` `i = ``1``, result = ``1``;``         ` `        ``while` `(result <= x) {``            ``i++;``            ``result = i * i;``        ``}``        ``return` `i - ``1``;``    ``}`` ` `    ``// Driver program``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `x = ``11``;``        ``System.out.print(floorSqrt(x));``    ``}``}`` ` `// This code is contributed by Smitha Dinesh Semwal.`

## Python3

 `# Python3 program to find floor(sqrt(x)`` ` `# Returns floor of square root of x``def` `floorSqrt(x):`` ` `    ``# Base cases``    ``if` `(x ``=``=` `0` `or` `x ``=``=` `1``):``        ``return` `x`` ` `    ``# Staring from 1, try all numbers until``    ``# i*i is greater than or equal to x.``    ``i ``=` `1``; result ``=` `1``    ``while` `(result <``=` `x):``     ` `        ``i ``+``=` `1``        ``result ``=` `i ``*` `i``     ` `    ``return` `i ``-` `1`` ` `# Driver Code``x ``=` `11``print``(floorSqrt(x))`` ` `# This code is contributed by Smitha Dinesh Semwal.`

## C#

 `// A C# program to ``// find floor(sqrt(x))``using` `System;`` ` `class` `GFG``{``    ``// Returns floor of``    ``// square root of x``    ``static` `int` `floorSqrt(``int` `x)``    ``{``        ``// Base cases``        ``if` `(x == 0 || x == 1)``            ``return` `x;`` ` `        ``// Staring from 1, try all``        ``// numbers until i*i is ``        ``// greater than or equal to x.``        ``int` `i = 1, result = 1;``         ` `        ``while` `(result <= x) ``        ``{``            ``i++;``            ``result = i * i;``        ``}``        ``return` `i - 1;``    ``}`` ` `    ``// Driver Code``    ``static` `public` `void` `Main ()``    ``{``        ``int` `x = 11;``        ``Console.WriteLine(floorSqrt(x));``    ``}``}`` ` `// This code is contributed by ajit`

## PHP

 ``

## Javascript

 ``

Output :

`3`
• Complexity Analysis:
• Time Complexity: O(√ n).
Only one traversal of the solution is needed, so the time complexity is O(√ n).
• Space Complexity: O(1).
Constant extra space is needed.

Thanks Fattepur Mahesh for suggesting this solution.
Better Approach: The idea is to find the largest integer i whose square is less than or equal to the given number. The idea is to use Binary Search to solve the problem. The values of i * i is monotonically increasing, so the problem can be solved using binary search.

• Algorithm:
1. Take care of some base cases, i.e when the given number is 0 or 1.
2. Create some variables, lowerbound l = 0, upperbound r = n, where n is the given number, mid and ans to store the answer.
3. Run a loop until l <= r , the search space vanishes
4. Check if the square of mid (mid = (l + r)/2 ) is less than or equal to n, If yes then search for a larger value in second half of search space, i.e l = mid + 1, update ans = mid
5. Else if the square of mid is more than n then search for a smaller value in first half of search space, i.e r = mid – 1
6. Print the value of answer ( ans)
• Implementation:

## C++

 `// A C++ program to find floor(sqrt(x)``#include ``using` `namespace` `std;`` ` `// Returns floor of square root of x``int` `floorSqrt(``int` `x)``{``    ``// Base cases``    ``if` `(x == 0 || x == 1)``        ``return` `x;`` ` `    ``// Do Binary Search for floor(sqrt(x))``    ``int` `start = 1, end = x, ans;``    ``while` `(start <= end) {``        ``int` `mid = (start + end) / 2;`` ` `        ``// If x is a perfect square``        ``if` `(mid * mid == x)``            ``return` `mid;`` ` `        ``// Since we need floor, we update answer when``        ``// mid*mid is smaller than x, and move closer to``        ``// sqrt(x)`` ` `        ``/*``           ``if(mid*mid<=x)``                   ``{``                           ``start = mid+1;``                           ``ans = mid;``                   ``}``            ``Here basically if we multiply mid with itself so``           ``there will be integer overflow which will throw``           ``tle for larger input so to overcome this``           ``situation we can use long or we can just divide``            ``the number by mid which is same as checking``           ``mid*mid < x`` ` `           ``*/``        ``if` `(mid <= x / mid) {``            ``start = mid + 1;``            ``ans = mid;``        ``}``        ``else` `// If mid*mid is greater than x``            ``end = mid - 1;``    ``}``    ``return` `ans;``}`` ` `// Driver program``int` `main()``{``    ``int` `x = 11;``    ``cout << floorSqrt(x) << endl;``    ``return` `0;``}`

## Java

 `// A Java program to find floor(sqrt(x)``public` `class` `Test``{``    ``public` `static` `int` `floorSqrt(``int` `x)``    ``{``        ``// Base Cases``        ``if` `(x == ``0` `|| x == ``1``)``            ``return` `x;`` ` ` ` `        ``// Do Binary Search for floor(sqrt(x))``        ``long` `start = ``1``, end = x, ans=``0``;``        ``while` `(start <= end)``        ``{``            ``int` `mid = (start + end) / ``2``;`` ` `            ``// If x is a perfect square``            ``if` `(mid*mid == x)``                ``return` `(``int``)mid;`` ` `            ``// Since we need floor, we update answer when mid*mid is``            ``// smaller than x, and move closer to sqrt(x)``            ``if` `(mid*mid < x)``            ``{``                ``start = mid + ``1``;``                ``ans = mid;``            ``}``            ``else`   `// If mid*mid is greater than x``                ``end = mid-``1``;``        ``}``        ``return` `(``int``)ans;``    ``}`` ` `    ``// Driver Method``    ``public` `static` `void` `main(String args[])``    ``{``        ``int` `x = ``11``;``        ``System.out.println(floorSqrt(x));``    ``}``}``// Contributed by InnerPeace`

## Python3

 `# Python 3 program to find floor(sqrt(x)`` ` `# Returns floor of square root of x         ``def` `floorSqrt(x) :`` ` `    ``# Base cases``    ``if` `(x ``=``=` `0` `or` `x ``=``=` `1``) :``        ``return` `x``  ` `    ``# Do Binary Search for floor(sqrt(x))``    ``start ``=` `1``    ``end ``=` `x   ``    ``while` `(start <``=` `end) :``        ``mid ``=` `(start ``+` `end) ``/``/` `2``         ` `        ``# If x is a perfect square``        ``if` `(mid``*``mid ``=``=` `x) :``            ``return` `mid``             ` `        ``# Since we need floor, we update ``        ``# answer when mid*mid is smaller``        ``# than x, and move closer to sqrt(x)``        ``if` `(mid ``*` `mid < x) :``            ``start ``=` `mid ``+` `1``            ``ans ``=` `mid``             ` `        ``else` `:``             ` `            ``# If mid*mid is greater than x``            ``end ``=` `mid``-``1``             ` `    ``return` `ans`` ` `# driver code    ``x ``=` `11``print``(floorSqrt(x))``     ` `# This code is contributed by Nikita Tiwari.`

## C#

 `// A C# program to ``// find floor(sqrt(x)``using` `System;`` ` `class` `GFG``{``    ``public` `static` `int` `floorSqrt(``int` `x)``    ``{``        ``// Base Cases``        ``if` `(x == 0 || x == 1)``            ``return` `x;`` ` `        ``// Do Binary Search ``        ``// for floor(sqrt(x))``        ``int` `start = 1, end = x, ans = 0;``        ``while` `(start <= end)``        ``{``            ``int` `mid = (start + end) / 2;`` ` `            ``// If x is a ``            ``// perfect square``            ``if` `(mid * mid == x)``                ``return` `mid;`` ` `            ``// Since we need floor, we ``            ``// update answer when mid * ``            ``// mid is smaller than x, ``            ``// and move closer to sqrt(x)``            ``if` `(mid * mid < x)``            ``{``                ``start = mid + 1;``                ``ans = mid;``            ``}``             ` `            ``// If mid*mid is ``            ``// greater than x``            ``else` `                ``end = mid-1;``        ``}``        ``return` `ans;``    ``}`` ` `    ``// Driver Code``    ``static` `public` `void` `Main ()``    ``{``        ``int` `x = 11;``        ``Console.WriteLine(floorSqrt(x));``    ``}``}`` ` `// This code is Contributed by m_kit`

## PHP

 ``

## Javascript

 ``

Output :

`3`
• Complexity Analysis:
• Time complexity: O(log n).
The time complexity of binary search is O(log n).
• Space Complexity: O(1).
Constant extra space is needed.

Thanks to Gaurav Ahirwar for suggesting above method.
Note: The Binary Search can be further optimized to start with ‘start’ = 0 and ‘end’ = x/2. Floor of square root of x cannot be more than x/2 when x > 1.
Thanks to vinit for suggesting above optimization.