Longest Nice Subarray

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: subarrays of length 1 are always considered nice.

Input & Output

Example 1 — Basic Case

$ Input: nums = [1,3,8,48,10]

› Output: 3

💡 Note: The longest nice subarray is [3,8,48] with length 3. Each pair has AND = 0: 3&8=0, 3&48=0, 8&48=0.

Example 2 — Single Element

$ Input: nums = [3,1,5,11,13]

› Output: 1

💡 Note: No pair of elements has AND = 0, so the longest nice subarray has length 1 (any single element).

Example 3 — All Elements Nice

$ Input: nums = [1,2,4]

› Output: 3

💡 Note: All elements have disjoint bits: 1&2=0, 1&4=0, 2&4=0. The entire array is nice with length 3.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 20 M Microsoft 15

The key insight is that a nice subarray requires all pairs to have bitwise AND = 0, meaning elements must have disjoint bits. The sliding window approach efficiently maintains an OR of the current window and shrinks when conflicts arise. Time: O(n), Space: O(1)

Common Approaches

✓ Brute Force - Check All Subarrays

⏱️ Time: O(n³) Space: O(1)

Generate all possible subarrays and for each one, check if every pair of elements has bitwise AND equal to 0. Keep track of the maximum length found.

Sliding Window - Two Pointers

⏱️ Time: O(n) Space: O(1)

Maintain a window with OR of all elements. When adding a new element creates conflict (AND ≠ 0), shrink window from left until conflict resolves.

Brute Force - Check All Subarrays — Algorithm Steps

Step 1: Generate all possible subarrays using nested loops
Step 2: For each subarray, check if it's nice by testing all pairs
Step 3: Keep track of maximum length of nice subarrays found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subarrays

Try all possible start and end positions

Check Pairs

For each subarray, check if all pairs AND to 0

Track Maximum

Keep the longest nice subarray found

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int solution(int* nums, int numsSize) {
    int maxLength = 1;
    
    for (int i = 0; i < numsSize; i++) {
        for (int j = i; j < numsSize; j++) {
            // Check if subarray [i:j+1] is nice
            int isNice = 1;
            for (int x = i; x <= j && isNice; x++) {
                for (int y = x + 1; y <= j; y++) {
                    if ((nums[x] & nums[y]) != 0) {
                        isNice = 0;
                        break;
                    }
                }
            }
            
            if (isNice) {
                int currentLength = j - i + 1;
                if (currentLength > maxLength) {
                    maxLength = currentLength;
                }
            }
        }
    }
    
    return maxLength;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Simple parsing for [1,2,3] format
    int nums[1000];
    int numsSize = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        int val = atoi(token);
        if (val != 0 || token[0] == '0') {
            nums[numsSize++] = val;
        }
        token = strtok(NULL, "[,]");
    }
    
    int result = solution(nums, numsSize);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops: outer two for subarray bounds, inner one to check all pairs

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track indices and maximum length

✓ Linear Space

18.5K Views

Medium Frequency

~25 min Avg. Time

850 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Check All Subarrays — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler