Longest Subarray With Maximum Bitwise AND

Longest Subarray With Maximum Bitwise AND - Problem

You are given an integer array nums of size n. Your task is to find the longest contiguous subarray that has the maximum possible bitwise AND value.

Here's how it works:

First, determine the maximum possible bitwise AND value among all possible subarrays
Then, find the longest subarray that achieves this maximum AND value

Key insight: The bitwise AND operation can only preserve or reduce bits - it never increases them. This means the maximum AND value is simply the maximum element in the array!

Example: For array [1, 2, 3, 3, 2, 2], the maximum element is 3. The longest subarray with AND value 3 is [3, 3] with length 2.

Input & Output

example_1.py — Basic case

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

› Output: 2

💡 Note: The maximum AND value is 3 (the maximum element). The longest subarray with AND value 3 is [3, 3] with length 2.

example_2.py — Single element

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

› Output: 1

💡 Note: The maximum AND value is 4. There's only one element with value 4, so the longest subarray length is 1.

example_3.py — All same elements

$ Input: nums = [5, 5, 5, 5]

› Output: 4

💡 Note: All elements are the same (5), so the entire array has AND value 5, giving us length 4.

Visualization

Tap to expand

Understanding the Visualization

Identify Maximum

Find the maximum element - this is our target AND value

Find Streaks

Locate all consecutive sequences of this maximum element

Return Longest

The longest streak gives us our answer

Key Takeaway

🎯 Key Insight: The maximum possible bitwise AND value in any subarray equals the maximum element in the entire array, since AND operations can only maintain or reduce values, never increase them.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Two passes through array: O(n) to find maximum + O(n) to find longest sequence

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra variables for maximum value and length tracking

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁶
The array contains at least one element

Asked in

G Google 42 a Amazon 35 ⊞ Microsoft 28 f Meta 22

The optimal solution leverages the key insight that bitwise AND can only preserve or reduce bits, never increase them. Therefore, the maximum possible AND value equals the maximum element in the array. The problem reduces to finding the longest consecutive sequence of maximum elements in O(n) time.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Subarrays)	O(n³)	O(1)	Calculate AND value for every possible subarray and track the longest with maximum AND
Optimal Single Pass Solution	O(n)	O(1)	Find maximum element, then count longest consecutive sequence of maximum elements

Brute Force (Check All Subarrays) — Algorithm Steps

Generate all possible subarrays using nested loops
For each subarray, calculate its bitwise AND value
Keep track of the maximum AND value found
Among subarrays with maximum AND, track the longest length

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subarrays

Check all subarrays starting from index 0

Calculate AND

Compute bitwise AND for each subarray

Track Maximum

Keep track of maximum AND value and longest length

Code -

solution.c — C

int longestSubarray(int* nums, int numsSize) {
    int maxAnd = 0;
    int maxLength = 0;
    
    // Find all possible subarrays
    for (int i = 0; i < numsSize; i++) {
        for (int j = i; j < numsSize; j++) {
            // Calculate AND for subarray nums[i:j+1]
            int currentAnd = nums[i];
            for (int k = i + 1; k <= j; k++) {
                currentAnd &= nums[k];
            }
            
            // Update maximum AND and corresponding length
            if (currentAnd > maxAnd) {
                maxAnd = currentAnd;
                maxLength = j - i + 1;
            } else if (currentAnd == maxAnd) {
                int currentLength = j - i + 1;
                if (currentLength > maxLength) {
                    maxLength = currentLength;
                }
            }
        }
    }
    
    return maxLength;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) subarrays × O(n) to calculate AND for each subarray

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra variables to track maximum AND and length

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁶
The array contains at least one element

42.3K Views

Medium Frequency

~15 min Avg. Time

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

Brute Force (Check All Subarrays) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler