2401. Longest Nice Subarray

Problem

You are given an array nums consisting of positive integers.

We call a subarray of nums nice if the bitwise AND of every pair of elements that are in different positions in the subarray is equal to 0.

Return **the length of the *longest* nice subarray**.

A subarray is a contiguous part of an array.

Note that subarrays of length 1 are always considered nice.

  Example 1:

Input: nums = [1,3,8,48,10]
Output: 3
Explanation: The longest nice subarray is [3,8,48]. This subarray satisfies the conditions:
- 3 AND 8 = 0.
- 3 AND 48 = 0.
- 8 AND 48 = 0.
It can be proven that no longer nice subarray can be obtained, so we return 3.

Example 2:

Input: nums = [3,1,5,11,13]
Output: 1
Explanation: The length of the longest nice subarray is 1. Any subarray of length 1 can be chosen.

  Constraints:

• 1 <= nums.length <= 10^5

• 1 <= nums[i] <= 10^9

Solution (Java)

class Solution {
    public int longestNiceSubarray(int[] nums) {
        int maxCount = 1;
        int count = 1;

        List<Integer> list = new ArrayList<>();

        for (int i = 0; i < nums.length - 1; i++) {
            list.clear();
            list.add(nums[i]);
            count = 1;
            for (int j = i + 1; j < nums.length; j++) {
                if ((nums[i] & nums[j]) == 0) {
                    list.add(nums[j]);
                } else
                    break;
            }

            boolean bool = true;
                if (list.size() != 1) {
                for (int i1 = 1; i1 < list.size(); i1++) {
                    for (int j = 0; j < i1; j++) {
                        if (i1!=j&&(list.get(i1) & list.get(j)) != 0) {
                            bool = false;
                            break;
                        }
                    }
                    if (bool)
                        count++;
                    else
                        break;
                }

                if (maxCount<count)
                    maxCount = count;
            }
        }
        return maxCount;
    }
}

Explain:

nope.

Complexity:

• Time complexity : O(n).
• Space complexity : O(n).