Add Generate Permutations backtracking algorithm

Author: IcarusTheFly

Diff for: backtracking/GeneratePermutations.ts

@@ -0,0 +1,38 @@
+/*
+ * Problem Statement: Generate all distinct permutations of an array (all permutations should be in sorted order);
+ *
+ * What is permutations?
+ * - Permutation means possible arrangements in a set (here it is an array);
+ *
+ * Reference to know more about permutations:
+ * - https://www.britannica.com/science/permutation
+ *
+ */
+
+const swap = <T>(arr: T[], i: number, j: number): T[] => {
+  const newArray: T[] = [...arr]
+
+  const temp: T = newArray[i]
+  newArray[i] = newArray[j]
+  newArray[j] = temp
+
+  return newArray
+}
+
+const permutations = <T>(arr: T[]): T[][] => {
+  const P: T[][] = []
+  const permute = (arr: T[], low: number, high: number): T[][] => {
+    if (low === high) {
+      P.push([...arr])
+      return P
+    }
+    for (let i = low; i <= high; i++) {
+      arr = swap(arr, low, i)
+      permute(arr, low + 1, high)
+    }
+    return P
+  }
+  return permute(arr, 0, arr.length - 1)
+}
+
+export { permutations }

Diff for: backtracking/test/GeneratePermutations.test.ts

@@ -0,0 +1,39 @@
+import { permutations } from '../GeneratePermutations'
+
+const factorial = (n: number): number => {
+  if (n === 0 || n === 1) {
+    return 1
+  }
+  return n * factorial(n - 1)
+}
+
+describe('Permutations', () => {
+  it('Permutations of [a]', () => {
+    const perms = permutations(['a'])
+    expect(perms).toHaveLength(factorial(1))
+    expect(perms).toContainEqual(['a'])
+  })
+
+  it('Permutations of [true, false]', () => {
+    const perms = permutations([true, false])
+    expect(perms).toHaveLength(factorial(2))
+    expect(perms).toContainEqual([true, false])
+    expect(perms).toContainEqual([false, true])
+  })
+
+  it('Permutations of [1, 2, 3]', () => {
+    const perms = permutations([1, 2, 3])
+    expect(perms).toHaveLength(factorial(3))
+    expect(perms).toContainEqual([1, 2, 3])
+    expect(perms).toContainEqual([1, 3, 2])
+    expect(perms).toContainEqual([2, 1, 3])
+    expect(perms).toContainEqual([2, 3, 1])
+    expect(perms).toContainEqual([3, 1, 2])
+    expect(perms).toContainEqual([3, 2, 1])
+  })
+
+  it('Permutation counts across larger input arrays', () => {
+    expect(permutations([1, 2, 3, 4, 5, 6, 7, 8])).toHaveLength(factorial(8))
+    expect(permutations([1, 2, 3, 4, 5, 6, 7, 8, 9])).toHaveLength(factorial(9))
+  })
+})