We use cookies (including Google cookies) to personalize ads and analyze traffic. By continuing to use our site, you accept our Privacy Policy.

SimplyLeet
TagsDisclaimersPrivacyTermsContactAbout Us

Find Subarray With Bitwise OR Closest to K

Difficulty: Hard

Problem Description

You are given an array nums and an integer k. You need to find a subarray of nums such that the absolute difference between k and the bitwise OR of the subarray elements is as small as possible. In other words, select a subarray nums[l..r] such that |k - (nums[l] OR nums[l + 1] ... OR nums[r])| is minimum. Return the minimum possible value of the absolute difference.

Key Insights

  • The problem requires finding a contiguous subarray whose bitwise OR is closest to a given integer k.
  • Bitwise OR operations tend to accumulate bits, meaning the result can only increase or stay the same as more elements are included.
  • A brute-force approach would involve calculating the bitwise OR for every possible subarray, which would be inefficient for large arrays.
  • Maintaining a running OR value as you explore the subarray can help efficiently calculate the required values.
  • Using a two-pointer or sliding window technique can help in finding the optimal subarray.

Space and Time Complexity

Time Complexity: O(n), where n is the length of the input array, as we will traverse the array at most twice. Space Complexity: O(1), since we only use a few extra variables for tracking the current OR value and the minimum difference.

Solution

To solve the problem, we can use a sliding window approach to maintain the current subarray and calculate the bitwise OR dynamically. Start with two pointers representing the bounds of the subarray. As we expand the right pointer, we update the current OR. If the current OR exceeds k significantly, we can move the left pointer to try and minimize the difference. We keep track of the minimum absolute difference encountered.

Code Solutions

def find_min_difference(nums, k):
    min_diff = float('inf')
    current_or = 0
    left = 0

    for right in range(len(nums)):
        current_or |= nums[right]  # Update the OR with the new element

        # Check the current absolute difference
        min_diff = min(min_diff, abs(current_or - k))

        # Try to minimize the window from the left if needed
        while left <= right and current_or >= k: 
            min_diff = min(min_diff, abs(current_or - k))
            current_or ^= nums[left]  # Remove the leftmost element from the OR
            left += 1

    return min_diff
← Back to All Questions