Longest Nice Subarray - Practice Coding Problems

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.

Note: A subarray is a contiguous part of an array. Subarrays of length 1 are always considered nice.

Example: In array [1, 3, 8, 48, 10], the subarray [1, 8, 48] is nice because:
• 1 & 8 = 0
• 1 & 48 = 0
• 8 & 48 = 0

Input & Output

example_1.py — Basic Case

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

› Output: 3

💡 Note: The longest nice subarray is [1,8,48] with length 3. All pairs have AND = 0: 1&8=0, 1&48=0, 8&48=0.

example_2.py — Powers of 2

$ Input: [1,2,4,8,16]

› Output: 5

💡 Note: All elements are powers of 2, so no two elements share any bit positions. The entire array forms a nice subarray.

example_3.py — Single Element

$ Input: [5]

› Output: 1

💡 Note: A single element array always forms a nice subarray of length 1.

Visualization

Tap to expand

Understanding the Visualization

Guest Check-in

Each guest arrives with their unique set of required light switches (bits)

Floor Assignment

Try to assign guest to current floor if no switch conflicts exist

Conflict Resolution

If conflicts arise, remove guests from the left until resolved

Optimal Floor

Track the maximum number of compatible guests on any floor

Key Takeaway

🎯 Key Insight: Use bitwise OR to track all occupied switches, and XOR to efficiently remove guests when shrinking the window.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each element is added once and removed at most once

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for pointers and OR value

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
All elements are positive integers

Asked in

G Google 45 a Amazon 38 f Meta 25 ⊞ Microsoft 18

The optimal solution uses a sliding window approach with bit manipulation. Key insight: track the bitwise OR of current window elements - if a new element has AND ≠ 0 with the current OR, shrink the window from left until valid. Time: O(n), Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Sliding Window (Two Pointers)	O(n)	O(1)	Use sliding window technique to efficiently find the longest nice subarray
Brute Force (Check All Subarrays)	O(n³)	O(1)	Check every possible subarray to see if it's nice

Sliding Window (Two Pointers) — Algorithm Steps

Initialize left and right pointers, and a variable to track current OR
Expand the right pointer and add elements to the window
If new element conflicts with current window (AND ≠ 0), shrink from left
Remove elements from left until no conflict exists
Update maximum window size found so far

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize window

Start with left and right pointers at beginning

Expand right

Add elements to window while maintaining nice property

Detect conflict

When AND ≠ 0, we have a conflict

Shrink left

Remove elements from left until conflict resolved

Code -

solution.c — C

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

int longestNiceSubarray(int* nums, int numsSize) {
    int left = 0;
    int currentOr = 0;
    int maxLength = 0;
    
    for (int right = 0; right < numsSize; right++) {
        // While current number conflicts with window
        while ((currentOr & nums[right]) != 0) {
            currentOr ^= nums[left];  // Remove leftmost element
            left++;
        }
        
        currentOr |= nums[right];  // Add current element
        int length = right - left + 1;
        if (length > maxLength) {
            maxLength = length;
        }
    }
    
    return maxLength;
}

int main() {
    int nums[] = {1, 3, 8, 48, 10};
    int size = sizeof(nums) / sizeof(nums[0]);
    printf("%d\n", longestNiceSubarray(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each element is added once and removed at most once

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for pointers and OR value

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
All elements are positive integers

28.5K Views

Medium Frequency

~22 min Avg. Time

1.2K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Sliding Window (Two Pointers) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler