Permutation Sequence

Permutation Sequence - Problem

Math Recursion Hard

The set [1, 2, 3, ..., n] contains a total of n! unique permutations.

By listing and labeling all of the permutations in order, we get the following sequence for n = 3:

"123", "132", "213", "231", "312", "321"

Given n and k, return the k^th permutation sequence.

Input & Output

Example 1 — Small Case

$ Input: n = 3, k = 3

› Output: "213"

💡 Note: All permutations in order: ["123", "132", "213", "231", "312", "321"]. The 3rd permutation is "213".

Example 2 — First Permutation

$ Input: n = 4, k = 1

› Output: "1234"

💡 Note: The first permutation in lexicographical order is always the numbers in ascending order: "1234".

Example 3 — Last Permutation

$ Input: n = 3, k = 6

› Output: "321"

💡 Note: For n=3, there are 3!=6 permutations total. The 6th (last) permutation is "321" (descending order).

Constraints

1 ≤ n ≤ 9
1 ≤ k ≤ n!

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 M Microsoft 8 a Amazon 6

The key insight is to use factorial number system to directly compute each digit position without generating all permutations. Best approach is factorial arithmetic with Time: O(n²), Space: O(n).

Common Approaches

Approach	Time	Space	Notes
✓ Generate All Permutations	O(n! × n)	O(n! × n)	Generate all n! permutations and return the kth one
Factorial Number System	O(n²)	O(n)	Use factorial arithmetic to directly compute the kth permutation

Generate All Permutations — Algorithm Steps

Generate all permutations using backtracking
Sort them in lexicographical order
Return the kth permutation (k-1 index)

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All

Create all n! permutations using backtracking

Sort

Sort permutations in lexicographical order

Select kth

Return the kth permutation from sorted list

Code -

solution.c — C

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

char permutations[40320][10];
int permCount = 0;

void backtrack(int* path, int pathLen, int* remaining, int remLen, int n) {
    if (remLen == 0) {
        for (int i = 0; i < pathLen; i++) {
            permutations[permCount][i] = path[i] + '0';
        }
        permutations[permCount][pathLen] = '\0';
        permCount++;
        return;
    }
    for (int i = 0; i < remLen; i++) {
        path[pathLen] = remaining[i];
        int newRemaining[10];
        int newRemLen = 0;
        for (int j = 0; j < remLen; j++) {
            if (j != i) {
                newRemaining[newRemLen++] = remaining[j];
            }
        }
        backtrack(path, pathLen + 1, newRemaining, newRemLen, n);
    }
}

int compare(const void* a, const void* b) {
    return strcmp((char*)a, (char*)b);
}

char* solution(int n, int k) {
    permCount = 0;
    int numbers[10];
    for (int i = 1; i <= n; i++) {
        numbers[i-1] = i;
    }
    int path[10];
    backtrack(path, 0, numbers, n, n);
    qsort(permutations, permCount, sizeof(permutations[0]), compare);
    return permutations[k-1];
}

int main() {
    int n, k;
    scanf("%d", &n);
    scanf("%d", &k);
    char* result = solution(n, k);
    printf("%s\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

Generate n! permutations, each taking O(n) time to construct

⚠ Quadratic Growth

Space Complexity

O(n! × n)

Store all n! permutations, each of length n

⚠ Quadratic Space

125.0K Views

Medium Frequency

~25 min Avg. Time

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

Generate All Permutations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler