Contiguous Array - Practice Coding Problems

Contiguous Array - Problem

Find the Longest Balanced Subarray

Given a binary array containing only 0s and 1s, your task is to find the maximum length of a contiguous subarray that has an equal number of 0s and 1s.

Think of this as finding the longest "balanced" segment in your binary array - where every 0 is perfectly matched with a 1.

Example: In [0,1,0,0,1,1,0], the subarray [0,1,0,0,1,1] has 3 zeros and 3 ones, giving us a maximum length of 6.

Goal: Return the length of the longest such balanced subarray, or 0 if no balanced subarray exists.

Input & Output

example_1.py — Balanced subarray found

$ Input: [0,1]

› Output: 2

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

example_2.py — Longer balanced subarray

$ Input: [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, giving maximum length 6.

example_3.py — No balanced subarray

$ Input: [0,0,0]

› Output: 0

💡 Note: There are only zeros, no ones, so no balanced subarray exists. Return 0.

Visualization

Tap to expand

Understanding the Visualization

Transform the problem

Convert 0→-1, 1→+1. Now equal 0s and 1s mean sum=0 between positions.

Track running totals

Maintain running sum and store first occurrence of each sum value.

Find matching sums

When same sum appears again, the subarray between has net sum 0 (balanced).

Maximize length

Keep track of the longest balanced subarray found.

Key Takeaway

🎯 Key Insight: When the running sum (treating 0 as -1) repeats, the subarray between those positions is perfectly balanced with equal 0s and 1s!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array with O(1) hashmap operations

✓ Linear Growth

Space Complexity

O(n)

Hashmap stores at most n different running sums

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
nums[i] is either 0 or 1
The array contains only binary values

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal solution uses a clever transformation and hash table to solve in O(n) time. By treating 0 as -1, the problem becomes finding subarrays with sum 0. A hash table stores the first occurrence of each running sum, and when we see the same sum again, we've found a balanced subarray. This approach efficiently finds the maximum length in a single pass.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Subarrays)	O(n²)	O(1)	Check every possible subarray and count 0s and 1s
One-Pass Hash Table (Optimal)	O(n)	O(n)	Track running balance and use hashmap to find matching states in single pass

Brute Force (Check All Subarrays) — Algorithm Steps

Start with each position as a potential beginning
Extend the subarray one element at a time
Keep running counts of 0s and 1s
When counts are equal, update maximum length
Continue until all subarrays are checked

Visualization

Tap to expand

Step-by-Step Walkthrough

Start from each position

Begin checking subarrays starting from index 0, then 1, then 2...

Extend subarray

For each starting position, extend the subarray one element at a time

Count and compare

Keep running count of 0s and 1s, check if they're equal

Update maximum

When balanced subarray found, update the maximum length if needed

Code -

solution.c — C

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

int findMaxLength(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;
}

int main() {
    int nums[1000];
    int size = 0;
    int x;
    while (scanf("%d", &x) == 1) {
        nums[size++] = x;
    }
    printf("%d\n", findMaxLength(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We check O(n²) subarrays, each taking O(1) time to process

⚠ Quadratic Growth

Space Complexity

O(1)

Only using variables to track counts and maximum length

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
nums[i] is either 0 or 1
The array contains only binary values

42.8K Views

High Frequency

~18 min Avg. Time

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