Find the Index of Permutation

Find the Index of Permutation - Problem

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

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

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

Lexicographic order means dictionary order - for example, permutations of [1,2,3] in lexicographic order are: [1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], [3,2,1].

Input & Output

Example 1 — Basic Case

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

› Output: 3

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

Example 2 — First Permutation

$ Input: perm = [1,2]

› Output: 0

💡 Note: Permutations of [1,2] in order: [1,2], [2,1]. The permutation [1,2] is the first one, so index is 0.

Example 3 — Last Permutation

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

› Output: 5

💡 Note: The permutation [3,2,1] is the last permutation of [1,2,3] in lexicographic order, so it's at index 5.

Constraints

1 ≤ perm.length ≤ 1000
perm is a permutation of [1, 2, ..., n]

Visualization

Tap to expand

Asked in

G Google 35 M Microsoft 28 a Amazon 22 F Facebook 18

The key insight is to use factorial mathematics instead of generating all permutations. For each position, count how many smaller unused numbers exist and multiply by the factorial of remaining positions. Best approach is the mathematical factorial calculation with Time: O(n²), Space: O(n).

Common Approaches

✓ Brute Force - Generate All Permutations

⏱️ Time: O(n! × n) Space: O(n!)

Generate all n! permutations of [1,2,...,n] in lexicographic order, then find the index where our target permutation appears. This works but is extremely slow for large inputs.

Mathematical Factorial Calculation

⏱️ Time: O(n²) Space: O(n)

For each position, count how many smaller elements remain and multiply by factorial of remaining positions. This gives us the exact lexicographic index without generating all permutations.

Brute Force - Generate All Permutations — Algorithm Steps

Generate all permutations of [1,2,...,n]
Sort them lexicographically
Find index of target permutation

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All

Create all permutations of [1,2,3]

Sort Lexicographically

Order them like dictionary

Find Target

Locate our target permutation

Code -

solution.c — C

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

void generatePermutations(int* nums, int n, int start, int** allPerms, int* count) {
    if (start == n) {
        for (int i = 0; i < n; i++) {
            allPerms[*count][i] = nums[i];
        }
        (*count)++;
        return;
    }
    
    for (int i = start; i < n; i++) {
        // Swap
        int temp = nums[start];
        nums[start] = nums[i];
        nums[i] = temp;
        
        generatePermutations(nums, n, start + 1, allPerms, count);
        
        // Backtrack
        temp = nums[start];
        nums[start] = nums[i];
        nums[i] = temp;
    }
}

int comparePerms(const void* a, const void* b) {
    int* arr1 = *(int**)a;
    int* arr2 = *(int**)b;
    
    for (int i = 0; i < 1000; i++) { // This will be limited by actual array size
        if (arr1[i] != arr2[i]) {
            return arr1[i] - arr2[i];
        }
    }
    return 0;
}

int factorial(int n) {
    if (n <= 1) return 1;
    int result = 1;
    for (int i = 2; i <= n; i++) {
        result *= i;
    }
    return result;
}

int solution(int* perm, int n) {
    int* nums = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) nums[i] = i + 1;
    
    int totalPerms = factorial(n);
    int** allPerms = (int**)malloc(totalPerms * sizeof(int*));
    for (int i = 0; i < totalPerms; i++) {
        allPerms[i] = (int*)malloc(n * sizeof(int));
    }
    
    int count = 0;
    generatePermutations(nums, n, 0, allPerms, &count);
    
    // Sort permutations lexicographically
    qsort(allPerms, totalPerms, sizeof(int*), comparePerms);
    
    for (int i = 0; i < totalPerms; i++) {
        bool match = true;
        for (int j = 0; j < n; j++) {
            if (allPerms[i][j] != perm[j]) {
                match = false;
                break;
            }
        }
        if (match) {
            for (int k = 0; k < totalPerms; k++) free(allPerms[k]);
            free(allPerms);
            free(nums);
            return i % (int)(1e9 + 7);
        }
    }
    
    for (int k = 0; k < totalPerms; k++) free(allPerms[k]);
    free(allPerms);
    free(nums);
    return -1;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int perm[1000];
    int n = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        perm[n++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    printf("%d\n", solution(perm, n));
    return 0;
}

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

28.5K Views

Medium Frequency

~25 min Avg. Time

892 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