Add solution #2035

Author: JoshCrozier

README.md

@@ -1,4 +1,4 @@
-# 1,699 LeetCode solutions in JavaScript
+# 1,700 LeetCode solutions in JavaScript
 
 [https://leetcodejavascript.com](https://leetcodejavascript.com)
 
@@ -1560,6 +1560,7 @@
 2030|[Smallest K-Length Subsequence With Occurrences of a Letter](./solutions/2030-smallest-k-length-subsequence-with-occurrences-of-a-letter.js)|Hard|
 2032|[Two Out of Three](./solutions/2032-two-out-of-three.js)|Easy|
 2033|[Minimum Operations to Make a Uni-Value Grid](./solutions/2033-minimum-operations-to-make-a-uni-value-grid.js)|Medium|
+2035|[Partition Array Into Two Arrays to Minimize Sum Difference](./solutions/2035-partition-array-into-two-arrays-to-minimize-sum-difference.js)|Hard|
 2037|[Minimum Number of Moves to Seat Everyone](./solutions/2037-minimum-number-of-moves-to-seat-everyone.js)|Easy|
 2047|[Number of Valid Words in a Sentence](./solutions/2047-number-of-valid-words-in-a-sentence.js)|Easy|
 2053|[Kth Distinct String in an Array](./solutions/2053-kth-distinct-string-in-an-array.js)|Medium|

solutions/2035-partition-array-into-two-arrays-to-minimize-sum-difference.js

@@ -0,0 +1,93 @@
+/**
+ * 2035. Partition Array Into Two Arrays to Minimize Sum Difference
+ * https://leetcode.com/problems/partition-array-into-two-arrays-to-minimize-sum-difference/
+ * Difficulty: Hard
+ *
+ * You are given an integer array nums of 2 * n integers. You need to partition nums into two arrays
+ * of length n to minimize the absolute difference of the sums of the arrays. To partition nums,
+ * put each element of nums into one of the two arrays.
+ *
+ * Return the minimum possible absolute difference.
+ */
+
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var minimumDifference = function(nums) {
+  const n = nums.length / 2;
+  let result = Infinity;
+  const totalSum = nums.reduce((sum, num) => sum + num, 0);
+  const firstHalfSubsets = new Map();
+
+  for (let mask = 0; mask < (1 << n); mask++) {
+    let size = 0;
+    let subsetSum = 0;
+
+    for (let i = 0; i < n; i++) {
+      if ((mask & (1 << i)) !== 0) {
+        size++;
+        subsetSum += nums[i];
+      }
+    }
+
+    if (!firstHalfSubsets.has(size)) {
+      firstHalfSubsets.set(size, []);
+    }
+    firstHalfSubsets.get(size).push(subsetSum);
+  }
+
+  for (const [size, sums] of firstHalfSubsets) {
+    sums.sort((a, b) => a - b);
+  }
+
+  for (let mask = 0; mask < (1 << n); mask++) {
+    let size = 0;
+    let secondHalfSum = 0;
+
+    for (let i = 0; i < n; i++) {
+      if ((mask & (1 << i)) !== 0) {
+        size++;
+        secondHalfSum += nums[n + i];
+      }
+    }
+
+    const complementSize = n - size;
+    const firstHalfSums = firstHalfSubsets.get(complementSize);
+    const target = (totalSum - 2 * secondHalfSum) / 2;
+    const closestIndex = binarySearch(firstHalfSums, target);
+
+    if (closestIndex < firstHalfSums.length) {
+      result = Math.min(
+        result, Math.abs(totalSum - 2 * (secondHalfSum + firstHalfSums[closestIndex]))
+      );
+    }
+
+    if (closestIndex > 0) {
+      result = Math.min(
+        result, Math.abs(totalSum - 2 * (secondHalfSum + firstHalfSums[closestIndex - 1]))
+      );
+    }
+  }
+
+  return result;
+};
+
+function binarySearch(arr, target) {
+  let left = 0;
+  let right = arr.length - 1;
+
+  if (right < 0) return 0;
+
+  while (left < right) {
+    const mid = Math.floor((left + right) / 2);
+
+    if (arr[mid] < target) {
+      left = mid + 1;
+    } else {
+      right = mid;
+    }
+  }
+
+  return left;
+}