feat(backtracking): Permutations II

Author: jeantimex

README.md

@@ -110,6 +110,7 @@ A collection of JavaScript problems and solutions for studying algorithms.
 - [Combination Sum II](src/backtracking/combination-sum-ii.js)
 - [Combination Sum III](src/backtracking/combination-sum-iii.js)
 - [Permutations](src/backtracking/permutations.js)
+- [Permutations II](src/backtracking/permutations-ii.js)
 
 ### Linked List
 

src/backtracking/__tests__/permutations-ii-test.js

@@ -0,0 +1,25 @@
+import { assert } from 'chai';
+import permuteUnique from '../permutations-ii';
+
+const sorter = (a, b) => {
+  if (a.length === b.length) {
+    return a.toString().localeCompare(b.toString());
+  }
+  return a.length - b.length;
+};
+
+describe('Permutations II', () => {
+  const testCases = [
+    [[1, 2, 3], [[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]]],
+    [[1, 1, 2], [[1, 1, 2], [1, 2, 1], [2, 1, 1]]],
+  ];
+
+  testCases.forEach((testCase, index) => {
+    it(`should get the permutations using back tracking ${index}`, () => {
+      const nums = testCase[0];
+      const expected = testCase[1];
+      const actual = permuteUnique(nums);
+      assert(actual.sort(sorter), expected.sort(sorter));
+    });
+  });
+});

src/backtracking/permutations-ii.js

@@ -0,0 +1,45 @@
+/**
+ * Permutations II
+ *
+ * Given a collection of numbers that might contain duplicates, return all possible unique permutations.
+ *
+ * For example,
+ * [1,1,2] have the following unique permutations:
+ * [
+ *   [1,1,2],
+ *   [1,2,1],
+ *   [2,1,1]
+ * ]
+ */
+
+/**
+ * @param {number[]} nums
+ * @return {number[][]}
+ */
+const permuteUnique = nums => {
+  const results = [];
+  nums.sort((a, b) => a - b);
+  backtracking(nums, {}, [], results);
+  return results;
+};
+
+const backtracking = (nums, used, solution, results) => {
+  if (solution.length === nums.length) {
+    results.push(solution.slice());
+    return;
+  }
+
+  for (let i = 0; i < nums.length; i++) {
+    if (used[i] || (i > 0 && nums[i] === nums[i - 1] && !used[i - 1])) {
+      continue;
+    }
+
+    solution.push(nums[i]);
+    used[i] = true;
+    backtracking(nums, used, solution, results);
+    solution.pop();
+    used[i] = false;
+  }
+};
+
+export default permuteUnique;