Guess the Number Using Bitwise Questions II

Guess the Number Using Bitwise Questions II - Problem

There is a number n between 0 and 2³⁰ - 1 (both inclusive) that you have to find. There is a pre-defined API int commonBits(int num) that helps you with your mission. But here is the challenge, every time you call this function, n changes in some way. But keep in mind, that you have to find the initial value of n.

commonBits(int num) acts as follows:

Calculate count which is the number of bits where both n and num have the same value in that position of their binary representation.
n = n XOR num
Return count.

Return the number n.

Note: In this world, all numbers are between 0 and 2³⁰ - 1 (both inclusive), thus for counting common bits, we see only the first 30 bits of those numbers.

Input & Output

Example 1 — Original n = 13

$ Input: Original n = 13 (binary: 1101)

› Output: 13

💡 Note: Using strategic bit queries, we determine bit 0=1, bit 2=1, bit 3=1, others=0, reconstructing 1101₂ = 13

Example 2 — Original n = 7

$ Input: Original n = 7 (binary: 0111)

› Output: 7

💡 Note: Query each bit position to find bits 0, 1, 2 are set, giving us 0111₂ = 7

Example 3 — Original n = 0

$ Input: Original n = 0 (binary: 0000...)

› Output: 0

💡 Note: All commonBits queries return maximum count since all bits match, indicating original was 0

Constraints

0 ≤ n ≤ 2³⁰ - 1
Only first 30 bits are considered
Each commonBits() call modifies n with XOR operation

Visualization

Tap to expand

Asked in

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

The key insight is that each bit of the original number can be determined independently using strategic XOR queries. Best approach is bit-by-bit reconstruction using the commonBits API. Time: O(log n), Space: O(1)

Common Approaches

✓ Bit-by-Bit Reconstruction

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

The key insight is that we can determine each bit of the original number independently. For each bit position i, we make strategic queries to isolate and determine that bit's value in the original number.

Brute Force - Try All Numbers

⏱️ Time: O(2³⁰) Space: O(1)

Since the API changes n with each call, we need to be strategic. We could try to guess the number by testing each possibility, but this would require too many calls and be inefficient.

Optimized Bit Reconstruction

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

This approach improves upon the basic bit manipulation by using a more efficient query strategy. Instead of always querying 0 first, we can use the state changes more strategically to minimize total queries needed.

Bit-by-Bit Reconstruction — Algorithm Steps

For each bit position i from 0 to 29
Query with 0 to get baseline common bits
Query with 2^i to isolate bit i
Use XOR properties to determine original bit value

Visualization

Tap to expand

Step-by-Step Walkthrough

Query 0

Call commonBits(0) to get baseline

Query 2^i

Call commonBits(2^i) to test bit i

Compare

If baseline > test, bit i was 1

Code -

solution.c — C

#include <stdio.h>

// Mock commonBits for compilation (judge will provide real implementation)
int commonBits(int num) {
    return 0; // Placeholder
}

int findNumber() {
    // Strategy: Determine each bit of the original number
    int original = 0;
    
    for (int i = 0; i < 30; i++) {
        // For each bit position, make strategic queries
        int queryVal = 1 << i;
        
        // Make two queries to isolate this bit
        int baseline = commonBits(0);
        int testResult = commonBits(queryVal);
        
        // Determine if bit i was set in original number
        if (baseline > testResult) {
            original |= queryVal;
        }
    }
    
    return original;
}

int main() {
    int result = findNumber();
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log n)

Need 2 calls per bit position, 30 bit positions maximum

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra variables for bit manipulation

✓ Linear Space

23.4K Views

Medium Frequency

~35 min Avg. Time

856 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

Bit-by-Bit Reconstruction — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler