Find the Index of Permutation - Practice Coding Problems

Find the Index of Permutation - Problem

Array Binary Search Divide and Conquer Binary Indexed Tree Segment Tree Merge Sort Ordered Set Medium

Imagine you have all possible arrangements (permutations) of numbers [1, 2, ..., n] listed in dictionary order (lexicographic order). Your task is to find the position of a specific permutation in this sorted list.

Given an array perm of length n which is a permutation of [1, 2, ..., n], return the 0-based index of perm in the lexicographically sorted array of all permutations of [1, 2, ..., n].

For example, if n = 3, all permutations in order are: [1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], [3,2,1]. If perm = [2,1,3], it's at index 2.

Since the answer may be very large, return it modulo 10⁹ + 7.

Input & Output

example_1.py — Basic Case

$ Input: perm = [1,2,3]

› Output: 0

💡 Note: This is the first permutation in lexicographic order, so its index is 0.

example_2.py — Middle Case

$ Input: perm = [2,1,3]

› Output: 2

💡 Note: All permutations in order: [1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], [3,2,1]. The permutation [2,1,3] is at index 2.

example_3.py — Last Case

$ Input: perm = [3,2,1]

› Output: 5

💡 Note: This is the last permutation in lexicographic order (reverse sorted), so its index is 3! - 1 = 5.

Constraints

1 ≤ n ≤ 1000
perm is a valid permutation of [1, 2, ..., n]
Return result modulo 10⁹ + 7

Visualization

Tap to expand

Understanding the Visualization

Count by First Letter

How many words start with letters before 'B'? All words starting with 'A' come first.

Count by Second Letter

Among words starting with 'B', how many have second letters before 'A'? None, since A is smallest.

Final Position

Add up all the counts to get the exact position without generating every arrangement.

Key Takeaway

🎯 Key Insight: Instead of generating all permutations, use factorial arithmetic to count how many permutations come before the target, giving us direct access to its position.

Asked in

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

The optimal solution uses the factorial number system to mathematically calculate the permutation index in O(n²) time. For each position, we count how many unused smaller numbers exist and multiply by the factorial of remaining positions. This avoids generating all permutations and works efficiently even for large inputs.

Common Approaches

Approach	Time	Space	Notes
✓ Factorial Number System (Optimal)	O(n²)	O(n)	Use mathematical formula with factorials to directly calculate the index
Brute Force (Generate All Permutations)	O(n! × n)	O(n! × n)	Generate all permutations in lexicographic order and find the target

Factorial Number System (Optimal) — Algorithm Steps

For each position i, count how many unused numbers are smaller than perm[i]
Multiply this count by (n-i-1)! (factorial of remaining positions)
Add to the total index and mark perm[i] as used
Continue for all positions and return the sum modulo 10^9 + 7

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Smaller

For each position, count available numbers smaller than current

Multiply by Factorial

Multiply count by factorial of remaining positions

Accumulate Index

Add to total index and mark number as used

Code -

solution.c — C

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

#define MOD 1000000007

int getPermutationIndex(int* perm, int n) {
    // Precompute factorials
    long long factorial[n];
    factorial[0] = 1;
    for (int i = 1; i < n; i++) {
        factorial[i] = (factorial[i-1] * i) % MOD;
    }
    
    // Track which numbers are still available
    bool available[n + 1];
    for (int i = 0; i <= n; i++) {
        available[i] = true;
    }
    
    long long index = 0;
    
    for (int i = 0; i < n; i++) {
        // Count how many available numbers are smaller than perm[i]
        int smallerCount = 0;
        for (int j = 1; j < perm[i]; j++) {
            if (available[j]) {
                smallerCount++;
            }
        }
        
        // Add contribution of this position to the index
        index = (index + (long long)smallerCount * factorial[n-1-i]) % MOD;
        
        // Mark this number as used
        available[perm[i]] = false;
    }
    
    return (int)index;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n positions, we count smaller unused elements which takes O(n) time

⚠ Quadratic Growth

Space Complexity

O(n)

Need to track which numbers have been used and precompute factorials

⚡ Linearithmic Space

42.1K Views

Medium Frequency

~25 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

Factorial Number System (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler