Generate All Permutations of Array in DSA Javascript - Build from Scratch

Generate All Permutations of Array

📖 Scenario: You are working on a puzzle game where you need to find all possible ways to arrange a set of unique numbers. This helps the game generate different challenges for players.

🎯 Goal: Build a program that generates all possible orderings (permutations) of a given array of numbers.

📋 What You'll Learn

Create an array called numbers with the exact values [1, 2, 3].

Create a variable called result to store all permutations as arrays.

Write a recursive function called permute that generates all permutations of the numbers array.

Call the permute function to fill result with all permutations.

Print the result array showing all permutations.

💡 Why This Matters

🌍 Real World

Generating all permutations is useful in games, puzzles, and testing different orderings of tasks or items.

💼 Career

Understanding recursion and permutations is important for software engineers working on algorithms, combinatorics, and problem-solving.

1

Create the initial array

Create an array called numbers with the exact values [1, 2, 3].

DSA Javascript

# Create the array called numbers with values [1, 2, 3]
// Your code here

Hint

Use const numbers = [1, 2, 3]; to create the array.

2

Create a variable to store permutations

Create a variable called result and set it to an empty array [] to store all permutations.

DSA Javascript

const numbers = [1, 2, 3];
// Create an empty array called result to store permutations
// Your code here

Hint

Use const result = []; to create an empty array.

3

Write the recursive function to generate permutations

Write a recursive function called permute that takes two parameters: arr (array to permute) and temp (current permutation array). Inside, if arr is empty, push a copy of temp into result. Otherwise, loop over arr, remove one element at a time, and call permute recursively with the remaining elements and updated temp.

DSA Javascript

const numbers = [1, 2, 3];
const result = [];

// Write the recursive function permute(arr, temp) here
// Your code here

Hint

Use recursion to build permutations by choosing each element and permuting the rest.

4

Call the function and print all permutations

Call the permute function with numbers and an empty array []. Then print the result array to display all permutations.

DSA Javascript

const numbers = [1, 2, 3];
const result = [];

function permute(arr, temp) {
    if (arr.length === 0) {
        result.push(temp.slice());
        return;
    }
    for (let i = 0; i < arr.length; i++) {
        const current = arr[i];
        const remaining = arr.slice(0, i).concat(arr.slice(i + 1));
        temp.push(current);
        permute(remaining, temp);
        temp.pop();
    }
}

// Call permute with numbers and empty array
// Print the result array
// Your code here

Hint

Call permute(numbers, []) and then console.log(result).

Practice

1. What does generating all permutations of an array mean?

easy

A. Finding the largest element in the array

B. Listing all possible orders of the array elements

C. Removing duplicate elements from the array

D. Sorting the array in ascending order

Solution

1. Step 1: Understand permutations

   Permutations are all possible ways to arrange elements in order.

2. Step 2: Apply to array elements

   Generating permutations means listing every possible order of the array's elements.

3. Final Answer:

   Listing all possible orders of the array elements -> Option B

4. Quick Check:

   Permutations = all orders [OK]

Hint: Permutations = all ways to arrange elements [OK]

Common Mistakes:

• Confusing permutations with sorting
• Thinking permutations remove duplicates
• Believing permutations find max element

2. Which of the following is the correct syntax to start a recursive function for generating permutations in JavaScript?

easy

A. function permute(arr l r) { }

B. function permute(arr, l, r) => { }

C. permute function(arr, l, r) { }

D. function permute(arr, l, r) { }

Solution

1. Step 1: Recall JavaScript function syntax

   Functions are declared with the keyword 'function', parameters inside parentheses separated by commas.

2. Step 2: Check each option

   function permute(arr, l, r) { } uses correct syntax: function name, parameters with commas, and braces. function permute(arr, l, r) => { } uses arrow syntax incorrectly. permute function(arr, l, r) { } has wrong order. function permute(arr l r) { } misses commas.

3. Final Answer:

   function permute(arr, l, r) { } -> Option D

4. Quick Check:

   Correct function syntax = function permute(arr, l, r) { } [OK]

Hint: Use 'function name(params) { }' for recursive functions [OK]

Common Mistakes:

• Using arrow syntax without proper parameters
• Missing commas between parameters
• Incorrect function keyword placement

3. What is the output of the following code?

function permute(arr, l, r) {
  if (l === r) {
    console.log(arr.join(''));
  } else {
    for (let i = l; i <= r; i++) {
      [arr[l], arr[i]] = [arr[i], arr[l]];
      permute(arr, l + 1, r);
      [arr[l], arr[i]] = [arr[i], arr[l]];
    }
  }
}
permute(['A', 'B', 'C'], 0, 2);

medium

A. ABC, ACB, BAC, BCA, CAB, CBA

B. ABC, BAC, CAB

C. ABC only

D. SyntaxError

Solution

1. Step 1: Understand the recursive swapping

   The function swaps elements starting from index l to r, generating all permutations by recursive calls.

2. Step 2: Trace output for ['A','B','C']

   All 6 permutations of 3 elements are printed: ABC, ACB, BAC, BCA, CAB, CBA.

3. Final Answer:

   ABC, ACB, BAC, BCA, CAB, CBA -> Option A

4. Quick Check:

   All 3-element permutations = ABC, ACB, BAC, BCA, CAB, CBA [OK]

Hint: Swapping + recursion = all permutations [OK]

Common Mistakes:

• Missing swap back step causing wrong output
• Printing partial permutations only
• Confusing output order

4. Identify the error in this permutation function:

function permute(arr, l, r) {
  if (l === r) {
    console.log(arr.join(''));
  } else {
    for (let i = l; i < r; i++) {
      [arr[l], arr[i]] = [arr[i], arr[l]];
      permute(arr, l + 1, r);
      [arr[l], arr[i]] = [arr[i], arr[l]];
    }
  }
}
permute(['X', 'Y', 'Z'], 0, 2);

medium

A. The for loop should use i <= r instead of i < r

B. The swap syntax is incorrect

C. The base case condition should be l > r

D. The function should not use recursion

Solution

1. Step 1: Check loop boundary

   The loop runs from i = l to i < r, so it misses the last index r.

2. Step 2: Correct loop condition

   Changing to i <= r includes the last element, ensuring all permutations are generated.

3. Final Answer:

   The for loop should use i <= r instead of i < r -> Option A

4. Quick Check:

   Loop boundary must include r [OK]

Hint: Loop to r inclusive for full permutations [OK]

Common Mistakes:

• Using i < r misses last element
• Incorrect swap syntax causing errors
• Wrong base case stopping recursion early

5. Given an array with duplicate elements ['A', 'B', 'A'], how can you modify the permutation function to avoid printing duplicate permutations?

hard

A. Use a set to track and skip already generated permutations

B. Remove duplicates from the array before permutation

C. Sort the array and skip swapping identical elements at the same recursion level

D. No modification needed; duplicates are automatically avoided

Solution

1. Step 1: Understand duplicates in permutations

   Duplicates cause repeated permutations when identical elements are swapped.

2. Step 2: Skip swapping identical elements

   Sorting the array and checking if the element was already swapped at the current recursion level avoids duplicates.

3. Final Answer:

   Sort the array and skip swapping identical elements at the same recursion level -> Option C

4. Quick Check:

   Skip identical swaps after sorting to avoid duplicates [OK]

Hint: Sort + skip identical swaps to avoid duplicate permutations [OK]

Common Mistakes:

• Removing duplicates loses valid permutations
• Using set only after generating all permutations (inefficient)
• Assuming duplicates are avoided automatically