1class Solution {
2    public int minimumDifference(int[] nums, int k) {
3        // Find the maximum value in the array to determine the number of bits needed.
4        int maxNum = 0;
5        for (int num : nums) {
6            maxNum = Math.max(maxNum, num);
7        }
8      
9        // Determine the number of bits needed to represent the maximum number.
10        int numBits = 32 - Integer.numberOfLeadingZeros(maxNum);
11      
12        // Array to count occurrences of bits.
13        int[] bitCount = new int[numBits];
14        int n = nums.length;
15        int minDifference = Integer.MAX_VALUE;
16      
17        // Initialize pointers i, j and variable s to 0.
18        for (int i = 0, j = 0, bitwiseOrSum = 0; j < n; ++j) {
19            // Update the bitwise OR sum with the current element.
20            bitwiseOrSum |= nums[j];
21            // Update the minimum difference.
22            minDifference = Math.min(minDifference, Math.abs(bitwiseOrSum - k));
23          
24            // Update the occurrences of each bit in the current number.
25            for (int bitPos = 0; bitPos < numBits; ++bitPos) {
26                if ((nums[j] >> bitPos & 1) == 1) {
27                    ++bitCount[bitPos];
28                }
29            }
30          
31            // Adjust the left pointer i until the condition is satisfied.
32            while (i < j && bitwiseOrSum > k) {
33                for (int bitPos = 0; bitPos < numBits; ++bitPos) {
34                    if ((nums[i] >> bitPos & 1) == 1 && --bitCount[bitPos] == 0) {
35                        // If the bit count is zero, remove this bit from the sum.
36                        bitwiseOrSum ^= 1 << bitPos;
37                    }
38                }
39                ++i;  // Increment the left pointer.
40                minDifference = Math.min(minDifference, Math.abs(bitwiseOrSum - k));
41            }
42        }
43        return minDifference;
44    }
45}
46

1#include <vector>
2#include <algorithm>
3#include <climits>
4
5class Solution {
6public:
7    int minimumDifference(std::vector<int>& nums, int k) {
8        // Find the maximum value in nums
9        int maxNum = *std::max_element(nums.begin(), nums.end());
10      
11        // Calculate the number of bits needed to represent maxNum
12        int bitCount = 32 - __builtin_clz(maxNum);
13      
14        // Get the size of the nums vector
15        int size = nums.size();
16      
17        // Initialize the answer to a large value (infinity substitute)
18        int answer = INT_MAX;
19      
20        // Create a vector to count occurrences of bits
21        std::vector<int> bitCounter(bitCount);
22      
23        // Initialize two pointers for the sliding window approach
24        for (int left = 0, right = 0, currentOrValue = 0; right < size; ++right) {
25            // Update the bitwise OR for the current window
26            currentOrValue |= nums[right];
27          
28            // Calculate the minimum difference found so far
29            answer = std::min(answer, abs(currentOrValue - k));
30          
31            // Count the bits for the current number
32            for (int bit = 0; bit < bitCount; ++bit) {
33                if (nums[right] >> bit & 1) {
34                    ++bitCounter[bit];
35                }
36            }
37          
38            // Adjust the window if the current OR value is greater than k
39            while (left < right && currentOrValue > k) {
40                for (int bit = 0; bit < bitCount; ++bit) {
41                    if (nums[left] >> bit & 1 && --bitCounter[bit] == 0) {
42                        // Remove the influence of this bit from currentOrValue
43                        currentOrValue ^= 1 << bit;
44                    }
45                }
46              
47                // Recalculate the minimum difference after shrinking the window
48                answer = std::min(answer, abs(currentOrValue - k));
49              
50                // Move the left pointer to shrink the window
51                ++left;
52            }
53        }
54        return answer;
55    }
56};
57

1function minimumDifference(nums: number[], k: number): number {
2    // Determine the binary length of the maximum number to track bit positions
3    const maxBinaryLength = Math.max(...nums).toString(2).length;
4    const n = nums.length;
5
6    // Initialize an array to count bit frequencies
7    const bitCount: number[] = Array(maxBinaryLength).fill(0);
8    let result = Infinity; // Start with the largest possible value
9
10    // Use two pointers to form a sliding window
11    for (let start = 0, end = 0, sum = 0; end < n; ++end) {
12        sum |= nums[end]; // Add current number's bits to the sum
13        result = Math.min(result, Math.abs(sum - k)); // Update result with the current difference
14
15        // Update the bit counts for current number
16        for (let bitPosition = 0; bitPosition < maxBinaryLength; ++bitPosition) {
17            if ((nums[end] >> bitPosition) & 1) {
18                ++bitCount[bitPosition];
19            }
20        }
21
22        // Slide the window to reduce sum while it exceeds k
23        while (start < end && sum > k) {
24            // Update bit counts when removing a number from the window (start side)
25            for (let bitPosition = 0; bitPosition < maxBinaryLength; ++bitPosition) {
26                if ((nums[start] >> bitPosition) & 1 && --bitCount[bitPosition] === 0) {
27                    sum ^= 1 << bitPosition; // Toggle the bit if it's no longer present
28                }
29            }
30            result = Math.min(result, Math.abs(sum - k)); // Update result
31            ++start; // Move the start pointer
32        }
33    }
34
35    return result; // Return the smallest difference found
36}
37