Next Permutation of Array in DSA Rust - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Next Permutation on a Simple Array

What is the output of the following Rust code that computes the next permutation of the array?

DSA Rust

fn next_permutation(nums: &mut [i32]) {
    let n = nums.len();
    if n < 2 { return; }
    let mut i = n - 2;
    while i != usize::MAX && nums[i] >= nums[i + 1] {
        if i == 0 { break; }
        i -= 1;
    }
    if nums[i] < nums[i + 1] {
        let mut j = n - 1;
        while nums[j] <= nums[i] {
            j -= 1;
        }
        nums.swap(i, j);
    }
    nums[i + 1..].reverse();
}

fn main() {
    let mut arr = vec![1, 2, 3];
    next_permutation(&mut arr);
    println!("{:?}", arr);
}

A [1, 2, 3]

B [3, 2, 1]

C [2, 1, 3]

D [1, 3, 2]

💡 Hint

Think about the next lexicographically larger permutation after [1, 2, 3].

The next permutation after [1, 2, 3] is [1, 3, 2] because we swap the last increasing pair and reverse the suffix.

❓ Predict Output

intermediate

Next Permutation Output for Descending Array

What will be printed after running this Rust code that applies next permutation on a descending array?

DSA Rust

fn next_permutation(nums: &mut [i32]) {
    let n = nums.len();
    if n < 2 { return; }
    let mut i = n - 2;
    while i != usize::MAX && nums[i] >= nums[i + 1] {
        if i == 0 { break; }
        i -= 1;
    }
    if nums[i] < nums[i + 1] {
        let mut j = n - 1;
        while nums[j] <= nums[i] {
            j -= 1;
        }
        nums.swap(i, j);
    }
    nums[i + 1..].reverse();
}

fn main() {
    let mut arr = vec![3, 2, 1];
    next_permutation(&mut arr);
    println!("{:?}", arr);
}

A [1, 2, 3]

B [3, 1, 2]

C [3, 2, 1]

D [2, 3, 1]

💡 Hint

If the array is in descending order, the next permutation is the smallest permutation.

The array is the highest permutation. The next permutation resets it to the lowest, which is sorted ascending.

🔧 Debug

advanced

Identify the Bug in Next Permutation Implementation

Which option contains a bug that causes incorrect next permutation for the input [1, 3, 2]?

DSA Rust

fn next_permutation(nums: &mut [i32]) {
    let n = nums.len();
    if n < 2 { return; }
    let mut i = n - 2;
    while i != usize::MAX && nums[i] > nums[i + 1] {
        if i == 0 { break; }
        i -= 1;
    }
    if nums[i] < nums[i + 1] {
        let mut j = n - 1;
        while nums[j] < nums[i] {
            j -= 1;
        }
        nums.swap(i, j);
    }
    nums[i + 1..].reverse();
}

A The condition in the first while loop should be nums[i] >= nums[i + 1], not nums[i] > nums[i + 1].

B The second while loop should use nums[j] <= nums[i], not nums[j] < nums[i].

C The code should reverse nums[i..] instead of nums[i + 1..].

D The code should swap nums[i + 1] and nums[j], not nums[i] and nums[j].

💡 Hint

Check the condition that finds the first decreasing element from the right.

Using > instead of >= skips equal elements and can cause wrong i selection, leading to incorrect permutation.

🧠 Conceptual

advanced

Understanding the Role of Reversing the Suffix

Why does the next permutation algorithm reverse the subarray after index i instead of sorting it?

A Because reversing the subarray after i swaps the first and last elements only.

B Because the subarray after i is always in descending order, reversing it sorts it ascending efficiently.

C Because the subarray after i is random, reversing it randomizes the order for next permutation.

D Because reversing is faster than sorting but does not guarantee correct next permutation.

💡 Hint

Think about the order of the suffix before reversal.

The suffix is in descending order, so reversing it produces the smallest ascending order suffix, which is the next permutation's requirement.

🚀 Application

expert

Next Permutation on a Large Array with Duplicates

Given the array [1, 5, 1, 1, 3, 3], what is the next permutation after applying the algorithm?

A [1, 5, 3, 1, 1, 3]

B [1, 5, 1, 3, 1, 3]

C [1, 5, 1, 3, 3, 1]

D [1, 5, 3, 1, 3, 1]

💡 Hint

Find the first decreasing element from the right, swap with next larger, then reverse suffix.

The first decreasing element from right is at index 3 (value 1). The next larger element to swap is at index 5 (value 3). After swapping and reversing suffix, the array becomes [1, 5, 1, 3, 3, 1].

Practice

1. What does the next_permutation algorithm do to an array of numbers?

easy

A. It rearranges the array to the next lexicographically greater permutation.

B. It sorts the array in ascending order.

C. It reverses the array.

D. It finds the maximum element in the array.

Solution

1. Step 1: Understand the purpose of next_permutation

   The algorithm finds the next arrangement of elements that is just larger than the current one in dictionary order.

2. Step 2: Compare with other options

   Sorting or reversing changes order but does not guarantee the next lexicographical permutation. Finding max element is unrelated.

3. Final Answer:

   It rearranges the array to the next lexicographically greater permutation. -> Option A

4. Quick Check:

   Next permutation = next lexicographically greater order [OK]

Hint: Next permutation means next bigger order arrangement [OK]

Common Mistakes:

• Confusing next permutation with sorting
• Thinking it reverses the array always
• Assuming it finds max element

2. Which of the following Rust code snippets correctly swaps two elements in a vector nums at indices i and j?

easy

A. nums.swap(i, j) -> ();

B. nums[i] = nums[j]; nums[j] = nums[i];

C. nums.swap(i, j);

D. nums.swap_elements(i, j);

Solution

1. Step 1: Recall Rust vector swap method

   Rust's standard Vec<T> has a method swap(i, j) to exchange elements at indices i and j.

2. Step 2: Check other options for correctness

   nums[i] = nums[j]; nums[j] = nums[i]; incorrectly assigns values without temporary storage, causing wrong swap. nums.swap_elements(i, j); uses a non-existent method. nums.swap(i, j) -> (); has invalid syntax.

3. Final Answer:

   nums.swap(i, j); -> Option C

4. Quick Check:

   Correct swap method = nums.swap(i, j) [OK]

Hint: Use nums.swap(i, j) to swap elements in Rust vector [OK]

Common Mistakes:

• Assigning without temp variable causing overwrite
• Using non-existent methods
• Incorrect syntax with arrows or extra symbols

3. What is the output of the following Rust code that finds the next permutation of nums = vec![1, 3, 2]?

let mut nums = vec![1, 3, 2];
if next_permutation(&mut nums) {
    println!("{:?}", nums);
} else {
    println!("No next permutation");
}

fn next_permutation(nums: &mut Vec<i32>) -> bool {
    let n = nums.len();
    if n < 2 { return false; }
    let mut i = n - 2;
    while i != usize::MAX && nums[i] >= nums[i + 1] {
        if i == 0 { break; }
        i -= 1;
    }
    if i == usize::MAX || nums[i] >= nums[i + 1] {
        nums.reverse();
        return false;
    }
    let mut j = n - 1;
    while nums[j] <= nums[i] {
        j -= 1;
    }
    nums.swap(i, j);
    nums[i + 1..].reverse();
    true
}

medium

A. [2, 1, 3]

B. [1, 2, 3]

C. [1, 3, 2]

D. No next permutation

Solution

1. Step 1: Identify pivot index i

   Starting from right, find i where nums[i] < nums[i+1]. For [1,3,2], i=0 because 1 < 3.

2. Step 2: Find j to swap with i

   From right, find j where nums[j] > nums[i]. Here j=2 (value 2 > 1).

3. Step 3: Swap and reverse suffix

   Swap nums[0] and nums[2]: [2,3,1]. Then reverse suffix after i: reverse [3,1] to [1,3]. Result: [2,1,3].

4. Step 4: Check code logic carefully

   Code breaks loop early if i=0 and condition met, so i=0 is pivot. But code returns false and reverses if no pivot found. Here pivot found, so returns true and prints new nums.

5. Final Answer:

   [2, 1, 3] -> Option A

6. Quick Check:

   Next permutation of [1,3,2] = [2,1,3] [OK]

Hint: Find pivot i, swap with j, reverse suffix [OK]

Common Mistakes:

• Not reversing suffix after swap
• Wrong pivot index calculation
• Confusing when to return false

4. The following Rust function attempts to implement next permutation but has a bug. What is the bug?

fn next_permutation(nums: &mut Vec<i32>) -> bool {
    let n = nums.len();
    if n < 2 { return false; }
    let mut i = n - 2;
    while nums[i] >= nums[i + 1] {
        i -= 1;
    }
    if nums[i] >= nums[i + 1] {
        nums.reverse();
        return false;
    }
    let mut j = n - 1;
    while nums[j] <= nums[i] {
        j -= 1;
    }
    nums.swap(i, j);
    nums[i + 1..].reverse();
    true
}

medium

A. The suffix reversal is missing.

B. The loop misses checking when i == 0, causing panic on underflow.

C. The swap method is used incorrectly.

D. The function does not return a boolean.

Solution

1. Step 1: Analyze the while loop condition

   The loop uses while nums[i] >= nums[i + 1] and decrements i. When i reaches 0 and condition holds, next decrement causes underflow (usize wraps to large number).

2. Step 2: Check consequences

   This causes panic or incorrect behavior. The correct approach is to use i != usize::MAX or check before decrementing to avoid underflow.

3. Final Answer:

   The loop misses checking when i == 0, causing panic on underflow. -> Option B

4. Quick Check:

   Loop underflow bug = missing i == 0 check [OK]

Hint: Check loop index underflow when decrementing unsigned integers [OK]

Common Mistakes:

• Ignoring unsigned integer underflow
• Incorrect swap usage
• Forgetting to reverse suffix

5. Given a vector nums = vec![3, 2, 1], which is the highest permutation, what will be the state of nums after applying the next permutation function that returns false when no next permutation exists?

hard

A. [3, 2, 1]

B. Original vector unchanged

C. Empty vector

D. [1, 2, 3]

Solution

1. Step 1: Identify if next permutation exists

   For [3, 2, 1], the array is in descending order, which is the highest permutation. No next permutation exists.

2. Step 2: Apply algorithm behavior when no next permutation

   The algorithm reverses the entire array to the lowest permutation and returns false.

3. Final Answer:

   [1, 2, 3] -> Option D

4. Quick Check:

   Highest permutation reversed = lowest permutation [OK]

Hint: No next permutation means reverse to lowest order [OK]

Common Mistakes:

• Expecting no change when no next permutation
• Returning empty vector incorrectly
• Confusing highest and lowest permutations