Add Tug of War solution using backtracking

Backtracking/TugOfWar.js

@@ -0,0 +1,49 @@
+// Given an array of n integers, we need to divide them 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 n = arr.length;
+ let totalSum = arr.reduce((a, b) => a + b, 0);
+ let minimumDiff = Number.MAX_VALUE;
+ let result = [];
+
+ function isSafe(index, subset) {
+ return index < n;
+ }
+
+ function backtrack(subset = [], index = 0) {
+ if (index === n) {
+ 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.
+ if (isSafe(index, subset)) {
+ backtrack([...subset, arr[index]], index + 1);
+ }
+
+ // Exclude the current element.
+ if (isSafe(index, subset)) {
+ backtrack([...subset], index + 1);
+ }
+ }
+
+ backtrack();
+ return result;
+}
+
+export { tugOfWar };

Backtracking/tests/TugOfWar.test.js

@@ -0,0 +1,11 @@
+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).toBeLessThanOrEqual(1); // Here we assume that the difference could be 0 or 1 for this test case.
+ });
+});