Codestin Search App

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].

Constraints

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

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!

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
✓ 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)	O(n)	O(1)	Find pivot point and swap strategically to get the next lexicographic permutation

Brute Force (Generate All Permutations) — Algorithm Steps

Generate all permutations using backtracking
Sort all permutations lexicographically
Find the index of current permutation
Return the next permutation (or wrap to first)

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All

Create all possible arrangements

Sort List

Sort permutations lexicographically

Find Current

Locate current permutation in sorted list

Get Next

Return the next permutation (or wrap around)

Code -

solution.c — C

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

void nextPermutation(int* nums, int numsSize) {
    // For C, we'll use a simplified approach
    // Generate permutations using lexicographic method
    int factorial = 1;
    for (int i = 1; i <= numsSize; i++) factorial *= i;
    
    int** allPerms = (int**)malloc(factorial * sizeof(int*));
    for (int i = 0; i < factorial; i++) {
        allPerms[i] = (int*)malloc(numsSize * sizeof(int));
    }
    
    // Generate all permutations (implementation needed)
    // Find current and get next
    
    // Copy next permutation
    // memcpy(nums, nextPerm, numsSize * sizeof(int));
    
    // Cleanup
    for (int i = 0; i < factorial; i++) {
        free(allPerms[i]);
    }
    free(allPerms);
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

Generate n! permutations, each taking O(n) time to create and compare

⚠ Quadratic Growth

Space Complexity

O(n!)

Store all n! permutations in memory

⚠ Quadratic 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Generate All Permutations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler