Find Subarray With Bitwise OR Closest to K

Find Subarray With Bitwise OR Closest to K - Problem

Find the Perfect Bitwise OR Match!

Given an array nums and a target integer k, you need to find a contiguous subarray whose bitwise OR value is as close as possible to k.

The bitwise OR of a subarray combines all bits using the OR operation: if any element has a bit set at position i, the result will have that bit set too.

Goal: Find a subarray nums[l..r] that minimizes |k - (nums[l] OR nums[l+1] OR ... OR nums[r])|

Example: For nums = [1, 2, 4, 5] and k = 3:
• Subarray [1, 2] has OR = 1 | 2 = 3, difference = |3 - 3| = 0
• This is optimal since we found an exact match!

Return the minimum possible absolute difference.

Input & Output

example_1.py — Basic Case

$ Input: nums = [1,2,4,5], k = 3

› Output: 0

💡 Note: The subarray [1,2] has OR value 1|2 = 3, which exactly matches k=3. The absolute difference is |3-3| = 0, which is optimal.

example_2.py — No Exact Match

$ Input: nums = [1,3,1,3], k = 2

› Output: 1

💡 Note: All possible OR values are 1 (from [1]), 3 (from [3] or [1,3]), giving differences |2-1|=1 and |2-3|=1. The minimum difference is 1.

example_3.py — Single Element

$ Input: nums = [1], k = 10

› Output: 9

💡 Note: Only one subarray [1] exists with OR value 1. The absolute difference is |10-1| = 9.

Visualization

Tap to expand

Understanding the Visualization

Setup Paint Palette

We have paints [1,2,4,5] and want to match color k=3

Try Mixing from Position 0

Start with paint 1, then try 1+2, then 1+2+4, etc.

Check Color Match

Paint 1|2 = 3 gives perfect match! Difference = 0

Verify Optimality

Continue checking other combinations but none beat difference of 0

Key Takeaway

🎯 Key Insight: The OR operation can only set bits (never unset them), which means there are at most 32 distinct OR values when extending from any starting position. This property allows us to optimize from O(n³) to O(n) time complexity!

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

For each position, at most 32 distinct OR values, leading to O(32n) = O(n)

⚡ Linearithmic

Space Complexity

O(log n)

At most 32 distinct OR values stored in set at any time

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
1 ≤ k ≤ 10⁹
All array elements and k are positive integers

Asked in

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

The optimal approach uses bit manipulation properties: when extending a subarray, there are at most 32 distinct OR values possible (since OR can only set bits, never unset them). This reduces time complexity from O(n³) to O(n) while maintaining the same logic of checking all subarrays.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized with Bit Manipulation	O(n log n)	O(log n)	Use the property that OR values have at most 32 distinct values per starting position
Brute Force (Nested Loops)	O(n³)	O(1)	Check every possible subarray and compute its OR value

Optimized with Bit Manipulation — Algorithm Steps

For each starting position i, maintain set of possible (OR_value, end_position) pairs
When adding nums[j], update each existing OR value in the set
Remove duplicates since same OR can be achieved in multiple ways
Track minimum difference for all OR values generated

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with Empty Set

Begin with empty set of OR values

Add First Element

Add nums[i] as first OR value

Extend with OR

Combine each existing OR with new element

Deduplicate

Remove duplicate OR values (key optimization)

Code -

solution.c — C

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

#define MAX_OR_VALUES 32

int minimumDifference(int* nums, int numsSize, int k) {
    int minDiff = INT_MAX;
    
    // For each starting position
    for (int i = 0; i < numsSize; i++) {
        // Array to store possible OR values (at most 32)
        int possibleOrs[MAX_OR_VALUES];
        int orCount = 0;
        
        for (int j = i; j < numsSize; j++) {
            // Update all existing OR values with nums[j]
            int newOrs[MAX_OR_VALUES];
            int newOrCount = 0;
            
            for (int l = 0; l < orCount; l++) {
                int newOr = possibleOrs[l] | nums[j];
                // Check if this OR value already exists
                int exists = 0;
                for (int m = 0; m < newOrCount; m++) {
                    if (newOrs[m] == newOr) {
                        exists = 1;
                        break;
                    }
                }
                if (!exists) {
                    newOrs[newOrCount++] = newOr;
                }
            }
            
            // Add nums[j] itself if not already present
            int exists = 0;
            for (int l = 0; l < newOrCount; l++) {
                if (newOrs[l] == nums[j]) {
                    exists = 1;
                    break;
                }
            }
            if (!exists) {
                newOrs[newOrCount++] = nums[j];
            }
            
            // Copy back to possibleOrs
            for (int l = 0; l < newOrCount; l++) {
                possibleOrs[l] = newOrs[l];
            }
            orCount = newOrCount;
            
            // Check all possible OR values for minimum difference
            for (int l = 0; l < orCount; l++) {
                int diff = abs(k - possibleOrs[l]);
                if (diff < minDiff) {
                    minDiff = diff;
                }
            }
        }
    }
    
    return minDiff;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    int nums[100];
    int numsSize = 0;
    char* token = strtok(line, ",");
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, ",");
    }
    int k;
    scanf("%d", &k);
    printf("%d\n", minimumDifference(nums, numsSize, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

For each position, at most 32 distinct OR values, leading to O(32n) = O(n)

⚡ Linearithmic

Space Complexity

O(log n)

At most 32 distinct OR values stored in set at any time

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
1 ≤ k ≤ 10⁹
All array elements and k are positive integers

39.2K Views

Medium-High Frequency

~25 min Avg. Time

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

Optimized with Bit Manipulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler