🐂 Beginner-Friendly Guide 'Longest Balanced Subarray I' - Problem 3719 (C++, Python, JavaScript)

Navigating through arrays to find specific patterns is a fundamental skill for any developer. This problem challenges us to look beyond simple element counts and instead focus on the diversity of values within a contiguous range. It is a perfect exercise for mastering the use of hash sets to track uniqueness while iterating through data.

---

Problem Summary

You're given:
An array of integers called nums.

Your goal:
Find the length of the longest subarray where the count of distinct even numbers is exactly equal to the count of distinct odd numbers.

---

Intuition

The core of this problem lies in the word "distinct." If a subarray contains the number 2 three times, it only counts as one distinct even number. To handle this efficiently, we can use a nested loop strategy to examine every possible subarray.

For every starting position , we expand to every possible ending position . As we expand, we keep track of the unique even and odd numbers we have encountered using a "Set" or a "Hash Map." A Set is ideal here because it automatically handles duplicates for us: if we add the number 2 twice, the Set size only increases once. Whenever the size of our even set equals the size of our odd set, we have found a "balanced" subarray, and we update our maximum length.

---

Walkthrough: Understanding the Examples

Let's look at Example 3: nums = [1, 2, 3, 2]

1. Start at index 0 (value 1):
2. Subarray [1, 2]: Even set = {2}, Odd set = {1}. Sizes are . Length is 2.
3. Subarray [1, 2, 3]: Even set = {2}, Odd set = {1, 3}. Sizes are .

4. Subarray [1, 2, 3, 2]: Even set = {2}, Odd set = {1, 3}. Sizes are .

5. Start at index 1 (value 2):

6. Subarray [2, 3]: Even set = {2}, Odd set = {3}. Sizes are . Length is 2.

7. Subarray [2, 3, 2]: Even set = {2}, Odd set = {3}. Sizes are . Length is 3. (New Max)

8. Start at index 2 (value 3):

9. Subarray [3, 2]: Even set = {2}, Odd set = {3}. Sizes are . Length is 2.

The longest length found is 3.

---

C++ Solution

#include <vector>
#include <unordered_set>
#include <algorithm>

using namespace std;

class Solution {
public:
    int longestBalanced(vector<int>& nums) {
        int max_ans = 0;
        int n = nums.size();

        // Check every possible starting point
        for (int i = 0; i < n; i++) {
            unordered_set<int> even_set;
            unordered_set<int> odd_set;

            // Expand the subarray to every possible ending point
            for (int j = i; j < n; j++) {
                if (nums[j] % 2 == 0) {
                    even_set.insert(nums[j]);
                } else {
                    odd_set.insert(nums[j]);
                }

                // Check if the number of distinct evens equals distinct odds
                if (even_set.size() == odd_set.size()) {
                    max_ans = max(max_ans, j - i + 1);
                }
            }
        }
        return max_ans;
    }
};

---

Python Solution

class Solution:
    def longestBalanced(self, nums: list[int]) -> int:
        max_ans = 0
        n = len(nums)

        # Outer loop sets the start of the subarray
        for i in range(n):
            even_set = set()
            odd_set = set()

            # Inner loop expands the end of the subarray
            for j in range(i, n):
                if nums[j] % 2 == 0:
                    even_set.add(nums[j])
                else:
                    odd_set.add(nums[j])

                # Compare the count of unique elements
                if len(even_set) == len(odd_set):
                    max_ans = max(max_ans, j - i + 1)

        return max_ans

---

JavaScript Solution

/**
 * @param {number[]} nums
 * @return {number}
 */
var longestBalanced = function(nums) {
    let maxAns = 0;
    const n = nums.length;

    for (let i = 0; i < n; i++) {
        let evenSet = new Set();
        let oddSet = new Set();

        for (let j = i; j < n; j++) {
            if (nums[j] % 2 === 0) {
                evenSet.add(nums[j]);
            } else {
                oddSet.add(nums[j]);
            }

            // In JS, we use .size to get the number of unique elements
            if (evenSet.size === oddSet.size) {
                maxAns = Math.max(maxAns, j - i + 1);
            }
        }
    }
    return maxAns;
};

---

Key Takeaways

• Set Data Structures: Using a Set is the most efficient way to track "distinct" or "unique" items because it ignores duplicate entries automatically.
• Subarray Brute Force: For smaller constraints (like ), an approach using nested loops is often acceptable and much easier to implement than complex sliding windows.
• Parity Logic: Using the modulo operator % 2 is the standard way to distinguish between even and odd numbers in programming.

---

Final Thoughts

This problem is a fantastic introduction to data integrity and filtering. In real-world systems, such as search engines or e-commerce filters, we often need to ensure that different categories of data are represented equally or meet specific ratio requirements. Mastering how to count unique occurrences while scanning through a stream of data is a skill you will use throughout your career.