Generate All Permutations of Array in DSA Typescript - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Permutations Function for [1, 2]

What is the output of the following TypeScript code that generates all permutations of the array [1, 2]?

DSA Typescript

function permute(nums: number[]): number[][] {
  const result: number[][] = [];
  function backtrack(start: number) {
    if (start === nums.length) {
      result.push([...nums]);
      return;
    }
    for (let i = start; i < nums.length; i++) {
      [nums[start], nums[i]] = [nums[i], nums[start]];
      backtrack(start + 1);
      [nums[start], nums[i]] = [nums[i], nums[start]];
    }
  }
  backtrack(0);
  return result;
}

console.log(permute([1, 2]));

A [[1,2],[2,1]]

B [[2,1],[1,2]]

C [[1,2]]

D [[2,1]]

💡 Hint

Think about all ways to arrange two numbers.

The function generates all permutations by swapping elements. For [1, 2], the permutations are [1, 2] and [2, 1].

❓ Predict Output

intermediate

Number of Permutations for Array [1, 2, 3]

What is the number of permutations generated by the following code for the array [1, 2, 3]?

DSA Typescript

function permute(nums: number[]): number[][] {
  const result: number[][] = [];
  function backtrack(start: number) {
    if (start === nums.length) {
      result.push([...nums]);
      return;
    }
    for (let i = start; i < nums.length; i++) {
      [nums[start], nums[i]] = [nums[i], nums[start]];
      backtrack(start + 1);
      [nums[start], nums[i]] = [nums[i], nums[start]];
    }
  }
  backtrack(0);
  return result;
}

const permutations = permute([1, 2, 3]);
console.log(permutations.length);

A 3

B 6

C 9

D 12

💡 Hint

Number of permutations of n distinct elements is n factorial.

For 3 elements, the number of permutations is 3! = 6.

🔧 Debug

advanced

Identify the Error in Permutation Code

What error will this TypeScript code produce when trying to generate permutations of [1, 2, 3]?

DSA Typescript

function permute(nums: number[]): number[][] {
  const result: number[][] = [];
  function backtrack(start: number) {
    if (start === nums.length) {
      result.push(nums);
      return;
    }
    for (let i = start; i < nums.length; i++) {
      [nums[start], nums[i]] = [nums[i], nums[start]];
      backtrack(start + 1);
      [nums[start], nums[i]] = [nums[i], nums[start]];
    }
  }
  backtrack(0);
  return result;
}

console.log(permute([1, 2, 3]));

A The output contains multiple references to the same array, causing all permutations to be identical.

B SyntaxError due to missing semicolon.

C TypeError because result.push is called with a number instead of an array.

D Runtime error due to infinite recursion.

💡 Hint

Check how arrays are added to the result.

The code pushes the original nums array reference multiple times without copying it, so all entries in result point to the same array, which ends up as the last permutation.

🧠 Conceptual

advanced

Understanding Backtracking in Permutations

In the backtracking approach to generate permutations, why do we swap elements back after the recursive call?

A To remove duplicate permutations from the result.

B To sort the array after each permutation is generated.

C To avoid infinite recursion by limiting the depth.

D To restore the original array state so other permutations can be generated correctly.

💡 Hint

Think about how the array changes during recursion.

Swapping back restores the array to its previous state so the next iterations can generate new permutations without interference.

🚀 Application

expert

Permutations with Duplicate Elements

Given the array [1, 1, 2], which option correctly outputs all unique permutations using backtracking?

DSA Typescript

function permuteUnique(nums: number[]): number[][] {
  nums.sort((a, b) => a - b);
  const result: number[][] = [];
  const used = new Array(nums.length).fill(false);
  function backtrack(path: number[]) {
    if (path.length === nums.length) {
      result.push([...path]);
      return;
    }
    for (let i = 0; i < nums.length; i++) {
      if (used[i]) continue;
      if (i > 0 && nums[i] === nums[i - 1] && !used[i - 1]) continue;
      used[i] = true;
      path.push(nums[i]);
      backtrack(path);
      path.pop();
      used[i] = false;
    }
  }
  backtrack([]);
  return result;
}

console.log(permuteUnique([1, 1, 2]));

A [[1,1,2],[2,1,1]]

B [[1,1,2],[1,2,1],[2,1,1],[1,1,2]]

C [[1,1,2],[1,2,1],[2,1,1]]

D [[1,2,1],[2,1,1]]

💡 Hint

Duplicates are skipped by checking previous usage.

The code sorts the array and skips duplicates by checking if the previous identical element was used, ensuring unique permutations only.