Guess the Number Using Bitwise Questions II

Guess the Number Using Bitwise Questions II - Problem

Imagine you're playing an interactive guessing game where you need to find a secret number n between 0 and 2³⁰ - 1. However, there's a twist that makes this challenge particularly intriguing!

You have access to a special API function commonBits(num) that helps you gather information about the secret number. But here's the catch: every time you call this function, the secret number changes! Your mission is to find the original value of n before any modifications.

The commonBits(num) function works as follows:

It calculates how many bit positions have the same value in both n and your input num
It then performs n = n XOR num (modifying the secret number!)
Finally, it returns the count of matching bits

Goal: Determine the initial value of the secret number n using strategic calls to commonBits().

Note: Only the first 30 bits are considered when counting common bits, as all numbers are guaranteed to be less than 2³⁰.

Input & Output

example_1.py — Python

$ Input: Secret number n = 5 (binary: 101)

› Output: 5

💡 Note: We query each bit: commonBits(1) returns 1 (odd, so bit 0 = 1), commonBits(2) returns 0 (even, so bit 1 = 0), commonBits(4) returns 1 (odd, so bit 2 = 1). Result: 101 binary = 5 decimal.

example_2.py — Python

$ Input: Secret number n = 0 (binary: 000...000)

› Output: 0

💡 Note: All calls to commonBits(2^i) will return 0 (even), indicating all bits are 0. Result: 0.

example_3.py — Python

$ Input: Secret number n = 1073741823 (binary: 111...111, all 30 bits set)

› Output: 1073741823

💡 Note: All calls to commonBits(2^i) will return 1 (odd), indicating all 30 bits are 1. Result: 2^30 - 1 = 1073741823.

Visualization

Tap to expand

Understanding the Visualization

Initial State

Secret number n has unknown bits

Query Single Bit

Ask about one bit position using power of 2

Analyze Response

Odd count means bit was 1, even means bit was 0

Reconstruct

Combine all discovered bits to get original number

Key Takeaway

🎯 Key Insight: By querying single bit positions, we isolate each bit's contribution to the XOR operation, allowing us to determine the original number bit by bit!

Time & Space Complexity

Time Complexity

⏱️

O(log n)

We make exactly 30 calls (one for each bit position)

⚡ Linearithmic

Space Complexity

O(1)

Only need to store the result and bit position

✓ Linear Space

Constraints

0 ≤ n ≤ 2³⁰ - 1
You can make at most 30 calls to commonBits()
Only the first 30 bits are considered for bit comparison

Asked in

G Google 35 ⊞ Microsoft 28 a Amazon 22 f Meta 15

The optimal solution uses bit manipulation to query each bit position independently. By calling commonBits(2ⁱ) for each bit position, we can determine if that bit was set in the original number based on whether the returned count is odd or even. This elegant approach requires exactly 30 API calls and runs in O(log n) time.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Possibilities)	O(2^30)	O(2^30)	Test every possible number and track the changes
Bit-by-Bit Discovery (Optimal)	O(log n)	O(1)	Determine each bit of the original number using strategic queries

Brute Force (Try All Possibilities) — Algorithm Steps

Try different numbers as input to commonBits()
Track the responses and XOR operations
Attempt to work backwards to find original n
Continue until all possibilities are exhausted

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Testing

Begin testing numbers from 0

Track Changes

Try to track how n changes with each call

Reverse Engineer

Attempt to work backwards to original n

Code -

solution.c — C

// This approach is impractical - shown for educational purposes
int findNumber() {
    // This would be extremely slow and impractical
    // Testing all 2^30 possibilities
    for (int candidate = 0; candidate < (1 << 30); candidate++) {
        // Would need complex logic to reverse-engineer
        // the original number from API responses
        // Not feasible in practice
    }
    return -1; // Placeholder
}

// Note: This approach is not recommended

Time & Space Complexity

Time Complexity

⏱️

O(2^30)

In worst case, we might need to try all possible values

✓ Linear Growth

Space Complexity

O(2^30)

Need to store information about all tested values

✓ Linear Space

Constraints

0 ≤ n ≤ 2³⁰ - 1
You can make at most 30 calls to commonBits()
Only the first 30 bits are considered for bit comparison

43.6K Views

Medium-High Frequency

~25 min Avg. Time

1.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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Try All Possibilities) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler