Guess Number Higher or Lower

Guess Number Higher or Lower - Problem

We are playing the Guess Game. The game is as follows:

I pick a number from 1 to n. You have to guess which number I picked (the number I picked stays the same throughout the game).

Every time you guess wrong, I will tell you whether the number I picked is higher or lower than your guess.

You call a pre-defined API int guess(int num), which returns three possible results:

-1: Your guess is higher than the number I picked (i.e. num > pick)
1: Your guess is lower than the number I picked (i.e. num < pick)
0: Your guess is equal to the number I picked (i.e. num == pick)

Return the number that I picked.

Input & Output

Example 1 — Basic Case

$ Input: n = 10, pick = 6

› Output: 6

💡 Note: Using binary search: guess 5 (too low), then 8 (too high), then 6 (correct). Found in 3 guesses.

Example 2 — Edge Case

$ Input: n = 1, pick = 1

› Output: 1

💡 Note: Only one number possible, so first guess is correct.

Example 3 — Large Range

$ Input: n = 2, pick = 1

› Output: 1

💡 Note: Binary search starts with middle (1.5 → 1), which happens to be correct.

Constraints

1 ≤ n ≤ 2³¹ - 1
1 ≤ pick ≤ n

Visualization

Tap to expand

Asked in

G Google 25 f Facebook 18 M Microsoft 15 a Amazon 12

The key insight is to use binary search to eliminate half the search space with each guess. The optimal approach uses binary search with O(log n) time complexity and O(1) space complexity.

Common Approaches

✓ Binary Search

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

Apply binary search principle by starting with middle value and adjusting search range based on API response. Each guess eliminates half of the remaining possibilities.

Linear Search

⏱️ Time: O(n) Space: O(1)

Start from 1 and keep guessing incrementally until we get a 0 response from the guess API. This is straightforward but inefficient.

Binary Search — Algorithm Steps

Set left = 1, right = n
Guess middle = (left + right) / 2
If guess returns -1, search left half (right = middle - 1)
If guess returns 1, search right half (left = middle + 1)
If guess returns 0, return middle

Visualization

Tap to expand

Step-by-Step Walkthrough

Middle

Guess middle value

Adjust

Adjust range based on response

Repeat

Continue until found

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// Global variable to store the picked number
int pickedNumber;

// The guess API implementation for testing
int guess(int num) {
    if (num > pickedNumber) {
        return -1;
    } else if (num < pickedNumber) {
        return 1;
    } else {
        return 0;
    }
}

int solution(int n) {
    int left = 1, right = n;
    
    while (left <= right) {
        int middle = left + (right - left) / 2;
        int result = guess(middle);
        
        if (result == 0) {
            return middle;
        } else if (result == -1) {
            right = middle - 1;
        } else { // result == 1
            left = middle + 1;
        }
    }
    
    return -1;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(log n)

Each guess eliminates half the search space, so maximum log₂(n) guesses needed

⚡ Linearithmic

Space Complexity

O(1)

Only using a few variables to track left, right, and middle boundaries

✓ Linear Space

28.4K Views

Medium Frequency

~15 min Avg. Time

892 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