Next Permutation - Practice Coding Problems

Next Permutation - Problem

Imagine you have a sequence of numbers, like a combination lock or a digital counter. Given the current arrangement, you need to find the very next arrangement in lexicographical (dictionary) order.

A permutation is simply a rearrangement of elements. For example, [1,2,3] can be rearranged as [1,3,2], [2,1,3], [2,3,1], [3,1,2], or [3,2,1].

The Challenge: Given an array of integers, find the next lexicographically greater permutation. If no such permutation exists (you're at the highest possible arrangement), wrap around to the smallest permutation (sorted in ascending order).

Examples:

[1,2,3] → [1,3,2] (next in dictionary order)
[2,3,1] → [3,1,2] (jump to next valid arrangement)
[3,2,1] → [1,2,3] (wrap around to smallest)

Constraints: You must modify the array in-place using only constant extra memory!

Input & Output

example_1.py — Basic Next Permutation

$ Input: [1,2,3]

› Output: [1,3,2]

💡 Note: The next lexicographical permutation of [1,2,3] is [1,3,2]. We find that position 1 (value 2) can be incremented, swap with 3, giving us [1,3,2].

example_2.py — Jump to Next Valid

$ Input: [3,2,1]

› Output: [1,2,3]

💡 Note: This is the highest possible permutation, so we wrap around to the lowest permutation [1,2,3]. The algorithm detects no valid pivot and reverses the entire array.

example_3.py — Complex Case

$ Input: [1,1,5]

› Output: [1,5,1]

💡 Note: Even with duplicate values, the algorithm works correctly. Position 1 (value 1) can be incremented to 5, then we reverse the suffix [1] which remains [1].

Visualization

Tap to expand

Understanding the Visualization

Find Increment Position

Like finding which digit in 1923 can still be incremented (digit 2 can become 3)

Find Next Value

Find the smallest value greater than current digit (next valid digit)

Increment

Replace with the next valid value (like 2 → 3)

Reset Suffix

Make all positions to the right as small as possible (like resetting to 00)

Key Takeaway

🎯 Key Insight: Just like incrementing a digital counter, we only need to change the minimal suffix to get the next valid arrangement - find the rightmost 'digit' that can be incremented, increment it, then reset everything to its right to the minimum value!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to find pivot, single pass to find swap target, single pass to reverse suffix

✓ Linear Growth

Space Complexity

O(1)

Only uses a few extra variables, modifies array in-place

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 100
0 ≤ nums[i] ≤ 100
Must modify the array in-place
Use only O(1) extra memory space

Asked in

G Google 42 f Meta 38 a Amazon 35 ⊞ Microsoft 28

The optimal solution uses the classic next permutation algorithm: find the rightmost 'pivot' that can be incremented, swap it with the next larger element, then reverse the suffix to get the lexicographically smallest arrangement. This achieves O(n) time and O(1) space complexity while modifying the array in-place.

Common Approaches

Approach	Time	Space	Notes
✓ Optimal Algorithm (Next Permutation Logic)	O(n)	O(1)	Find pivot point and swap strategically to get the next lexicographic permutation
Brute Force (Generate All Permutations)	O(n! × n)	O(n!)	Generate all permutations, sort them, and find the next one

Optimal Algorithm (Next Permutation Logic) — Algorithm Steps

Find the largest index i such that nums[i] < nums[i+1] (rightmost 'ascending' pair)
If no such i exists, the permutation is the last one, so reverse the entire array
Find the largest index j such that nums[i] < nums[j]
Swap nums[i] and nums[j]
Reverse the suffix starting at nums[i+1] to get the smallest lexicographic order

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Pivot

Find rightmost nums[i] < nums[i+1]

Find Successor

Find rightmost nums[j] > nums[i]

Swap

Swap nums[i] and nums[j]

Reverse Suffix

Reverse everything after position i

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

void reverse(int* nums, int start, int end) {
    while (start < end) {
        swap(&nums[start], &nums[end]);
        start++;
        end--;
    }
}

void nextPermutation(int* nums, int numsSize) {
    // Step 1: Find the rightmost character that can be incremented
    int i = numsSize - 2;
    while (i >= 0 && nums[i] >= nums[i + 1]) {
        i--;
    }
    
    if (i == -1) {
        // The permutation is the last permutation, reverse to get the first
        reverse(nums, 0, numsSize - 1);
        return;
    }
    
    // Step 2: Find the smallest character to the right of nums[i] that's larger than nums[i]
    int j = numsSize - 1;
    while (nums[j] <= nums[i]) {
        j--;
    }
    
    // Step 3: Swap nums[i] and nums[j]
    swap(&nums[i], &nums[j]);
    
    // Step 4: Reverse the suffix starting at nums[i+1]
    reverse(nums, i + 1, numsSize - 1);
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to find pivot, single pass to find swap target, single pass to reverse suffix

✓ Linear Growth

Space Complexity

O(1)

Only uses a few extra variables, modifies array in-place

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 100
0 ≤ nums[i] ≤ 100
Must modify the array in-place
Use only O(1) extra memory space

78.4K Views

High Frequency

~18 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Optimal Algorithm (Next Permutation Logic) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler