Permutations with repetitive options

Author: edignot

src/sets/sets.js

@@ -44,6 +44,7 @@ export const getCartesianProductsUnlimitedSets = (...sets) => {
 // Permutations algorithm - ordered combinations of values, can be without or with repetition
 // All possible combination of items with or without repetition
 // One extra loop per extra element inside input array
+// Time complexity: Factorial O(n!) ( 4 * 3 * 2 * 1 => 24; 5 * 4 * 3 * 2 * 1 => 120)
 export const getAllPermutations = (options) => {
     const possibleOptions = [];
     if (options.length === 1) {
@@ -66,4 +67,24 @@ export const getAllPermutations = (options) => {
     return possibleOptions;
 };
 
-console.log(getAllPermutations(["a", "b", "c"]));
+// Permutation algorithm with repetitive values
+export const getAllPermutationsWithRepetition = (
+    options,
+    combinationLength
+) => {
+    const possibleOptions = [];
+    if (combinationLength === 1) return options.map((option) => [option]);
+    const partialOption = getAllPermutationsWithRepetition(
+        options,
+        combinationLength - 1
+    );
+
+    for (const option of options) {
+        for (const existingOption of partialOption) {
+            possibleOptions.push([option].concat(existingOption));
+        }
+    }
+    return possibleOptions;
+};
+
+console.log(getAllPermutationsWithRepetition([1, 2, 3], 2).length);

src/sets/sets.test.js

@@ -2,6 +2,7 @@ import {
     getCartesianProductsForOf,
     getCartesianProductsUnlimitedSets,
     getAllPermutations,
+    getAllPermutationsWithRepetition,
 } from "./sets";
 
 describe("Cartesian Product", () => {
@@ -71,3 +72,42 @@ describe("Permutations", () => {
         ]);
     });
 });
+
+describe("Permutations with repetitive items, predefined combination length", () => {
+    test("Get All Permutations with repetitive items", () => {
+        expect(getAllPermutationsWithRepetition([1, 2, 3], 3)).toStrictEqual([
+            [1, 1, 1],
+            [1, 1, 2],
+            [1, 1, 3],
+            [1, 2, 1],
+            [1, 2, 2],
+            [1, 2, 3],
+            [1, 3, 1],
+            [1, 3, 2],
+            [1, 3, 3],
+            [2, 1, 1],
+            [2, 1, 2],
+            [2, 1, 3],
+            [2, 2, 1],
+            [2, 2, 2],
+            [2, 2, 3],
+            [2, 3, 1],
+            [2, 3, 2],
+            [2, 3, 3],
+            [3, 1, 1],
+            [3, 1, 2],
+            [3, 1, 3],
+            [3, 2, 1],
+            [3, 2, 2],
+            [3, 2, 3],
+            [3, 3, 1],
+            [3, 3, 2],
+            [3, 3, 3],
+        ]);
+    });
+    test("Get All Permutations with repetitive items", () => {
+        expect(getAllPermutationsWithRepetition([1], 2)).toStrictEqual([
+            [1, 1],
+        ]);
+    });
+});