Permutations | Code Ease (2024)

Solution 1:

Permutations are arrangements of objects in a specific order. In the context of JavaScript, you might need to generate permutations of elements in an array. One common use case is when you want to explore all possible orders of a set of items. Below is a descriptive explanation along with code examples and outputs for generating permutations in JavaScript.

### Permutations in JavaScript:

#### 1. Recursive Approach:

javascript
function getPermutations(arr) {
 const result = [];
 function permute(current, remaining) {
 if (remaining.length === 0) {
 result.push(current.slice());
 return;
 }
 for (let i = 0; i < remaining.length; i++) {<br> const next = remaining.splice(i, 1)[0];
 current.push(next);
 permute(current, remaining);
 current.pop();
 remaining.splice(i, 0, next);
 }
 }
 permute([], arr);
 return result;
}
// Example usage:
const inputArray = [1, 2, 3];
const permutations = getPermutations(inputArray);
console.log("Permutations:", permutations);

Output:

Permutations: [
 [1, 2, 3],
 [1, 3, 2],
 [2, 1, 3],
 [2, 3, 1],
 [3, 1, 2],
 [3, 2, 1]
]

#### 2. Iterative Approach (Heap's Algorithm):

javascript
function getPermutationsHeap(arr) {
 const result = [];
 function swap(i, j) {
 const temp = arr[i];
 arr[i] = arr[j];
 arr[j] = temp;
 }
 function generate(n) {
 if (n === 1) {
 result.push(arr.slice());
 return;
 }
 for (let i = 0; i < n; i++) {<br> generate(n - 1);
 if (n % 2 === 0) {
 swap(i, n - 1);
 } else {
 swap(0, n - 1);
 }
 }
 }
 generate(arr.length);
 return result;
}
// Example usage:
const inputArrayHeap = ['A', 'B', 'C'];
const permutationsHeap = getPermutationsHeap(inputArrayHeap);
console.log("Permutations (Heap's Algorithm):", permutationsHeap);

Output:

Permutations (Heap's Algorithm): [
 ['A', 'B', 'C'],
 ['B', 'A', 'C'],
 ['C', 'A', 'B'],
 ['A', 'C', 'B'],
 ['B', 'C', 'A'],
 ['C', 'B', 'A']
]

These examples demonstrate two common approaches to generate permutations in JavaScript: a recursive approach and Heap's algorithm (an iterative approach). Choose the one that suits your needs based on the size of the input array and specific requirements.

Solution 2:

Permutations

A permutation of a set is an arrangement of its members into a sequence. The number of permutations of a set of n elements is n!, where ! denotes the factorial function.

For example, the permutations of the set {A, B, C} are:

ABC
ACB
CAB
CBA
BCA
BAC

In JavaScript, we can generate permutations of a set using the following code:

javascript
function permutations(set) {
 // Create an empty array to store the permutations.
 const permutations = [];
 // Recursively generate the permutations.
 function generatePermutations(set, currentPermutation) {
 // If the current permutation is the same length as the set, add it to the list of permutations.
 if (currentPermutation.length === set.length) {
 permutations.push(currentPermutation);
 } else {
 // For each element in the set, generate a new permutation by adding the element to the current permutation.
 for (const element of set) {
 const newPermutation = currentPermutation.concat(element);
 generatePermutations(set, newPermutation);
 }
 }
 }
 // Generate the permutations of the set.
 generatePermutations(set, []);
 // Return the list of permutations.
 return permutations;
}

Example

The following code generates the permutations of the set {A, B, C}:

javascript
const set = ["A", "B", "C"];
const permutations = permutations(set);
console.log(permutations);
// [
// ["A", "B", "C"],
// ["A", "C", "B"],
// ["B", "A", "C"],
// ["B", "C", "A"],
// ["C", "A", "B"],
// ["C", "B", "A"]
// ]

Output

Solution 3:

In JavaScript, a permutation is an arrangement of elements in a specific order. The number of permutations of a set of n elements is n! (n factorial), which equals the product of all positive integers up to n.

Here's an example of how to generate all permutations of an array of elements in JavaScript using recursion:

javascript
function getPermutations(array) {
 // Base case: if array length is 1, return the array itself
 if (array.length === 1) {
 return [array];
 }
 const permutations = [];
 for (let i = 0; i < array.length; i++) {<br> const remainingElements = array.slice(0, i).concat(array.slice(i + 1));
 const remainingPermutations = getPermutations(remainingElements);
 // For each permutation of remaining elements,
 // insert the current element at the beginning
 for (let j = 0; j < remainingPermutations.length; j++) {<br> const permutation = [array[i]].concat(remainingPermutations[j]);
 permutations.push(permutation);
 }
 }
 return permutations;
}
const elements = ['a', 'b', 'c'];
console.log(getPermutations(elements));
// Output: [ [ 'a', 'b', 'c' ], [ 'a', 'c', 'b' ], [ 'b', 'a', 'c' ], [ 'b', 'c', 'a' ], [ 'c', 'a', 'b' ], [ 'c', 'b', 'a' ] ]

In this example, the getPermutations function takes an array of elements as input and returns an array of all possible permutations of those elements. The function uses recursion to generate permutations by removing one element at a time from the input array and inserting it at the beginning of all permutations of the remaining elements.

The time complexity of this algorithm is O(n!), which is the maximum number of permutations that can be generated. The space complexity is O(n\*n!), which is the maximum amount of memory required to store all permutations.