Solution to "Longest Balanced Subarray I" problem

Author: dkoval

src/main/java/com/github/dkoval/leetcode/challenge/LongestBalancedSubarray1.java

@@ -0,0 +1,47 @@
+package com.github.dkoval.leetcode.challenge;
+
+import java.util.HashSet;
+
+/**
+ * <a href="https://leetcode.com/problems/longest-balanced-subarray-i/">Longest Balanced Subarray I</a>
+ * <p>
+ * You are given an integer array nums.
+ * <p>
+ * A subarray is called balanced if the number of distinct even numbers in the subarray is equal to the number of distinct odd numbers.
+ * <p>
+ * Return the length of the longest balanced subarray.
+ * <p>
+ * Constraints:
+ * <ul>
+ *  <li>1 <= nums.length <= 1500</li>
+ *  <li>1 <= nums[i] <= 10^5</li>
+ * </ul>
+ */
+public interface LongestBalancedSubarray1 {
+
+    int longestBalanced(int[] nums);
+
+    class LongestBalancedSubarray1Rev1 implements LongestBalancedSubarray1 {
+
+        @Override
+        public int longestBalanced(int[] nums) {
+            final var n = nums.length;
+
+            // brute force: try every subarray
+            var best = 0;
+            for (var left = 0; left < n; left++) {
+                final var even = new HashSet<Integer>();
+                final var odds = new HashSet<Integer>();
+                for (var right = left; right < n; right++) {
+                    final var xs = (nums[right] % 2 == 0) ? even : odds;
+                    xs.add(nums[right]);
+
+                    if (even.size() == odds.size()) {
+                        best = Math.max(best, right - left + 1);
+                    }
+                }
+            }
+            return best;
+        }
+    }
+}

src/test/kotlin/com/github/dkoval/leetcode/challenge/LongestBalancedSubarray1Test.kt

@@ -0,0 +1,55 @@
+package com.github.dkoval.leetcode.challenge
+
+import com.github.dkoval.leetcode.challenge.LongestBalancedSubarray1.LongestBalancedSubarray1Rev1
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Nested
+import org.junit.jupiter.api.extension.ExtensionContext
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.Arguments
+import org.junit.jupiter.params.provider.Arguments.arguments
+import org.junit.jupiter.params.provider.ArgumentsProvider
+import org.junit.jupiter.params.provider.ArgumentsSource
+import org.junit.jupiter.params.support.ParameterDeclarations
+import java.util.stream.Stream
+
+internal class LongestBalancedSubarray1Test {
+
+    class InputArgumentsProvider : ArgumentsProvider {
+
+        override fun provideArguments(
+            parameters: ParameterDeclarations,
+            context: ExtensionContext
+        ): Stream<out Arguments> = Stream.of(
+            arguments(
+                intArrayOf(2, 5, 4, 3),
+                4
+            ),
+            arguments(
+                intArrayOf(3, 2, 2, 5, 4),
+                5
+            ),
+            arguments(
+                intArrayOf(1, 2, 3, 2),
+                3
+            )
+        )
+    }
+
+    @Nested
+    inner class LongestBalancedSubarray1Rev1Test {
+
+        @ParameterizedTest
+        @ArgumentsSource(InputArgumentsProvider::class)
+        fun `should return the length of the longest balanced subarray`(
+            nums: IntArray,
+            expected: Int
+        ) {
+            LongestBalancedSubarray1Rev1().test(nums, expected)
+        }
+    }
+}
+
+private fun LongestBalancedSubarray1.test(nums: IntArray, expected: Int) {
+    val actual = longestBalanced(nums)
+    assertEquals(expected, actual)
+}