Permutation Sequence - Practice Coding Problems

Permutation Sequence - Problem

Math Recursion Hard

The mathematical foundation of permutations tells us that a set of n distinct elements produces exactly n! unique permutations. When we arrange these permutations in lexicographical (dictionary) order, we create a predictable sequence.

For example, with n = 3, the set [1, 2, 3] generates these 6 permutations in order:

1st: "123"
2nd: "132"
3rd: "213"
4th: "231"
5th: "312"
6th: "321"

Your challenge: Given n and k, find the k-th permutation in this sequence without generating all previous permutations.

This problem tests your ability to think mathematically about combinatorics and avoid the computational explosion of factorial complexity.

Input & Output

example_1.py — Basic Case

$ Input: n = 3, k = 3

› Output: "213"

💡 Note: For n=3, the permutations in order are: 123, 132, 213, 231, 312, 321. The 3rd permutation is "213".

example_2.py — Larger Input

$ Input: n = 4, k = 9

› Output: "2314"

💡 Note: With n=4, there are 4!=24 permutations. The 9th permutation in lexicographical order is "2314".

example_3.py — Edge Case

$ Input: n = 3, k = 1

› Output: "123"

💡 Note: The 1st (first) permutation is always the natural ascending order: "123".

Visualization

Tap to expand

Understanding the Visualization

Understand the Pattern

For n digits, exactly (n-1)! permutations start with each digit

Calculate Position

Use k÷(n-1)! to find which digit starts our target permutation

Remove and Recurse

Remove chosen digit and repeat for remaining positions

Build Result

Concatenate all chosen digits to form the k-th permutation

Key Takeaway

🎯 Key Insight: Mathematics beats brute force! By understanding that each digit 'reserves' exactly (n-1)! positions, we can calculate any permutation directly.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We iterate through n positions, and for each position we may need O(n) time to remove elements from the list

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing the available digits list and result string

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 9
1 ≤ k ≤ n!
k is guaranteed to be valid (within the range of possible permutations)

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28

The optimal approach uses factorial mathematics to directly calculate each digit position without generating intermediate permutations. By recognizing that exactly (n-1)! permutations start with each digit, we can use integer division to jump directly to the k-th permutation in O(n²) time.

Common Approaches

Approach	Time	Space	Notes
✓ Mathematical Direct Calculation (Optimal)	O(n²)	O(n)	Use factorial math to directly calculate each digit position
Generate All Permutations	O(k × n)	O(n)	Generate all permutations until we reach the k-th one

Mathematical Direct Calculation (Optimal) — Algorithm Steps

Create list of available digits [1,2,3,...,n]
For each position, calculate how many permutations start with each remaining digit
Use integer division to find which digit belongs in current position
Remove chosen digit from available list and update k
Repeat until all positions are filled

Visualization

Tap to expand

Step-by-Step Walkthrough

Setup

Available digits [1,2,3], k=4, need 4th permutation

First digit

(4-1) ÷ 2! = 3 ÷ 2 = 1 → choose digits[1] = 2

Second digit

k = 3 % 2 = 1, 1 ÷ 1! = 1 → choose digits[1] = 3

Final result

Last remaining digit is 1 → result = "231"

Code -

solution.c — C

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

char* getPermutation(int n, int k) {
    // Precompute factorials
    int* factorial = malloc((n + 1) * sizeof(int));
    factorial[0] = 1;
    for (int i = 1; i <= n; i++) {
        factorial[i] = factorial[i - 1] * i;
    }
    
    // Initialize digits
    int* digits = malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        digits[i] = i + 1;
    }
    
    char* result = malloc((n + 1) * sizeof(char));
    k--; // Convert to 0-indexed
    
    for (int i = 0; i < n; i++) {
        int fact = factorial[n - 1 - i];
        int index = k / fact;
        
        result[i] = '0' + digits[index];
        
        // Remove chosen digit by shifting
        for (int j = index; j < n - 1 - i; j++) {
            digits[j] = digits[j + 1];
        }
        
        k %= fact;
    }
    
    result[n] = '\0';
    free(factorial);
    free(digits);
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We iterate through n positions, and for each position we may need O(n) time to remove elements from the list

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing the available digits list and result string

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 9
1 ≤ k ≤ n!
k is guaranteed to be valid (within the range of possible permutations)

52.0K Views

Medium-High Frequency

~25 min Avg. Time

1.7K 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

Mathematical Direct Calculation (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler