Generate All Permutations of Array in DSA Javascript - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to start the permutation by calling the helper function.

DSA Javascript

function permute(nums) {
  const result = [];
  function backtrack(path, options) {
    if (options.length === 0) {
      result.push(path.slice());
      return;
    }
    for (let i = 0; i < options.length; i++) {
      path.push(options[i]);
      backtrack(path, options.filter((_, idx) => idx !== i));
      path.pop();
    }
  }
  [1];
  return result;
}

Drag options to blanks, or click blank then click option'

Abacktrack(nums, [])

Bbacktrack([], nums)

Cpermute(nums)

Dbacktrack(nums)

Attempts:

3 left

💡 Hint

Common Mistakes

Calling backtrack with arguments in wrong order.

Not passing an empty array as the initial path.

The helper function backtrack is called with an empty path and the full nums array as options to start generating permutations.

2fill in blank

medium

Complete the code to add the current path copy to the result when no options remain.

DSA Javascript

function backtrack(path, options) {
  if (options.length === 0) {
    result.[1](path.slice());
    return;
  }
  for (let i = 0; i < options.length; i++) {
    path.push(options[i]);
    backtrack(path, options.filter((_, idx) => idx !== i));
    path.pop();
  }
}

Drag options to blanks, or click blank then click option'

Apush

Bpop

Cslice

Dconcat

Attempts:

3 left

💡 Hint

Common Mistakes

Using pop instead of push.

Using slice or concat incorrectly.

We use push to add a copy of the current path to the result array when no options remain.

3fill in blank

hard

Fix the error in the for loop condition to iterate over all options.

DSA Javascript

for (let i = 0; i < [1]; i++) {
  path.push(options[i]);
  backtrack(path, options.filter((_, idx) => idx !== i));
  path.pop();
}

Drag options to blanks, or click blank then click option'

Aoptions.length

Bpath.length

Cnums.length

Di < 0

Attempts:

3 left

💡 Hint

Common Mistakes

Using path.length which changes during recursion.

Using nums.length which is fixed and not filtered.

The loop must run from 0 to options.length to cover all available options for the current step.

4fill in blank

hard

Fill both blanks to create a new options array excluding the current index.

DSA Javascript

backtrack(path, options.[1]((_, idx) => idx !== [2]));

Drag options to blanks, or click blank then click option'

Afilter

Bmap

Ci

Dslice

Attempts:

3 left

💡 Hint

Common Mistakes

Using map which transforms elements but does not remove.

Using slice which does not exclude specific indices.

We use filter to exclude the current index from options, so the next recursion step has one less element.

5fill in blank

hard

Fill all three blanks to complete the permutation function with helper and return result.

DSA Javascript

function permute([1]) {
  const result = [];
  function backtrack([2], options) {
    if (options.length === 0) {
      result.push([3]);
      return;
    }
    for (let i = 0; i < options.length; i++) {
      path.push(options[i]);
      backtrack(path, options.filter((_, idx) => idx !== i));
      path.pop();
    }
  }
  backtrack([], nums);
  return result;
}

Drag options to blanks, or click blank then click option'

Anums

Bpath

Cpath.slice()

Doptions

Attempts:

3 left

💡 Hint

Common Mistakes

Not copying path before pushing to result.

Using wrong parameter names in backtrack.

The function permute takes nums; backtrack takes path and options; when options is empty, push a copy of path using path.slice() to 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