Construct the Minimum Bitwise Array I - Practice Coding Problems

Construct the Minimum Bitwise Array I - Problem

Construct the Minimum Bitwise Array

You're given an array nums consisting of n prime integers. Your task is to construct a magical array ans of the same length where each element has a special property.

For each position i, you need to find the minimum possible value for ans[i] such that:

ans[i] OR (ans[i] + 1) == nums[i]

In other words, when you perform a bitwise OR operation between ans[i] and its successor (ans[i] + 1), the result must equal nums[i].

If it's impossible to find such a value for any position, set ans[i] = -1.

The Challenge: Find the minimum valid value for each position, or determine when it's impossible!

Input & Output

example_1.py — Basic Case

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

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

💡 Note: For 2: impossible (no x where x|(x+1)=2). For 3: 1|2=3. For 5: 4|5=5. For 7: 3|4=7.

example_2.py — Single Element

$ Input: nums = [11]

› Output: [9]

💡 Note: For 11: we need x where x|(x+1)=11. Testing: 9|10 = 1001|1010 = 1011 = 11 ✓

example_3.py — All Impossible

$ Input: nums = [2]

› Output: [-1]

💡 Note: 2 in binary is 10. No number x exists where x|(x+1) equals 10 in binary.

Constraints

1 ≤ nums.length ≤ 100
2 ≤ nums[i] ≤ 10⁹
All nums[i] are prime numbers

Visualization

Tap to expand

Understanding the Visualization

Pattern Recognition

When you OR any number with its successor, the rightmost 0 bit gets filled

Reverse Engineering

To find x from target, we need to 'unfill' the rightmost bit that was set

Special Cases

Some numbers like 2 (binary: 10) cannot be created this way

Direct Calculation

Mathematical formula gives us the answer instantly

Key Takeaway

🎯 Key Insight: The OR operation between consecutive numbers follows predictable bit patterns that can be mathematically reversed to find the minimum answer directly!

Asked in

G Google 32 a Amazon 28 f Meta 24 ⊞ Microsoft 19

The optimal approach uses direct bit manipulation to solve each case in O(1) time. The key insight is understanding the mathematical relationship: when x OR (x+1) = target, we can reverse-engineer x by analyzing the binary pattern of the target. This gives us O(n) total time complexity instead of the brute force O(n * max(nums)) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Values)	O(n * max(nums))	O(1)	For each target, try all possible values starting from 0
Direct Bit Manipulation (Optimal)	O(n)	O(1)	Use mathematical properties of OR operation to calculate answer directly

Brute Force (Try All Values) — Algorithm Steps

For each target number in nums
Start testing from candidate = 0
Check if (candidate OR candidate+1) == target
If yes, this is our minimum answer
If no match found after reasonable attempts, return -1

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with target

Begin with the target number we need to achieve

Try candidate = 0

Check if 0 OR 1 equals target

Try candidate = 1

Check if 1 OR 2 equals target

Continue until found

Keep incrementing candidate until we find a match

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 target = nums[i];
        int found = 0;
        
        // Try candidates from 0 up to target
        for (int candidate = 0; candidate < target; candidate++) {
            if ((candidate | (candidate + 1)) == target) {
                result[i] = candidate;
                found = 1;
                break;
            }
        }
        
        if (!found) {
            result[i] = -1;
        }
    }
    
    return result;
}

int main() {
    int nums[] = {2, 3, 5, 7};
    int returnSize;
    int* result = minBitwiseArray(nums, 4, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * max(nums))

For each of n elements, we might check up to max(nums) values in worst case

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables for iteration and result storage

✓ Linear Space

31.5K Views

Medium Frequency

~15 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