Codestin Search App

Construct the Minimum Bitwise Array II - Problem

You are given an array nums consisting of n prime integers. Your task is to construct an array ans of length n such that for each index i, the bitwise OR of ans[i] and ans[i] + 1 equals nums[i].

Key Constraint: ans[i] OR (ans[i] + 1) == nums[i]

Your goal is to minimize each value of ans[i] in the resulting array. If it's impossible to find such a value for ans[i] that satisfies the condition, set ans[i] = -1.

Example: If nums[i] = 5 (binary: 101), we need to find the minimum x such that x OR (x+1) = 5. Testing x = 4 (binary: 100): 4 OR 5 = 100 OR 101 = 101 = 5 ✓

Input & Output

example_1.py — Basic Case

$ Input: nums = [2, 3, 5, 7]

› Output: [-1, 1, 4, 3]

💡 Note: For 2: no valid x exists since 2 is even. For 3: 1|2=3. For 5: 4|5=5. For 7: 3|4=7

example_2.py — All Odd Primes

$ Input: nums = [11, 13, 31]

› Output: [8, 9, 16]

💡 Note: For 11: 8|9=11 (binary: 1000|1001=1011). For 13: 9|10=13 (1001|1010=1011). For 31: 16|17=31

example_3.py — Edge Case with 2

$ Input: nums = [2]

› Output: [-1]

💡 Note: 2 is the only even prime, and no value x exists such that x|(x+1)=2

Constraints

1 ≤ nums.length ≤ 1000
2 ≤ nums[i] ≤ 10⁹
All elements in nums are prime numbers
You must minimize each ans[i] value

Visualization

Tap to expand

Understanding the Visualization

Key Insight

When we add 1 to any number x, it flips the rightmost 0 bit to 1 and makes all bits to its right become 0

Pattern Recognition

For x OR (x+1) to equal nums[i], we need to find x where adding 1 creates the right bit pattern

Reverse Engineering

Start with nums[i], find its rightmost 0 bit, and clear it to get the minimum x

Special Case

If nums[i] is even (only 2 for primes), no valid x exists since x OR (x+1) is always odd

Key Takeaway

🎯 Key Insight: The mathematical property that x OR (x+1) always produces a number where the rightmost 0 bit of x becomes 1, allowing us to reverse-engineer the solution efficiently.

Asked in

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

The optimal solution uses bit manipulation to directly compute the minimum value. Key insight: when adding 1 to a number, the rightmost 0 bit flips to 1. We work backwards by finding this bit in the target and clearing it to get our answer. Time complexity: O(n), space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Values)	O(n * max(nums))	O(1)	For each nums[i], try values from 0 upwards until we find one that satisfies the OR condition
Bit Manipulation (Optimal)	O(n)	O(1)	Analyze bit patterns to directly compute the minimum value using mathematical properties

Brute Force (Try All Values) — Algorithm Steps

For each element nums[i] in the input array
Start with candidate value x = 0
Calculate x OR (x+1) and check if it equals nums[i]
If yes, store x as ans[i] and move to next element
If no, increment x and try again
If x exceeds nums[i], set ans[i] = -1 (impossible case)

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with nums[0] = 5

We need to find x such that x OR (x+1) = 5

Try x = 0

0 OR 1 = 1 ≠ 5, continue

Try x = 1

1 OR 2 = 3 ≠ 5, continue

Try x = 4

4 OR 5 = 5 ✓, found answer!

Code -

solution.c — C

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

int* minBitwiseArray(int* nums, int numsSize, int* returnSize) {
    int* result = (int*)malloc(numsSize * sizeof(int));
    *returnSize = numsSize;
    
    for (int i = 0; i < numsSize; i++) {
        int found = 0;
        // Try values from 0 up to nums[i]
        for (int x = 0; x < nums[i]; x++) {
            if ((x | (x + 1)) == nums[i]) {
                result[i] = x;
                found = 1;
                break;
            }
        }
        
        if (!found) {
            result[i] = -1;
        }
    }
    
    return result;
}

int main() {
    int n;
    scanf("%d", &n);
    int* nums = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        scanf("%d", &nums[i]);
    }
    
    int returnSize;
    int* result = minBitwiseArray(nums, n, &returnSize);
    
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(" ");
    }
    
    free(nums);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * max(nums))

For each of n elements, we might check up to nums[i] values in worst case

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

21.5K Views

Medium Frequency

~25 min Avg. Time

890 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

Brute Force (Try All Values) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler