Shortest Subarray With OR at Least K I

This approach exhaustively checks every possible non-empty subarray. For each subarray, it computes the bitwise OR of its elements and compares it with k. The length of the shortest valid subarray is tracked and returned.

• Initialize minLength to a very large value (e.g., Integer.MAX_VALUE).
• Iterate through each possible starting index i from 0 to n-1.
• For each i, iterate through each possible ending index j from i to n-1.
• For each subarray nums[i..j], calculate its bitwise OR by iterating from i to j.
• If the calculated OR is greater than or equal to k, update minLength = min(minLength, j - i + 1).
• After all loops complete, if minLength remains at its initial large value, return -1. Otherwise, return minLength.

The algorithm uses three nested loops. The outer two loops define the start (i) and end (j) indices of a subarray. The innermost loop then iterates from i to j to calculate the bitwise OR of the elements within that subarray. If this OR value is at least k, we update our answer with the current subarray's length if it's smaller than the minimum length found so far. After checking all subarrays, if no valid subarray was found, we return -1; otherwise, we return the minimum length.

class Solution {
    public int shortestSubarray(int[] nums, int k) {
        int n = nums.length;
        int minLength = Integer.MAX_VALUE;

        for (int i = 0; i < n; i++) {
            for (int j = i; j < n; j++) {
                // Subarray is nums[i..j]
                int currentOR = 0;
                for (int l = i; l <= j; l++) {
                    currentOR |= nums[l];
                }

                if (currentOR >= k) {
                    minLength = Math.min(minLength, j - i + 1);
                }
            }
        }

        return minLength == Integer.MAX_VALUE ? -1 : minLength;
    }
}