Guess the Number Using Bitwise Questions I

Guess the Number Using Bitwise Questions I - Problem

Imagine you're playing a digital guessing game where you need to find a hidden number n. However, instead of asking "Is it higher or lower?", you can only ask bitwise questions!

You have access to a special API function: int commonSetBits(int num)

This function tells you how many bit positions have 1s in both the hidden number n and your guess num. In other words, it returns the count of set bits in n & num (bitwise AND).

Your mission: Use this API strategically to discover the hidden number n.

Example: If the hidden number is n = 6 (binary: 110):
• commonSetBits(4) returns 1 because 6 & 4 = 110 & 100 = 100 (one set bit)
• commonSetBits(7) returns 2 because 6 & 7 = 110 & 111 = 110 (two set bits)

Input & Output

example_1.py — Small Number

$ Input: Hidden number: 5 Binary representation: 101

› Output: 5

💡 Note: Using bit-by-bit discovery: commonSetBits(1)=1 (bit 0 set), commonSetBits(2)=0 (bit 1 not set), commonSetBits(4)=1 (bit 2 set). Result: 101₂ = 5₁₀

example_2.py — Power of Two

$ Input: Hidden number: 8 Binary representation: 1000

› Output: 8

💡 Note: Only commonSetBits(8) returns 1, all other powers of 2 return 0. This directly gives us 8.

example_3.py — Edge Case Zero

$ Input: Hidden number: 0 Binary representation: 0

› Output: 0

💡 Note: All calls to commonSetBits with any positive number return 0, indicating the target number is 0.

Visualization

Tap to expand

Understanding the Visualization

Test Position 1

Check if the first dial should be set to 1

Test Position 2

Check if the second dial should be set to 1

Continue Testing

Test each position systematically

Build Combination

Combine all discovered positions to get the final code

Key Takeaway

🎯 Key Insight: By testing individual bit positions with powers of 2, we can reconstruct any number using at most log₂(n) API calls instead of potentially n calls with brute force!

Time & Space Complexity

Time Complexity

⏱️

O(n)

We may need to test up to n numbers in the worst case, where n is the target value

✓ Linear Growth

Space Complexity

O(1)

Only using a constant amount of extra space for variables

✓ Linear Space

Constraints

1 ≤ n ≤ 2³⁰
The hidden number is a positive integer
Interactive problem: You must call the API efficiently
Maximum 50 calls to commonSetBits allowed

Asked in

G Google 25 ⊞ Microsoft 18 a Amazon 15 f Meta 12

The optimal solution uses bit manipulation to discover the target number bit by bit. Instead of guessing entire numbers, we test each bit position independently using powers of 2. This reduces the problem from O(n) API calls to just O(log n) calls, making it highly efficient even for large numbers.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Numbers)	O(n)	O(1)	Test every number from 0 upward until we find the target
Bit-by-Bit Discovery (Optimal)	O(log n)	O(1)	Discover each bit position independently using powers of 2

Brute Force (Try All Numbers) — Algorithm Steps

Start with candidate = 0
For each candidate, count its set bits
Call commonSetBits(candidate) to get common bits with target
If common bits equals candidate's set bits, candidate might be the target
Verify by checking if commonSetBits(candidate) equals total bits in candidate
If verified, return candidate; otherwise increment and continue

Visualization

Tap to expand

Step-by-Step Walkthrough

Test 0

Check if 0 matches the target

Test 1

Check if 1 matches the target

Continue

Keep testing until match found

Code -

solution.c — C

int findNumber() {
    int candidate = 0;
    while (1) {
        int candidateBits = __builtin_popcount(candidate);
        int commonBits = commonSetBits(candidate);
        
        if (candidateBits == commonBits) {
            if (candidate == 0 || commonSetBits(candidate) == candidateBits) {
                return candidate;
            }
        }
        candidate++;
    }
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We may need to test up to n numbers in the worst case, where n is the target value

✓ Linear Growth

Space Complexity

O(1)

Only using a constant amount of extra space for variables

✓ Linear Space

Constraints

1 ≤ n ≤ 2³⁰
The hidden number is a positive integer
Interactive problem: You must call the API efficiently
Maximum 50 calls to commonSetBits allowed

38.5K Views

Medium Frequency

~15 min Avg. Time

1.5K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Try All Numbers) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler