1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

from typing import List

class Solution:
    def maxBalancedSubarray(self, nums: List[int]) -> int:
        
        x_or_pre = [0]
        diff_pre = [0]
        seen = {(0, 0): -1}

        
        for i, num in enumerate(nums):
            new_diff = diff_pre[-1] + (1 if num & 1 else -1)  
            diff_pre.append(new_diff)
            new_xor = x_or_pre[-1] ^ num  
            x_or_pre.append(new_xor)
            pair = (new_diff, new_xor)
            if pair not in seen:
                seen[pair] = i  

        
        ans = 0
        n = len(nums)
        for i in range(n):
            cnt = diff_pre[i + 1]
            curr_xor = x_or_pre[i + 1]
            pair = (cnt, curr_xor)
            if pair in seen:
                j = seen[pair]
                ans = max(ans, i - j)  
        return ans

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

import java.util.HashMap;
import java.util.Map;

class Solution {
    public int maxBalancedSubarray(int[] nums) {
        int n = nums.length;
        
        int[] xOrPre = new int[n + 1];
        int[] diffPre = new int[n + 1];
        
        Map<String, Integer> seen = new HashMap<>();
        seen.put("0,0", -1);

        
        for (int i = 0; i < n; i++) {
            int num = nums[i];
            diffPre[i + 1] = diffPre[i] + ((num & 1) == 1 ? 1 : -1);  
            xOrPre[i + 1] = xOrPre[i] ^ num;  
            String pair = diffPre[i + 1] + "," + xOrPre[i + 1];
            if (!seen.containsKey(pair)) {
                seen.put(pair, i);  
            }
        }

        
        int ans = 0;
        for (int i = 0; i < n; i++) {
            String pair = diffPre[i + 1] + "," + xOrPre[i + 1];
            if (seen.containsKey(pair)) {
                int j = seen.get(pair);
                ans = Math.max(ans, i - j);
            }
        }
        return ans;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

#include <unordered_map>
#include <string>
#include <vector>

class Solution {
public:
    int maxBalancedSubarray(std::vector<int>& nums) {
        int n = nums.size();
        
        std::vector<int> xOrPre(n + 1, 0);
        std::vector<int> diffPre(n + 1, 0);
        
        std::unordered_map<std::string, int> seen;
        seen["0,0"] = -1;

        
        for (int i = 0; i < n; ++i) {
            int num = nums[i];
            diffPre[i + 1] = diffPre[i] + ((num & 1) ? 1 : -1);  
            xOrPre[i + 1] = xOrPre[i] ^ num;  
            std::string pair = std::to_string(diffPre[i + 1]) + "," + std::to_string(xOrPre[i + 1]);
            if (seen.find(pair) == seen.end()) {
                seen[pair] = i;  
            }
        }

        
        int ans = 0;
        for (int i = 0; i < n; ++i) {
            std::string pair = std::to_string(diffPre[i + 1]) + "," + std::to_string(xOrPre[i + 1]);
            if (seen.find(pair) != seen.end()) {
                int j = seen[pair];
                ans = std::max(ans, i - j);
            }
        }
        return ans;
    }
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

var maxBalancedSubarray = function (nums) {
  const n = nums.length;
  
  const xOrPre = new Array(n + 1).fill(0);
  const diffPre = new Array(n + 1).fill(0);
  
  const seen = new Map();
  seen.set("0,0", -1);

  
  for (let i = 0; i < n; i++) {
    const num = nums[i];
    diffPre[i + 1] = diffPre[i] + (num & 1 ? 1 : -1); 
    xOrPre[i + 1] = xOrPre[i] ^ num; 
    const pair = `${diffPre[i + 1]},${xOrPre[i + 1]}`;
    if (!seen.has(pair)) {
      seen.set(pair, i); 
    }
  }

  
  let ans = 0;
  for (let i = 0; i < n; i++) {
    const pair = `${diffPre[i + 1]},${xOrPre[i + 1]}`;
    if (seen.has(pair)) {
      const j = seen.get(pair);
      ans = Math.max(ans, i - j);
    }
  }
  return ans;
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

import (
    "fmt"
    "strconv"
)

func maxBalancedSubarray(nums []int) int {
    n := len(nums)
    xOrPre := make([]int, n+1)
    diffPre := make([]int, n+1)
    seen := make(map[string]int)
    seen["0,0"] = -1

    
    for i := 0; i < n; i++ {
        num := nums[i]
        if num&1 == 1 {
            diffPre[i+1] = diffPre[i] + 1
        } else {
            diffPre[i+1] = diffPre[i] - 1
        }
        xOrPre[i+1] = xOrPre[i] ^ num
        pair := strconv.Itoa(diffPre[i+1]) + "," + strconv.Itoa(xOrPre[i+1])
        if _, exists := seen[pair]; !exists {
            seen[pair] = i
        }
    }

    
    ans := 0
    for i := 0; i < n; i++ {
        pair := strconv.Itoa(diffPre[i+1]) + "," + strconv.Itoa(xOrPre[i+1])
        if j, exists := seen[pair]; exists {
            if i-j > ans {
                ans = i - j
            }
        }
    }
    return ans
}