Implemented Partition Problem, Recursive problem

DIRECTORY.md

@@ -160,6 +160,7 @@
   * [NumberOfIslands](Graphs/NumberOfIslands.js)
   * [PrimMST](Graphs/PrimMST.js)
 * **Hashes**
+  * [MD5](Hashes/MD5.js)
   * [SHA1](Hashes/SHA1.js)
   * [SHA256](Hashes/SHA256.js)
 * **Maths**
@@ -302,6 +303,7 @@
   * [Palindrome](Recursive/Palindrome.js)
   * [SubsequenceRecursive](Recursive/SubsequenceRecursive.js)
   * [TowerOfHanoi](Recursive/TowerOfHanoi.js)
+  * [TugOfWar](Recursive/TugOfWar.js)
 * **Search**
   * [BinarySearch](Search/BinarySearch.js)
   * [ExponentialSearch](Search/ExponentialSearch.js)

Recursive/TugOfWar.js

@@ -0,0 +1,37 @@
+/**
+ * @see https://www.geeksforgeeks.org/tug-of-war/
+ * Divides the given array into two subsets such that the difference between their sums is minimized.
+ * @param {number[]} arr - The array of integers.
+ * @returns {Array.<number[]>} Two subsets with minimized sum difference.
+ */
+
+function tugOfWar(arr) {
+  const totalSum = arr.reduce((a, b) => a + b, 0)
+  let minimumDiff = totalSum
+  let result = [arr, []]
+
+  function recurse(subset, index) {
+    if (index === arr.length) {
+      const currentSubsetSum = subset.reduce((a, b) => a + b, 0)
+      const otherSubsetSum = totalSum - currentSubsetSum
+      const currentDiff = Math.abs(currentSubsetSum - otherSubsetSum)
+
+      if (currentDiff < minimumDiff) {
+        minimumDiff = currentDiff
+        result = [subset, arr.filter((x) => !subset.includes(x))]
+      }
+      return
+    }
+
+    // Include the current element.
+    recurse([...subset, arr[index]], index + 1)
+
+    // Exclude the current element.
+    recurse([...subset], index + 1)
+  }
+
+  recurse([], 0)
+  return result
+}
+
+export { tugOfWar }

Recursive/test/TugOfWar.test.js

@@ -0,0 +1,12 @@
+import { tugOfWar } from '../TugOfWar'
+
+describe('tugOfWar', () => {
+  it('should divide array into two subsets with minimized sum difference', () => {
+    const arr = [3, 4, 5, -3, 100, 1, 89, 54, 23, 20]
+    const [subset1, subset2] = tugOfWar(arr)
+    const diff = Math.abs(
+      subset1.reduce((a, b) => a + b, 0) - subset2.reduce((a, b) => a + b, 0)
+    )
+    expect(diff).toBe(1)
+  })
+})