Construct the Minimum Bitwise Array II

Construct the Minimum Bitwise Array II - Problem

You are given an array nums consisting of n prime integers.

You need to construct an array ans of length n, such that, for each index i, the bitwise OR of ans[i] and ans[i] + 1 is equal to nums[i], i.e. ans[i] OR (ans[i] + 1) == nums[i].

Additionally, you must minimize each value of ans[i] in the resulting array.

If it is not possible to find such a value for ans[i] that satisfies the condition, then set ans[i] = -1.

Input & Output

Example 1 — Basic Case

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

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

💡 Note: For 2: impossible since 2 is the smallest prime and no valid x exists. For 3: 1|2 = 3. For 5: 4|5 = 5. For 7: 3|4 = 7.

Example 2 — Larger Numbers

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

› Output: [10,12,30]

💡 Note: For 11: 10|11 = 11. For 13: 12|13 = 13. For 31: 30|31 = 31.

Example 3 — Edge Case

$ Input: nums = [2,2,2]

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

💡 Note: All elements are 2, which cannot be formed by x OR (x+1) for any non-negative x.

Constraints

1 ≤ nums.length ≤ 100
2 ≤ nums[i] ≤ 1000
nums[i] is a prime number

Visualization

Tap to expand

Asked in

G Google 25 M Microsoft 20 a Amazon 15

The key insight is understanding how the OR operation works with consecutive numbers: x OR (x+1) creates specific bit patterns that can be analyzed mathematically. The optimal approach uses bit manipulation to directly compute the minimum value by finding the rightmost bit position that can be cleared. Time: O(n × log k), Space: O(1).

Common Approaches

✓ Dfs

⏱️ Time: N/A Space: N/A

Bit Manipulation Analysis

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

Understanding that x OR (x+1) flips the rightmost 0 bit and all bits to its right in x. We can reverse this process by finding where to place a 0 bit in the target number to get the minimum x.

Brute Force Search

⏱️ Time: O(n × k) Space: O(1)

For each element in nums, iterate through all possible values starting from 0 and check if x OR (x+1) equals the target number. Return the first valid x found, or -1 if none exists within reasonable bounds.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

struct TreeNode {
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
};

struct TreeNode* first = NULL;
struct TreeNode* last = NULL;

struct TreeNode* createNode(int val) {
    struct TreeNode* node = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    node->val = val;
    node->left = NULL;
    node->right = NULL;
    return node;
}

void inorder(struct TreeNode* node) {
    if (!node) return;
    
    inorder(node->left);
    
    if (last) {
        last->right = node;
        node->left = last;
    } else {
        first = node;
    }
    
    last = node;
    
    inorder(node->right);
}

struct TreeNode* solution(struct TreeNode* root) {
    if (!root) return NULL;
    
    first = NULL;
    last = NULL;
    
    inorder(root);
    
    if (first && last) {
        last->right = first;
        first->left = last;
    }
    
    return first;
}

struct TreeNode* buildTree(int* arr, int size) {
    if (size == 0) return NULL;
    
    struct TreeNode** nodes = (struct TreeNode**)calloc(size, sizeof(struct TreeNode*));
    
    for (int i = 0; i < size; i++) {
        if (arr[i] != -1001) {
            nodes[i] = createNode(arr[i]);
        }
    }
    
    for (int i = 0; i < size; i++) {
        if (nodes[i]) {
            int leftIdx = 2 * i + 1;
            int rightIdx = 2 * i + 2;
            if (leftIdx < size) {
                nodes[i]->left = nodes[leftIdx];
            }
            if (rightIdx < size) {
                nodes[i]->right = nodes[rightIdx];
            }
        }
    }
    
    struct TreeNode* root = nodes[0];
    free(nodes);
    return root;
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    int arr[2000];
    int size = 0;
    
    char* token = strtok(input, "[],\n ");
    while (token != NULL) {
        if (strcmp(token, "null") == 0) {
            arr[size++] = -1001;
        } else {
            arr[size++] = atoi(token);
        }
        token = strtok(NULL, "[],\n ");
    }
    
    struct TreeNode* root = buildTree(arr, size);
    struct TreeNode* result = solution(root);
    
    if (!result) {
        printf("[]\n");
        return 0;
    }
    
    printf("[");
    struct TreeNode* current = result;
    int first = 1;
    do {
        if (!first) printf(",");
        printf("%d", current->val);
        current = current->right;
        first = 0;
    } while (current != result);
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚡ Linearithmic

Space Complexity

✓ Linear Space

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