Contiguous Array

Contiguous Array - Problem

Given a binary array nums, return the maximum length of a contiguous subarray with an equal number of 0s and 1s.

A contiguous subarray is a sequence of adjacent elements in the array.

Example: For array [0,1,0,0,1,1,0], the subarray [0,1,0,0,1,1] has 3 zeros and 3 ones, so the maximum length is 6.

Input & Output

Example 1 — Basic Case

$ Input: nums = [0,1]

› Output: 2

💡 Note: The entire array has 1 zero and 1 one, so the maximum length is 2

Example 2 — Longer Array

$ Input: nums = [0,1,0,0,1,1,0]

› Output: 6

💡 Note: The subarray [0,1,0,0,1,1] from index 0 to 5 has 3 zeros and 3 ones, length = 6

Example 3 — All Same

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

› Output: 0

💡 Note: No subarray has equal number of 0s and 1s, so return 0

Constraints

1 ≤ nums.length ≤ 10⁵
nums[i] is either 0 or 1

Visualization

Tap to expand

Asked in

f Facebook 45 G Google 35 a Amazon 30

The key insight is to transform the problem: convert 0s to -1s and find the longest subarray with sum 0. Best approach uses prefix sum with hash map to track first occurrence of each cumulative sum. Time: O(n), Space: O(n)

Common Approaches

✓ Brute Force

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

For each starting position, expand the subarray and keep track of count of 0s and 1s. When counts are equal, update the maximum length.

Prefix Sum with Hash Map

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

Convert each 0 to -1, then find the longest subarray with sum 0 using cumulative sum and hash map to store first occurrence of each sum.

Brute Force — Algorithm Steps

Iterate through each starting index
For each start, expand to all possible ending positions
Count 0s and 1s in current subarray
Update maximum length when counts are equal

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Position

Begin at each index

Expand Window

Extend to all possible endpoints

Count & Compare

Count 0s and 1s, check if equal

Code -

solution.c — C

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

int solution(int* nums, int numsSize) {
    int maxLength = 0;
    
    for (int i = 0; i < numsSize; i++) {
        int zeros = 0, ones = 0;
        for (int j = i; j < numsSize; j++) {
            if (nums[j] == 0) zeros++;
            else ones++;
            
            if (zeros == ones) {
                int currentLength = j - i + 1;
                if (currentLength > maxLength) {
                    maxLength = currentLength;
                }
            }
        }
    }
    
    return maxLength;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int nums[10000];
    int numsSize = 0;
    
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, "[,]");
    }
    
    int result = solution(nums, numsSize);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Nested loops: outer loop n iterations, inner loop up to n iterations

✓ Linear Growth

Space Complexity

O(1)

Only using variables to track counts and maximum length

⚡ Linearithmic Space

180.0K Views

Medium Frequency

~25 min Avg. Time

3.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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler