Minimum Number of Operations to Make String Sorted

Minimum Number of Operations to Make String Sorted - Problem

You're given a string s and need to determine how many operations it takes to sort it using a specific algorithm. Think of this as reverse-engineering the next permutation algorithm!

The algorithm works like this:
1. Find the rightmost position where a character is smaller than its predecessor
2. Find the smallest character to the right that's still larger than the predecessor
3. Swap these two characters
4. Reverse everything after the swap position

Instead of actually performing these operations (which would be too slow), you need to calculate how many steps it would take using combinatorial mathematics. The key insight is that this is equivalent to finding the rank of the current permutation in lexicographic order!

Goal: Return the number of operations needed, modulo 10⁹ + 7.

Input & Output

example_1.py — Basic Example

$ Input: s = "cba"

› Output: 5

💡 Note: The string "cba" needs to be sorted to "abc". Following the algorithm: cba → cab → bca → bac → acb → abc. This takes 5 operations total.

example_2.py — With Duplicates

$ Input: s = "aabaa"

› Output: 2

💡 Note: The string "aabaa" becomes sorted as "aaaab" in 2 operations. The presence of duplicate characters reduces the number of distinct permutations.

example_3.py — Already Sorted

$ Input: s = "abc"

› Output: 0

💡 Note: The string "abc" is already in sorted order, so no operations are needed. The algorithm detects this immediately.

Visualization

Tap to expand

Understanding the Visualization

Setup Phase

Count character frequencies and precompute factorials with modular inverses

Position Analysis

For each position, count how many smaller characters appear later in the string

Permutation Counting

Calculate how many arrangements would start with those smaller characters

Duplicate Handling

Use multinomial coefficients to account for repeated characters

Accumulate Result

Sum all possibilities and update character frequencies for next position

Key Takeaway

🎯 Key Insight: Instead of simulating O(n!) operations, we mathematically calculate the permutation's lexicographic rank in O(n²) time using combinatorial formulas.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n positions, we potentially check all remaining characters (26 max), plus factorial precomputation

⚠ Quadratic Growth

Space Complexity

O(n)

Space for factorial array, character frequencies, and input string

⚡ Linearithmic Space

Constraints

1 ≤ s.length ≤ 3000
s consists only of lowercase English letters
Result must be returned modulo 10⁹ + 7
The string may contain duplicate characters

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 B ByteDance 6

The optimal solution uses combinatorial mathematics to calculate the permutation rank instead of simulating operations. Key insights: precompute factorials and modular inverses, use multinomial coefficients for duplicate characters, and count arrangements lexicographically smaller than the current permutation. Time complexity: O(n²), much faster than the factorial-time simulation approach.

Common Approaches

Approach	Time	Space	Notes
✓ Simulation Approach	O(n! × n)	O(n)	Actually perform the sorting operations step by step
Combinatorial Mathematics (Optimal)	O(n²)	O(n)	Calculate permutation rank using factorials and character frequencies

Simulation Approach — Algorithm Steps

Repeat until string is sorted:
Find largest i where s[i] < s[i-1]
Find the appropriate j to swap with i-1
Swap characters at positions i-1 and j
Reverse the suffix starting at i
Increment operation counter

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Inversion

Locate the rightmost position where s[i] < s[i-1]

Find Swap Target

Find the largest j where s[j] < s[i-1]

Swap Characters

Exchange characters at positions i-1 and j

Reverse Suffix

Reverse all characters from position i to the end

Code -

solution.c — C

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

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

void reverse(char *s, int start, int end) {
    while (start < end) {
        char temp = s[start];
        s[start] = s[end];
        s[end] = temp;
        start++;
        end--;
    }
}

int makeStringSorted(char *s) {
    const int MOD = 1e9 + 7;
    int len = strlen(s);
    char *copy = malloc(len + 1);
    int operations = 0;
    
    while (1) {
        // Check if sorted
        strcpy(copy, s);
        qsort(copy, len, sizeof(char), compare);
        if (strcmp(s, copy) == 0) break;
        
        // Find largest i where s[i] < s[i-1]
        int i = -1;
        for (int k = 1; k < len; k++) {
            if (s[k] < s[k-1]) i = k;
        }
        
        if (i == -1) break;
        
        // Find largest j where s[j] < s[i-1]
        int j = i;
        for (int k = i; k < len; k++) {
            if (s[k] < s[i-1]) j = k;
        }
        
        // Swap
        char temp = s[i-1];
        s[i-1] = s[j];
        s[j] = temp;
        
        // Reverse suffix
        reverse(s, i, len - 1);
        
        operations = (operations + 1) % MOD;
    }
    
    free(copy);
    return operations;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

In worst case, we might need to go through all n! permutations, each operation taking O(n) time

⚠ Quadratic Growth

Space Complexity

O(n)

Only need space to store the current string state

⚡ Linearithmic Space

Constraints

1 ≤ s.length ≤ 3000
s consists only of lowercase English letters
Result must be returned modulo 10⁹ + 7
The string may contain duplicate characters

28.4K Views

Medium Frequency

~35 min Avg. Time

847 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

Simulation Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler