Longest Balanced Parity Subarray

Array Easy 0 views

Like19

Longest Balanced Parity Subarray returns the maximum length of a contiguous segment with equal counts of even and odd numbers. In this dataset, the expected output is a length integer, not the subarray values. If no balanced segment exists, return zero.

The reliable method is prefix-difference mapping. Convert each element conceptually into +1 for even and -1 for odd, then track cumulative difference while scanning. When the same cumulative difference appears again, the segment between those positions has net zero difference, meaning equal even/odd count. Store earliest index of each difference to maximize segment length.

Judge coverage includes fully balanced arrays, mostly-one-parity arrays, mixed arrays with long balanced interiors, and empty input. Return only the maximum length integer. Complexity is linear with hash map support. Correctness depends on initializing difference zero at index -1 so prefixes that are already balanced are counted correctly. This pattern is a standard template for equal-count subarray detection under binary category transforms.

If no zero-difference span is found, return zero rather than negative or null values. In practical terms, this means initializing best length to zero and only updating when a valid repeated-difference boundary is detected, including the prefix-balanced case starting at index zero.

Examples

Example 1

Input

nums = [2,5,6,3,4,7]

Output

"2,5,6,3,4,7"

Explanation

The entire array has three evens and three odds.

Example 2

Input

nums = [1,3,5,7]

Output

Explanation

No contiguous subarray balances even and odd counts.

Example 3

Input

nums = [2,4,1,3,6,8,5,7]

Output

"2,4,1,3,6,8,5,7"

Explanation

The full range contains four even and four odd numbers.

Algorithm Flow

Recommendation Algorithm Flow for Longest Balanced Parity Subarray - Budibadu

Best Answers

java

import java.util.*;
class Solution {
    public int longest_balanced_parity_subarray(int[] nums) {
        Map<Integer, Integer> map = new HashMap<>();
        map.put(0, -1);
        int maxLen = 0, current = 0;
        for (int i = 0; i < nums.length; i++) {
            current += (nums[i] % 2 == 0) ? 1 : -1;
            if (map.containsKey(current)) maxLen = Math.max(maxLen, i - map.get(current));
            else map.put(current, i);
        }
        return maxLen;
    }
}

javascript

function longest_balanced_parity_subarray(nums) {
    const sumMap = {0: -1};
    let maxLen = 0, current = 0;
    for (let i = 0; i < nums.length; i++) {
        current += (nums[i] % 2 === 0) ? 1 : -1;
        if (current in sumMap) maxLen = Math.max(maxLen, i - sumMap[current]);
        else sumMap[current] = i;
    }
    return maxLen;
}

php

function longest_balanced_parity_subarray($nums) {
    $sumMap = [0 => -1];
    $maxLen = 0; $current = 0;
    foreach ($nums as $i => $x) {
        $current += ($x % 2 == 0) ? 1 : -1;
        if (isset($sumMap[$current])) $maxLen = max($maxLen, $i - $sumMap[$current]);
        else $sumMap[$current] = $i;
    }
    return $maxLen;
}

python

def longest_balanced_parity_subarray(nums: list) -> int:
    sum_map = {0: -1}
    max_len = 0
    current = 0
    for i, x in enumerate(nums):
        current += 1 if x % 2 == 0 else -1
        if current in sum_map:
            max_len = max(max_len, i - sum_map[current])
        else: sum_map[current] = i
    return max_len

rust

use std::collections::HashMap;
pub fn longest_balanced_parity_subarray(nums: Vec<i32>) -> i32 {
    let mut map = HashMap::new();
    map.insert(0, -1);
    let mut max_len = 0;
    let mut current = 0;
    for (i, &x) in nums.iter().enumerate() {
        current += if x % 2 == 0 { 1 } else { -1 };
        if let Some(&prev) = map.get(&current) {
            max_len = std::cmp::max(max_len, i as i32 - prev);
        } else {
            map.insert(current, i as i32);
        }
    }
    max_len
}

typescript

function longest_balanced_parity_subarray(nums: number[]): number {
    const sumMap: {[key: number]: number} = {0: -1};
    let maxLen = 0, current = 0;
    for (let i = 0; i < nums.length; i++) {
        current += (nums[i] % 2 === 0) ? 1 : -1;
        if (current in sumMap) maxLen = Math.max(maxLen, i - sumMap[current]);
        else sumMap[current] = i;
    }
    return maxLen;
}

Comments (0)

Join the Discussion

Share your thoughts, ask questions, or help others with this problem.

Longest Balanced Parity Subarray

Examples

Algorithm Flow

Best Answers

Solutions Coming Soon

Related Array Problems

Longest Consecutive Sequence

Garden Relay Count

Lantern Stall Picks

Festival Stall Order

Studio Lighting Slots

Seaport Ferry Gate Control

Comments (0)

Join the Discussion