Sqrt(x)

Sqrt(x) - Problem

Given a non-negative integer x, return the square root of x rounded down to the nearest integer. The returned integer should be non-negative as well.

Important: You must not use any built-in exponent function or operator. For example, do not use pow(x, 0.5) in C++ or x ** 0.5 in Python.

Input & Output

Example 1 — Perfect Square

$ Input: x = 4

› Output: 2

💡 Note: The square root of 4 is exactly 2, so we return 2

Example 2 — Non-Perfect Square

$ Input: x = 8

› Output: 2

💡 Note: √8 = 2.828..., rounded down to nearest integer is 2

Example 3 — Edge Case Zero

$ Input: x = 0

› Output: 0

💡 Note: The square root of 0 is 0

Constraints

0 ≤ x ≤ 2³¹ - 1
Must not use built-in exponent functions

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 f Facebook 8 🍎 Apple 6

The key insight is that we need to find the largest integer whose square is ≤ x. Best approach is Binary Search which efficiently narrows down the answer space. Time: O(log x), Space: O(1)

Common Approaches

✓ Binary Search

⏱️ Time: O(log x) Space: O(1)

Instead of checking every number, use binary search between 0 and x to efficiently find the square root. Compare the middle value's square with x and adjust the search range accordingly.

Brute Force Linear Search

⏱️ Time: O(√x) Space: O(1)

Start from 0 and increment by 1, checking if the current number squared is still ≤ x. When we find a number whose square exceeds x, return the previous number.

Newton's Method

⏱️ Time: O(log log x) Space: O(1)

Apply Newton's method for finding roots of f(y) = y² - x = 0. Start with an initial guess and iteratively refine it using the formula: y_new = (y + x/y) / 2.

Binary Search — Algorithm Steps

Set left=0, right=x
While left ≤ right, check mid = (left+right)/2
If mid² ≤ x, search right half; else search left half
Return the last valid mid

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set left=1, right=8, search for √8

Check mid=(1+8)/2=4, 4²=16>8, go left

Found

Check mid=2, 2²=4≤8, this is our answer

Code -

solution.c — C

#include <stdio.h>

int solution(int x) {
    if (x == 0) return 0;
    
    int left = 1, right = x;
    int result = 0;
    
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if ((long long)mid * mid <= x) {
            result = mid;
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    
    return result;
}

int main() {
    int x;
    scanf("%d", &x);
    int result = solution(x);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log x)

Binary search divides search space in half each iteration

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables for left, right, mid pointers

✓ Linear Space

892.2K Views

Medium Frequency

~15 min Avg. Time

3.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Binary Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler