Lexicographically Smallest String After Substring Operation

Lexicographically Smallest String After Substring Operation - Problem

String Greedy Medium

You're given a string s consisting of lowercase English letters. Your task is to make the lexicographically smallest string possible by performing exactly one operation:

Select any non-empty substring from the string
Replace every letter in that substring with its preceding letter in the alphabet
Note: 'b' becomes 'a', 'c' becomes 'b', but 'a' becomes 'z'

Goal: Return the lexicographically smallest string after performing exactly one such operation.

Example: Given "cba", you could select substring "cb" and transform it to "ba", resulting in "baa".

Input & Output

example_1.py — Basic Case

$ Input: s = "cba"

› Output: "baa"

💡 Note: We select substring "cb" (indices 0-1) and transform: c→b, b→a. Result: "baa". This is lexicographically smallest among all possible operations.

example_2.py — All 'a' Case

$ Input: s = "aaa"

› Output: "aaz"

💡 Note: Since all characters are 'a', transforming any 'a' gives 'z'. To get the lexicographically smallest result, we transform only the last character: "aaa" → "aaz".

example_3.py — Mixed Case

$ Input: s = "acbbc"

› Output: "aabac"

💡 Note: The first non-'a' is 'c' at index 1. We find consecutive non-'a' characters: "c" only. Transform: c→b. Result: "aabbc". Wait, let's recalculate: we should transform "cbb" (indices 1-3): c→b, b→a, b→a. Result: "aabac".

Constraints

1 ≤ s.length ≤ 10⁵
s consists of lowercase English letters only
Must perform exactly one operation
The selected substring must be non-empty

Visualization

Tap to expand

Understanding the Visualization

Scan for Opportunity

Look for the first character that isn't 'a' - this is where we can improve without creating 'z'

Maximize Impact

Extend the transformation to include all consecutive non-'a' characters for maximum benefit

Handle Edge Case

If the string is all 'a's, transform only the last one to minimize lexicographical impact

Key Takeaway

🎯 Key Insight: To minimize lexicographical order, transform the first maximal sequence of non-'a' characters. This avoids creating 'z' characters early in the string while maximizing the improvement from the transformation.

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal solution uses a greedy approach to find the first non-'a' character and transform the maximal consecutive sequence of non-'a' characters starting from that position. If all characters are 'a', we transform only the last character to minimize lexicographical impact. Time complexity: O(n), Space complexity: O(n).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Substrings)	O(n³)	O(n)	Try every possible substring operation and find the lexicographically smallest result
Greedy Single Pass (Optimal)	O(n)	O(n)	Find the first non-'a' character and transform the maximal substring of non-'a' characters

Brute Force (Try All Substrings) — Algorithm Steps

Generate all possible substrings (i, j) where i <= j
For each substring, create a copy of the original string
Apply the transformation (shift each character backward by 1) to the substring
Keep track of the lexicographically smallest result seen so far
Return the smallest result after checking all possibilities

Visualization

Tap to expand

Step-by-Step Walkthrough

Try substring [0,0]

Transform first character only

Try substring [0,1]

Transform first two characters

Continue for all substrings

Compare results to find minimum

Code -

solution.c — C

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

char* smallestString(char* s) {
    int n = strlen(s);
    char* result = (char*)malloc((n + 1) * sizeof(char));
    strcpy(result, s);
    
    // Try all possible substrings
    for (int i = 0; i < n; i++) {
        for (int j = i; j < n; j++) {
            // Create new string with substring [i, j] transformed
            char* candidate = (char*)malloc((n + 1) * sizeof(char));
            strcpy(candidate, s);
            
            for (int k = i; k <= j; k++) {
                if (candidate[k] == 'a') {
                    candidate[k] = 'z';
                } else {
                    candidate[k] = candidate[k] - 1;
                }
            }
            
            if (strcmp(candidate, result) < 0) {
                strcpy(result, candidate);
            }
            free(candidate);
        }
    }
    
    return result;
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    // Remove newline and quotes
    s[strcspn(s, "\n")] = 0;
    if (s[0] == '"') {
        memmove(s, s+1, strlen(s));
        s[strlen(s)-1] = 0;
    }
    
    char* result = smallestString(s);
    printf("\"%s\"", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) substrings, each requiring O(n) time to create and compare the resulting string

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing the result string and temporary strings during comparison

⚡ Linearithmic Space

28.4K Views

Medium Frequency

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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Try All Substrings) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler