Sqrt(x)

Problem Statement

Given a non-negative integer x, return the square root of x rounded down to the nearest integer.

You need to solve this problem efficiently.

What to notice first

• Key insight 1 for Sqrt(x)
• Key insight 2 for solving this problem
• Key insight 3 specific to the approach

Examples

Input	Output	Explanation
Example 1	Result 1	Explanation for example 1
Example 2	Result 2	Explanation for example 2

Constraints

• Constraint 1 for Sqrt(x)
• Constraint 2
• Constraint 3

Real-World Applications

Where this pattern appears

• Database indexing and query optimization
• Buffer management in system memory
• Time-series data analysis and sliding windows
• Image pixel manipulation and batch processing

Complexity Comparison

Approach	Time	Space	Best When
Binary Search	O(n)	O(1)	When applicable
Newton	O(n)	O(1)	When applicable
Iterative	O(n)	O(1)	When applicable

Approach 1: Binary Search

★ Recommended

This approach provides an efficient solution for sqrt(x).

⏱ Time O(n) Single pass 💾 Space O(1) Minimal storage

Solution Code

Python

sqrtx_binary_search.py

def sqrtx_binary_search(x: int) -> int:
    """Find integer square root using binary search."""
    if x < 2:
        return x

    left, right = 2, x // 2
    while left <= right:
        mid = (left + right) // 2
        if mid * mid == x:
            return mid
        elif mid * mid < x:
            left = mid + 1
        else:
            right = mid - 1

    return right

# Test cases
print(sqrtx_binary_search(4))  # 2
print(sqrtx_binary_search(8))  # 2

C++

sqrtx_binary_search.cpp

using namespace std;

int sqrtxBinarySearch(int x) {
    if (x < 2) return x;

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

    return right;
}

int main() {
    cout << sqrtxBinarySearch(4) << endl;  // 2
    cout << sqrtxBinarySearch(8) << endl;  // 2
    return 0;
}

Java

sqrtx_binary_search.java

public class SqrtxBinarySearch {
    public static int sqrtxBinarySearch(int x) {
        if (x < 2) return x;

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

        return (int) right;
    }

    public static void main(String[] args) {
        System.out.println(sqrtxBinarySearch(4));  // 2
        System.out.println(sqrtxBinarySearch(8));  // 2
    }
}

JavaScript

sqrtx_binary_search.js

function sqrtxBinarySearch(x) {
    if (x < 2) return x;

    let left = 2, right = Math.floor(x / 2);
    while (left <= right) {
        const mid = Math.floor((left + right) / 2);
        if (mid * mid === x) {
            return mid;
        } else if (mid * mid < x) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }

    return right;
}

console.log(sqrtxBinarySearch(4));  // 2
console.log(sqrtxBinarySearch(8));  // 2

Rust

sqrtx_binary_search.rs

fn sqrtx_binary_search(x: i32) -> i32 {
    if x < 2 {
        return x;
    }

    let mut left = 2i64;
    let mut right = (x / 2) as i64;

    while left <= right {
        let mid = (left + right) / 2;
        if mid * mid == x as i64 {
            return mid as i32;
        } else if mid * mid < x as i64 {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }

    right as i32
}

fn main() {
    println!("{}", sqrtx_binary_search(4));  // 2
    println!("{}", sqrtx_binary_search(8));  // 2
}

Go

sqrtx_binary_search.go

package main

import "fmt"

func sqrtxBinarySearch(x int) int {
  if x < 2 {
    return x
  }

  left, right := 2, x/2
  for left <= right {
    mid := (left + right) / 2
    if mid*mid == x {
      return mid
    } else if mid*mid < x {
      left = mid + 1
    } else {
      right = mid - 1
    }
  }

  return right
}

func main() {
  fmt.Println(sqrtxBinarySearch(4))  // 2
  fmt.Println(sqrtxBinarySearch(8))  // 2
}

Approach 2: Newton

🎯 Interview Favourite

This approach provides an efficient solution for sqrt(x).

⏱ Time O(n) Single pass 💾 Space O(1) Minimal storage

Solution Code

Python

sqrtx_newton.py

# Python Solution
# Problem: sqrtx
# Approach: newton

# Implementation placeholder for sqrtx_newton
# This file is auto-generated and should contain the solution code.

def sqrtx_newton():
    pass

if __name__ == "__main__":
    pass

C++

sqrtx_newton.cpp

# C++ Solution
# Problem: sqrtx
# Approach: newton

# Implementation placeholder for sqrtx_newton
# This file is auto-generated and should contain the solution code.

def sqrtx_newton():
    pass

if __name__ == "__main__":
    pass

Java

sqrtx_newton.java

# Java Solution
# Problem: sqrtx
# Approach: newton

# Implementation placeholder for sqrtx_newton
# This file is auto-generated and should contain the solution code.

def sqrtx_newton():
    pass

if __name__ == "__main__":
    pass

JavaScript

sqrtx_newton.js

# JavaScript Solution
# Problem: sqrtx
# Approach: newton

# Implementation placeholder for sqrtx_newton
# This file is auto-generated and should contain the solution code.

def sqrtx_newton():
    pass

if __name__ == "__main__":
    pass

Rust

sqrtx_newton.rs

# Rust Solution
# Problem: sqrtx
# Approach: newton

# Implementation placeholder for sqrtx_newton
# This file is auto-generated and should contain the solution code.

def sqrtx_newton():
    pass

if __name__ == "__main__":
    pass

Go

sqrtx_newton.go

# Golang Solution
# Problem: sqrtx
# Approach: newton

# Implementation placeholder for sqrtx_newton
# This file is auto-generated and should contain the solution code.

def sqrtx_newton():
    pass

if __name__ == "__main__":
    pass

Approach 3: Iterative

✓ Simple

This approach provides an efficient solution for sqrt(x).

⏱ Time O(n) Single pass 💾 Space O(1) Minimal storage

Solution Code

Python

sqrtx_iterative.py

# Python Solution
# Problem: sqrtx
# Approach: iterative

# Implementation placeholder for sqrtx_iterative
# This file is auto-generated and should contain the solution code.

def sqrtx_iterative():
    pass

if __name__ == "__main__":
    pass

C++

sqrtx_iterative.cpp

# C++ Solution
# Problem: sqrtx
# Approach: iterative

# Implementation placeholder for sqrtx_iterative
# This file is auto-generated and should contain the solution code.

def sqrtx_iterative():
    pass

if __name__ == "__main__":
    pass

Java

sqrtx_iterative.java

# Java Solution
# Problem: sqrtx
# Approach: iterative

# Implementation placeholder for sqrtx_iterative
# This file is auto-generated and should contain the solution code.

def sqrtx_iterative():
    pass

if __name__ == "__main__":
    pass

JavaScript

sqrtx_iterative.js

# JavaScript Solution
# Problem: sqrtx
# Approach: iterative

# Implementation placeholder for sqrtx_iterative
# This file is auto-generated and should contain the solution code.

def sqrtx_iterative():
    pass

if __name__ == "__main__":
    pass

Rust

sqrtx_iterative.rs

# Rust Solution
# Problem: sqrtx
# Approach: iterative

# Implementation placeholder for sqrtx_iterative
# This file is auto-generated and should contain the solution code.

def sqrtx_iterative():
    pass

if __name__ == "__main__":
    pass

Go

sqrtx_iterative.go

# Golang Solution
# Problem: sqrtx
# Approach: iterative

# Implementation placeholder for sqrtx_iterative
# This file is auto-generated and should contain the solution code.

def sqrtx_iterative():
    pass

if __name__ == "__main__":
    pass

Related Problems

• Two Sum ↗ Easy #1
• Palindrome Number ↗ Easy #9

Interview Tips

Key trade-offs to discuss

• Time vs. space trade-offs between approaches
• Handling edge cases (empty inputs, single elements, duplicates)
• Optimization opportunities and when they matter
• Follow-up variations and constraint changes

← Previous
#66 Plus One Next
#172 Factorial Trailing Zeroes →