2401. Longest Nice Subarray

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 <= 105

• 1 <= nums[i] <= 109

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;
      }
  }
  
  ############
  
  class Solution {
      public int longestNiceSubarray(int[] nums) {
          int ans = 0, mask = 0;
          for (int i = 0, j = 0; i < nums.length; ++i) {
              while ((mask & nums[i]) != 0) {
                  mask ^= nums[j++];
              }
              ans = Math.max(ans, i - j + 1);
              mask |= nums[i];
          }
          return ans;
      }
  }

C++

• class Solution {
  public:
      int longestNiceSubarray(vector<int>& nums) {
          int ans = 0, mask = 0;
          for (int i = 0, j = 0; i < nums.size(); ++i) {
              while (mask & nums[i]) {
                  mask ^= nums[j++];
              }
              ans = max(ans, i - j + 1);
              mask |= nums[i];
          }
          return ans;
      }
  };