Removing Stars From a String - Practice Coding Problems

Removing Stars From a String - Problem

You are given a string s containing letters and stars (*). Your task is to simulate a backspace operation where each star removes the closest non-star character to its left.

The Process:

When you encounter a star *, remove the closest non-star character to its left
Also remove the star itself
Repeat until all stars are processed

Goal: Return the final string after all stars have been removed and processed.

Note: The input guarantees that every star will have at least one non-star character to its left, so the operation is always valid.

Example: "abc*de*f" becomes "adf" because the first * removes 'c', and the second * removes 'e'.

Input & Output

example_1.py — Basic Case

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

› Output: "lecoe"

💡 Note: Processing left to right: 'l','e','e','t' get added, first '*' removes 't', second '*' removes 'e', then 'c','o','d' get added, third '*' removes 'd', finally 'e' gets added. Result: "lecoe"

example_2.py — Simple Case

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

› Output: ""

💡 Note: The string 'erase' has 5 characters, and there are 5 stars. Each star removes one character from left to right: 'e' removed, 'r' removed, 'a' removed, 's' removed, 'e' removed. Final result is empty string.

example_3.py — No Stars

$ Input: s = "abc"

› Output: "abc"

💡 Note: No stars in the string, so no characters are removed. The result is the original string "abc".

Visualization

Tap to expand

Understanding the Visualization

Initialize Stack

Start with an empty stack to represent the text buffer

Process Characters

For each regular character, add it to the buffer (push to stack)

Handle Backspaces

For each star (*), remove the most recent character (pop from stack)

Build Result

The final stack contents represent the text after all backspaces

Key Takeaway

🎯 Key Insight: The stack data structure perfectly mimics a text editor's buffer, making this an elegant and efficient solution that processes each character exactly once.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string, each character is processed once

✓ Linear Growth

Space Complexity

O(n)

Stack can contain at most n characters in worst case (no stars)

⚡ Linearithmic Space

Constraints

1 ≤ s.length ≤ 10⁵
s consists of lowercase English letters and stars *
The given string is valid (every star has a non-star character to its left)

Asked in

a Amazon 35 ⊞ Microsoft 28 G Google 22 f Meta 18

The optimal solution uses a stack-based approach to simulate the star removal process. Process the string from left to right: push regular characters onto a stack and pop characters when encountering stars. This achieves O(n) time complexity with a single pass through the string, making it much more efficient than the brute force approach that requires multiple scans.

Common Approaches

Approach	Time	Space	Notes
✓ Stack-Based Solution (Optimal)	O(n)	O(n)	Use a stack to simulate the character removal process in one pass
Brute Force (String Reconstruction)	O(n²)	O(n)	Convert to list and repeatedly find and remove star-character pairs

Stack-Based Solution (Optimal) — Algorithm Steps

Initialize an empty stack (or list)
Iterate through each character in the string
If character is not a star: push it onto the stack
If character is a star: pop the top character from stack
Join the remaining characters in the stack to form result

Visualization

Tap to expand

Step-by-Step Walkthrough

Process 'a'

Regular character - push to stack

Process 'b'

Regular character - push to stack

Process 'c'

Regular character - push to stack

Process '*'

Star character - pop from stack

Process 'd'

Regular character - push to stack

Code -

solution.c — C

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

char* removeStars(char* s) {
    int len = strlen(s);
    char* stack = malloc((len + 1) * sizeof(char));
    int top = -1; // Stack pointer
    
    for (int i = 0; i < len; i++) {
        if (s[i] == '*') {
            if (top >= 0) {
                top--; // Remove the most recent character
            }
        } else {
            stack[++top] = s[i]; // Add regular character
        }
    }
    
    stack[top + 1] = '\0'; // Null terminate
    return stack;
}

int main() {
    char s[1000];
    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 = removeStars(s);
    printf("\"%s\"\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string, each character is processed once

✓ Linear Growth

Space Complexity

O(n)

Stack can contain at most n characters in worst case (no stars)

⚡ Linearithmic Space

Constraints

1 ≤ s.length ≤ 10⁵
s consists of lowercase English letters and stars *
The given string is valid (every star has a non-star character to its left)

68.5K Views

Medium-High Frequency

~12 min Avg. Time

2.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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Stack-Based Solution (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler