Contiguous Array

class Solution {
public:
    int findMaxLength(vector<int>& nums) {
        unordered_map<int,int> firstSeen;
        firstSeen[0] = -1;
        int sum = 0, ans = 0;
        for (int i = 0; i < (int)nums.size(); ++i) {
            sum += nums[i] == 1 ? 1 : -1;
            auto it = firstSeen.find(sum);
            if (it != firstSeen.end()) ans = max(ans, i - it->second);
            else firstSeen[sum] = i;
        }
        return ans;
    }
};

func findMaxLength(nums []int) int {
    firstSeen := map[int]int{0: -1}
    sum, ans := 0, 0
    for i, v := range nums {
        if v == 1 {
            sum++
        } else {
            sum--
        }
        if j, ok := firstSeen[sum]; ok {
            if i-j > ans {
                ans = i - j
            }
        } else {
            firstSeen[sum] = i
        }
    }
    return ans
}

from typing import List

class Solution:
    def findMaxLength(self, nums: List[int]) -> int:
        first_seen = {0: -1}
        total, ans = 0, 0
        for i, v in enumerate(nums):
            total += 1 if v == 1 else -1
            if total in first_seen:
                ans = max(ans, i - first_seen[total])
            else:
                first_seen[total] = i
        return ans

function findMaxLength(nums) {
    const firstSeen = new Map();
    firstSeen.set(0, -1);
    let sum = 0, ans = 0;
    for (let i = 0; i < nums.length; i++) {
        sum += nums[i] === 1 ? 1 : -1;
        if (firstSeen.has(sum)) {
            ans = Math.max(ans, i - firstSeen.get(sum));
        } else {
            firstSeen.set(sum, i);
        }
    }
    return ans;
}

class Solution {
    public int findMaxLength(int[] nums) {
        Map<Integer, Integer> firstSeen = new HashMap<>();
        firstSeen.put(0, -1);
        int sum = 0, ans = 0;
        for (int i = 0; i < nums.length; i++) {
            sum += nums[i] == 1 ? 1 : -1;
            if (firstSeen.containsKey(sum)) {
                ans = Math.max(ans, i - firstSeen.get(sum));
            } else {
                firstSeen.put(sum, i);
            }
        }
        return ans;
    }
}

function findMaxLength(nums: number[]): number {
    const firstSeen = new Map<number, number>();
    firstSeen.set(0, -1);
    let sum = 0, ans = 0;
    for (let i = 0; i < nums.length; i++) {
        sum += nums[i] === 1 ? 1 : -1;
        const prev = firstSeen.get(sum);
        if (prev !== undefined) {
            ans = Math.max(ans, i - prev);
        } else {
            firstSeen.set(sum, i);
        }
    }
    return ans;
}