Lexicographically Minimum String After Removing Stars

Lexicographically Minimum String After Removing Stars - Problem

Hash Table String Stack Greedy Heap (Priority Queue) Medium

You are given a string s that may contain any number of '*' characters. Your task is to remove all '*' characters through a specific process.

While there is a '*' in the string, perform the following operation:

Delete the leftmost '*' character
Delete the smallest non-'*' character to its left
If there are several smallest characters, you can delete any of them

Return the lexicographically smallest resulting string after removing all '*' characters.

Input & Output

Example 1 — Basic Case

$ Input: s = "leet*cod*e"

› Output: "lecoe"

💡 Note: First '*' removes 'e' (smallest among 'l','e','e','t'), leaving "let*cod*e". Next '*' removes 'd' (smallest among 'l','e','t','c','o','d'), giving final result "lecoe".

Example 2 — Multiple Same Characters

$ Input: s = "erase*****"

› Output: ""

💡 Note: Each '*' removes the smallest available character: first removes 'a', then 'e', then 'e', then 'r', finally 's', leaving empty string.

Example 3 — No Stars

$ Input: s = "hello"

› Output: "hello"

💡 Note: No '*' characters to process, so the original string is returned unchanged.

Constraints

1 ≤ s.length ≤ 10⁵
s consists of lowercase English letters and '*' characters
It is guaranteed that all '*' operations can be applied

Visualization

Tap to expand

Asked in

G Google 23 a Amazon 18 f Meta 15 m Microsoft 12

The key insight is to process characters left to right using a stack, and when encountering a '*', remove the lexicographically smallest character from the stack. The greedy stack approach works optimally by removing the rightmost occurrence of the smallest character to ensure lexicographically minimum result. Time: O(n²), Space: O(n)

Common Approaches

✓ Sort First

⏱️ Time: N/A Space: N/A

Dp 1d

⏱️ Time: N/A Space: N/A

Brute Force - Direct Simulation

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

For each '*' from left to right, scan all characters to its left to find the smallest one, then remove both the '*' and the smallest character. Repeat until no '*' remains.

Greedy with Smart Stack Management

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

Maintain a stack of characters and a frequency count. When encountering '*', remove the lexicographically smallest character. Use greedy approach to ensure the final result is lexicographically minimum.

Stack-Based Approach

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

Build result using a stack. For each character, if it's '*', remove the smallest character from the stack. Otherwise, add the character to stack maintaining order for easy removal.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

typedef struct {
    char ch;
    int pos;
} CharPos;

int compareByChar(const void* a, const void* b) {
    CharPos* ca = (CharPos*)a;
    CharPos* cb = (CharPos*)b;
    return ca->ch - cb->ch;
}

int compareByPos(const void* a, const void* b) {
    CharPos* ca = (CharPos*)a;
    CharPos* cb = (CharPos*)b;
    return ca->pos - cb->pos;
}

char* solution(const char* s) {
    static CharPos chars[100000];
    int charCount = 0;
    int starCount = 0;
    
    // Count stars and collect non-star characters with positions
    for (int i = 0; s[i]; i++) {
        if (s[i] == '*') {
            starCount++;
        } else {
            chars[charCount].ch = s[i];
            chars[charCount].pos = i;
            charCount++;
        }
    }
    
    if (starCount >= charCount) {
        static char empty[1] = "";
        return empty;
    }
    
    // Sort characters by value (lexicographically)
    qsort(chars, charCount, sizeof(CharPos), compareByChar);
    
    // Remove the smallest starCount characters
    int remainingCount = charCount - starCount;
    CharPos* remaining = chars + starCount;
    
    // Sort remaining characters by original position to maintain order
    qsort(remaining, remainingCount, sizeof(CharPos), compareByPos);
    
    // Extract just the characters
    static char result[100000];
    for (int i = 0; i < remainingCount; i++) {
        result[i] = remaining[i].ch;
    }
    result[remainingCount] = '\0';
    
    return result;
}

int main() {
    static char s[100000];
    fgets(s, sizeof(s), stdin);
    
    // Remove newline if present
    int len = strlen(s);
    if (len > 0 && s[len-1] == '\n') {
        s[len-1] = '\0';
    }
    
    printf("%s\n", solution(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

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