Given an integer X, find its 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.
Naive 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.
Follow the steps below to implement the above idea
- Create a variable (counter) i and take care of some base cases, (i.e when the given number is 0 or 1).
- Run a loop until i*i <= n, where n is the given number. Increment i by 1.
- The floor of the square root of the number is i – 1
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int floorSqrt(int x)
{
if (x == 0 || x == 1)
return x;
int i = 1, result = 1;
while (result <= x) {
i++;
result = i * i;
}
return i - 1;
}
int main()
{
int x = 11;
cout << floorSqrt(x) << endl;
return 0;
}
|
C
#include <stdio.h>
int floorSqrt(int x)
{
if (x == 0 || x == 1)
return x;
int i = 1, result = 1;
while (result <= x) {
i++;
result = i * i;
}
return i - 1;
}
int main()
{
int x = 11;
printf("%d\n", floorSqrt(x));
return 0;
}
|
Java
class GFG {
static int floorSqrt(int x)
{
if (x == 0 || x == 1)
return x;
int i = 1, result = 1;
while (result <= x) {
i++;
result = i * i;
}
return i - 1;
}
public static void main(String[] args)
{
int x = 11;
System.out.print(floorSqrt(x));
}
}
|
Python3
def floorSqrt(x):
if (x == 0 or x == 1):
return x
i = 1
result = 1
while (result <= x):
i += 1
result = i * i
return i - 1
x = 11
print(floorSqrt(x))
|
C#
using System;
class GFG {
static int floorSqrt(int x)
{
if (x == 0 || x == 1)
return x;
int i = 1, result = 1;
while (result <= x) {
i++;
result = i * i;
}
return i - 1;
}
static public void Main()
{
int x = 11;
Console.WriteLine(floorSqrt(x));
}
}
|
PHP
<?php
function floorSqrt($x)
{
if ($x == 0 || $x == 1)
return $x;
$i = 1;
$result = 1;
while ($result <= $x)
{
$i++;
$result = $i * $i;
}
return $i - 1;
}
$x = 11;
echo floorSqrt($x), "\n";
?>
|
Javascript
<script>
function floorSqrt(x)
{
if (x == 0 || x == 1)
return x;
let i = 1;
let result = 1;
while (result <= x)
{
i++;
result = i * i;
}
return i - 1;
}
let x = 11;
document.write(floorSqrt(x));
</script>
|
Complexity Analysis:
- Time Complexity: O(√X). Only one traversal of the solution is needed, so the time complexity is O(√X).
- Auxiliary Space: O(1).
Thanks, Fattepur Mahesh for suggesting this solution.
Square root an integer using Binary search:
The idea is to find the largest integer i whose square is less than or equal to the given number. The values of i * i is monotonically increasing, so the problem can be solved using binary search.
Below is the implementation of the above idea:
- Base cases for the given problem are when the given number is 0 or 1, then return X;
- Create some variables, for storing the lower bound say l = 0, and for upper bound r = X / 2 (i.e, The floor of the square root of x cannot be more than x/2 when x > 1).
- Run a loop until l <= r, the search space vanishes
- Check if the square of mid (mid = (l + r)/2 ) is less than or equal to X, If yes then search for a larger value in the second half of the search space, i.e l = mid + 1, update ans = mid
- Else if the square of mid is more than X then search for a smaller value in the first half of the search space, i.e r = mid – 1
- Finally, Return the ans
Below is the implementation of the above approach:
C++
#include <iostream>
using namespace std;
int floorSqrt(int x)
{
if (x == 0 || x == 1)
return x;
int start = 1, end = x / 2, ans;
while (start <= end) {
int mid = (start + end) / 2;
int sqr = mid * mid;
if (sqr == x)
return mid;
if (sqr <= x) {
start = mid + 1;
ans = mid;
}
else
end = mid - 1;
}
return ans;
}
int main()
{
int x = 11;
cout << floorSqrt(x) << endl;
return 0;
}
|
C
#include <math.h>
#include <stdio.h>
int floorSqrt(int x)
{
if (x == 0 || x == 1)
return x;
long start = 1, end = x / 2, ans = 0;
while (start <= end) {
int mid = (start + end) / 2;
if (mid * mid == x)
return (int)mid;
if (mid * mid < x) {
start = mid + 1;
ans = mid;
}
else
end = mid - 1;
}
return (int)ans;
}
int main()
{
int x = 11;
printf("%d\n", floorSqrt(x));
}
|
Java
public class Test {
public static int floorSqrt(int x)
{
if (x == 0 || x == 1)
return x;
long start = 1, end = x / 2, ans = 0;
while (start <= end) {
long mid = (start + end) / 2;
if (mid * mid == x)
return (int)mid;
if (mid * mid < x) {
start = mid + 1;
ans = mid;
}
else
end = mid - 1;
}
return (int)ans;
}
public static void main(String args[])
{
int x = 11;
System.out.println(floorSqrt(x));
}
}
|
Python3
def floorSqrt(x):
if (x == 0 or x == 1):
return x
start = 1
end = x//2
while (start <= end):
mid = (start + end) // 2
if (mid*mid == x):
return mid
if (mid * mid < x):
start = mid + 1
ans = mid
else:
end = mid-1
return ans
x = 11
print(floorSqrt(x))
|
C#
using System;
class GFG {
public static int floorSqrt(int x)
{
if (x == 0 || x == 1)
return x;
int start = 1, end = x / 2, ans = 0;
while (start <= end) {
int mid = (start + end) / 2;
if (mid * mid == x)
return mid;
if (mid * mid < x) {
start = mid + 1;
ans = mid;
}
else
end = mid - 1;
}
return ans;
}
static public void Main()
{
int x = 11;
Console.WriteLine(floorSqrt(x));
}
}
|
PHP
<?php
function floorSqrt($x)
{
if ($x == 0 || $x == 1)
return $x;
$start = 1; $end = $x/2; $ans;
while ($start <= $end)
{
$mid = ($start + $end) / 2;
if ($mid * $mid == $x)
return $mid;
if ($mid * $mid < $x)
{
$start = $mid + 1;
$ans = $mid;
}
else
$end = $mid-1;
}
return $ans;
}
$x = 11;
echo floorSqrt($x), "\n";
?>
|
Javascript
<script>
function floorSqrt(x)
{
if (x == 0 || x == 1)
return x;
let start = 1;
let end = x/2;
let ans;
while (start <= end)
{
let mid = (start + end) / 2;
if (mid * mid == x)
return mid;
if (mid * mid < x)
{
start = mid + 1;
ans = mid;
}
else
end = mid-1;
}
return ans;
}
let x = 11;
document.write(floorSqrt(x) + "<br>");
</script>
|
Complexity Analysis:
- Time Complexity: O(log(X)).
- Auxiliary Space: O(1).
Thanks to Gaurav Ahirwar for suggesting the above method.
Square root an integer using built-in functions:
Below is the implementation for finding the square root using the built-in function.
C++
#include <bits/stdc++.h>
using namespace std;
int countSquares(int x)
{
int sqr = sqrt(x);
int result = (int)(sqr);
return result;
}
int main()
{
int x = 9;
cout << (countSquares(x));
return 0;
}
|
C
#include <math.h>
#include <stdio.h>
static int countSquares(int x)
{
int sqr = (int)sqrt(x);
int result = (int)(sqr);
return result;
}
int main()
{
int x = 9;
printf("%d\n", countSquares(x));
}
|
Java
import java.util.*;
class GFG {
static int countSquares(int x)
{
int sqr = (int)Math.sqrt(x);
int result = (int)(sqr);
return result;
}
public static void main(String[] args)
{
int x = 9;
System.out.print(countSquares(x));
}
}
|
Python3
def countSquares(x):
sqrt = x**0.5
result = int(sqrt)
return result
x = 9
print(countSquares(x))
|
C#
using System;
public class GFG {
static int countSquares(int x)
{
int sqr = (int)Math.Sqrt(x);
int result = (int)(sqr);
return result;
}
public static void Main(String[] args)
{
int x = 9;
Console.Write(countSquares(x));
}
}
|
Javascript
<script>
function countSquares(x) {
var sqr = parseInt( Math.sqrt(x));
var result = parseInt(sqr);
return result;
}
var x = 9;
document.write(countSquares(x));
</script>
|
Time Complexity: O(log(X))
Auxiliary Space: O(1)
There can be many ways to solve this problem. For example, the Babylonian Method is one way.
Another Approach to Solve This Problem Using Exponential Function:
The basic idea behind the method is to calculate the exponential of the logarithm of the integer divided by two.
Below are steps to implement the above approach:
- Take the integer value as input and save it in a variable.
- Use the exponential function exp() and the logarithmic function log() from the <cmath> library to calculate the square root of the integer. exp(log(x) / 2) will give the square root of x.
- Use the floor() function to get the integer part of the result.
- Check whether the square of the floor result is equal to the input x.
- If the square of the floor result is equal to the input x, then return the floor result as it is the square root of x.
- If the square of the floor result is not equal to the input x, then return the floor result as the floor of the square root
Below is the implementation of the above approach:
C++
#include <iostream>
#include <cmath>
using namespace std;
int findSquareRoot(int x)
{
double result = exp(log(x) / 2);
int floorResult = floor(result);
if (floorResult * floorResult == x) {
return floorResult;
}
else {
return floorResult;
}
}
int main()
{
int x = 11;
int squareRoot = findSquareRoot(
x);
cout << squareRoot << endl;
return 0;
}
|
Java
import java.lang.Math;
public class Main {
public static int findSquareRoot(int x)
{
double result = Math.exp(Math.log(x) / 2);
int floorResult = (int)Math.floor(result);
if (floorResult * floorResult == x) {
return floorResult;
}
else {
return floorResult;
}
}
public static void main(String[] args)
{
int x = 11;
int squareRoot = findSquareRoot(
x);
System.out.println(
squareRoot);
}
}
|
Python3
import math
def findSquareRoot(x):
result = math.exp(math.log(x) / 2)
floorResult = math.floor(result)
if floorResult * floorResult == x:
return floorResult
else:
return floorResult
x = 11
squareRoot = findSquareRoot(x)
print(squareRoot)
|
C#
using System;
public class Program
{
public static int FindSquareRoot(int x)
{
double result = Math.Exp(Math.Log(x) / 2);
int floorResult = (int)Math.Floor(result);
if (floorResult * floorResult == x)
{
return floorResult;
}
else
{
return floorResult;
}
}
public static void Main()
{
int x = 11;
int squareRoot = FindSquareRoot(x);
Console.WriteLine(squareRoot);
}
}
|
Javascript
function findSquareRoot(x) {
let result = Math.exp(Math.log(x) / 2);
let floorResult = Math.floor(result);
if (floorResult * floorResult == x) {
return floorResult;
} else {
return floorResult;
}
}
let x = 11;
let squareRoot = findSquareRoot(x);
console.log(squareRoot);
|
Time Complexity: O(1), The time complexity of the given approach is O(1) since it uses only one mathematical formula exp(log(x) / 2) which is constant time, and a few arithmetic operations, comparisons, and function calls that take constant time as well. Therefore, the time complexity of this algorithm is constant or O(1).
Auxiliary Space: O(1), The space complexity of the given approach is O(1) as it only uses a constant amount of extra space. It declares two integer variables, result and floorResult, which each take constant space, and there is no dynamic memory allocation or recursive calls. Therefore, the space complexity of this algorithm is constant or O(1).