🚀 Longest Balanced Subarray (Distinct Even = Distinct Odd)

Pradum Saindane — Tue, 10 Feb 2026 16:59:44 +0000

Recently, I worked on an interesting array problem:

A subarray is called balanced if the number of distinct even numbers is equal to the number of distinct odd numbers. The task is to return the length of the longest such subarray.

At first glance, this looks like a simple parity count problem. Naturally, thoughts go toward prefix sums or sliding window techniques. But the real challenge lies in one word distinct.

We are not counting how many even or odd elements exist. We are counting how many unique even and unique odd values exist inside a subarray. That changes the entire strategy.

Distinct counts are not monotonic. If we shrink a window, removing one element might reduce the distinct count or it might not. That makes classic two pointer shrinking approaches unreliable here.

Given the constraint (n ≤ 1500), an O(n²) solution is fully acceptable and optimal.

💡 Approach

For every starting index:
• Expand the subarray to the right.
• Maintain a frequency map.
• Track two counters:
• evenDistinct
• oddDistinct
• Whenever both are equal, update the maximum length.

This guarantees correctness while staying within acceptable time complexity.

✅ Java Implementation
import java.util.*;

class Solution {
public int longestBalanced(int[] nums) {
int n = nums.length;
int maxLen = 0;

    for (int i = 0; i < n; i++) {
        Map<Integer, Integer> freq = new HashMap<>();
        int evenDistinct = 0;
        int oddDistinct = 0;

        for (int j = i; j < n; j++) {
            int num = nums[j];

            if (!freq.containsKey(num)) {
                freq.put(num, 1);
                if (num % 2 == 0) evenDistinct++;
                else oddDistinct++;
            } else {
                freq.put(num, freq.get(num) + 1);
            }

            if (evenDistinct == oddDistinct) {
                maxLen = Math.max(maxLen, j - i + 1);
            }
        }
    }

    return maxLen;
}

}
📊 Complexity
• Time Complexity: O(n²)
• Space Complexity: O(n)

🎯 My POV

This problem reminded me that not every array problem fits into the “optimize to O(n)” mindset. Sometimes, understanding constraints and choosing the correct strategy is more important than forcing a pattern.

The biggest lesson:
When you see words like distinct or unique, pause before applying sliding window blindly.

Strong problem-solving is not about memorising patterns it’s about recognising when patterns don’t apply.

That’s where real growth happens as a developer.

HELLO WORLD

Pradum Saindane — Tue, 30 Dec 2025 08:58:29 +0000

Hello everyone,

I’m excited to publish my first post on dev.to and become part of this amazing developer community.

I have completed my Full-Stack Web Development journey and gained hands-on, industry-level experience in building end-to-end applications. My learning includes Java, Flutter, and modern web technologies, with a strong focus on writing clean, scalable, and maintainable code.

I created this dev.to profile to:
• Document my learning and projects
• Share practical development insights
• Improve through community feedback
• Prepare myself for professional software development roles

Going forward, I’ll be posting about:
• Full-stack concepts and real-world implementations
• Java and backend development topics
• Flutter and cross-platform app development
• Lessons learned from projects and problem-solving

I believe consistency, fundamentals, and community learning are key to long-term growth in tech. Looking forward to learning, sharing, and growing together.

Thank you for reading.

DEV Community: Pradum Saindane

🚀 Longest Balanced Subarray (Distinct Even = Distinct Odd)

HELLO WORLD