Generate All Permutations of Array in DSA Java - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to swap two elements in the array.

DSA Java

int temp = arr[[1]];
arr[[1]] = arr[j];
arr[j] = temp;

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

Ai

Bj

C0

Darr.length

Attempts:

3 left

💡 Hint

Common Mistakes

Using j instead of i for the first element causes incorrect swapping.

Using arr.length as index causes ArrayIndexOutOfBoundsException.

We swap the element at index i with the element at index j to generate permutations.

2fill in blank

medium

Complete the code to generate permutations recursively by fixing the element at index {{BLANK_1}}.

DSA Java

public void permute(int[] arr, int [1], int n) {
    if ([1] == n) {
        printArray(arr);
        return;
    }
    for (int j = [1]; j < n; j++) {
        swap(arr, [1], j);
        permute(arr, [1] + 1, n);
        swap(arr, [1], j);
    }
}

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

Aindex

Bi

Cpos

Dstart

Attempts:

3 left

💡 Hint

Common Mistakes

Using a variable name not consistent with the rest of the code.

Confusing the variable with the array length.

The variable i is commonly used as the current index to fix in the permutation recursion.

3fill in blank

hard

Fix the error in the base case condition to correctly print the permutation when all positions are fixed.

DSA Java

if (i [1] n) {
    printArray(arr);
    return;
}

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

A<

B>

C==

D!=

Attempts:

3 left

💡 Hint

Common Mistakes

Using less than or greater than causes premature or missed base case.

Using not equal causes infinite recursion.

The base case is when the current index i equals n, meaning all elements are fixed and the permutation is ready to print.

4fill in blank

hard

Fill both blanks to complete the swap and recursive call inside the loop.

DSA Java

for (int j = [1]; j < n; j++) {
    swap(arr, [2], j);
    permute(arr, [2] + 1, n);
    swap(arr, [2], j);
}

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

Ai

Bj

C0

Dn

Attempts:

3 left

💡 Hint

Common Mistakes

Using j as the first argument in swap causes incorrect swapping.

Using 0 or n as indices causes errors.

The loop starts at i, and swaps elements at i and j. The recursive call fixes the next position i+1.

5fill in blank

hard

Fill all three blanks to complete the method signature and the base case condition.

DSA Java

public void permute(int[] [1], int i, int [2]) {
    if (i [3] [2]) {
        printArray(arr);
        return;
    }
    // rest of code
}

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

Aarr

Blength

C==

Dsize

Attempts:

3 left

💡 Hint

Common Mistakes

Using length as a parameter name conflicts with array property.

Using incorrect comparison operator in base case.

The array parameter is named arr, the length parameter is named size, and the base case checks if i == size.

Practice

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

easy

A. Sorting the array in ascending order

B. Listing all possible orders of the array elements

C. Finding the largest element in the array

D. Removing duplicate elements from the array

Solution

1. Step 1: Understand permutations

   Permutations are all possible ways to arrange elements in order.

2. Step 2: Apply to array

   Generating all permutations means listing every possible order of the array 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
• Mixing permutations with finding max element

2. Which Java method signature correctly defines a function to generate permutations of an integer array?

easy

A. public void generatePermutations(int[] arr, int start)

B. void generatePermutations(int arr[], int start) public

C. public int generatePermutations(int[] arr, int start)

D. public static generatePermutations(int[] arr, int start)

Solution

1. Step 1: Check method signature syntax

   In Java, method signature starts with access modifier, return type, method name, and parameters.

2. Step 2: Validate options

   public void generatePermutations(int[] arr, int start) correctly uses 'public void' and parameter types. void generatePermutations(int arr[], int start) public has wrong order. public int generatePermutations(int[] arr, int start) returns int but should be void. public static generatePermutations(int[] arr, int start) misses return type.

3. Final Answer:

   public void generatePermutations(int[] arr, int start) -> Option A

4. Quick Check:

   Correct Java method syntax = public void generatePermutations(int[] arr, int start) [OK]

Hint: Java method = access + return type + name + params [OK]

Common Mistakes:

• Missing return type in method signature
• Incorrect order of access modifier and return type
• Wrong return type for void methods

3. What is the output of the following Java code snippet?

public class PermTest {
  public static void permute(int[] arr, int start) {
    if (start == arr.length - 1) {
      for (int num : arr) System.out.print(num + " ");
      System.out.println();
      return;
    }
    for (int i = start; i < arr.length; i++) {
      int temp = arr[start];
      arr[start] = arr[i];
      arr[i] = temp;
      permute(arr, start + 1);
      temp = arr[start];
      arr[start] = arr[i];
      arr[i] = temp;
    }
  }
  public static void main(String[] args) {
    int[] arr = {1, 2};
    permute(arr, 0);
  }
}

medium

A. 1 2 \n2 1 \n

B. 1 2 \n1 2 \n

C. 2 1 \n1 2 \n

D. No output

Solution

1. Step 1: Trace recursive calls for arr = {1, 2}

   Start with start=0, swap arr[0] with arr[0] (no change), recurse with start=1, print 1 2. Then swap back, swap arr[0] with arr[1], arr becomes {2,1}, recurse start=1, print 2 1.

2. Step 2: Confirm output lines

   Two lines printed: '1 2' and '2 1', each followed by newline.

3. Final Answer:

   1 2 \n2 1 \n -> Option A

4. Quick Check:

   All permutations of [1,2] = 1 2 and 2 1 [OK]

Hint: Swap and recurse to generate permutations [OK]

Common Mistakes:

• Forgetting to swap back after recursion
• Printing before reaching last index
• Confusing order of swaps

4. Identify the error in this Java method for generating permutations:

public void permute(int[] arr, int start) {
  if (start == arr.length) {
    System.out.println(Arrays.toString(arr));
    return;
  }
  for (int i = start; i < arr.length; i++) {
    int temp = arr[start];
    arr[start] = arr[i];
    arr[i] = temp;
    permute(arr, start + 1);
  }
}

medium

A. Using Arrays.toString incorrectly

B. Incorrect base case condition

C. Missing swap back after recursive call

D. Wrong loop range in for loop

Solution

1. Step 1: Analyze swapping logic

   After swapping arr[start] and arr[i], the method calls recursion but does not swap back, so array stays changed for next iterations.

2. Step 2: Identify missing swap back

   To restore original array before next iteration, swap back is needed after recursive call.

3. Final Answer:

   Missing swap back after recursive call -> Option C

4. Quick Check:

   Swap back needed to restore array [OK]

Hint: Always swap back after recursion to restore array [OK]

Common Mistakes:

• Not swapping back after recursion
• Incorrect base case index
• Misusing Arrays.toString for printing

5. You want to generate all permutations of an array with possible duplicate elements, but avoid printing duplicate permutations. Which approach is best?

hard

A. Use a HashSet to store and print only unique permutations after generating all

B. Only swap elements if they are different values

C. Generate all permutations without any checks and print all

D. Sort the array first and skip swapping duplicate elements during recursion

Solution

1. Step 1: Understand duplicates in permutations

   Duplicates cause repeated permutations if not handled. Sorting helps group duplicates together.

2. Step 2: Skip swapping duplicates during recursion

   By sorting and skipping swaps of same values at the same recursion level, duplicates are avoided efficiently.

3. Final Answer:

   Sort the array first and skip swapping duplicate elements during recursion -> Option D

4. Quick Check:

   Sort + skip duplicates = unique permutations [OK]

Hint: Sort array and skip duplicate swaps to avoid repeats [OK]

Common Mistakes:

• Generating all then filtering duplicates (inefficient)
• Not sorting before recursion
• Only swapping if values differ misses some permutations