Remove All Occurrences of a Substring - Practice Coding Problems

Remove All Occurrences of a Substring - Problem

You're given a string s and a substring part that you need to completely eliminate from s. Here's the catch: removing one occurrence might create new occurrences!

Your task is to repeatedly find the leftmost occurrence of part in s and remove it, until no more occurrences exist. Think of it like a chain reaction where each removal might expose new patterns.

Example: If s = "daabcbaabcbc" and part = "abc", removing the first "abc" gives us "daabcbabc", but now there's still another "abc" to remove!

Return the final string after all possible removals.

Input & Output

example_1.py — Basic Removal

$ Input: s = "daabcbaabcbc", part = "abc"

› Output: "daabcb"

💡 Note: Remove first "abc" → "daabcbabc". Remove second "abc" → "daabcb". No more "abc" patterns exist.

example_2.py — Chain Reaction

$ Input: s = "abccba", part = "ab"

› Output: "cccba"

💡 Note: Remove "ab" from position 0 → "ccba". No more "ab" patterns found, so we stop.

example_3.py — No Occurrences

$ Input: s = "hello", part = "xyz"

› Output: "hello"

💡 Note: The substring "xyz" doesn't exist in "hello", so the string remains unchanged.

Constraints

1 ≤ s.length ≤ 1000
1 ≤ part.length ≤ 1000
s and part consist of lowercase English letters
s contains at least one occurrence of part initially

Visualization

Tap to expand

Understanding the Visualization

Initialize Stack

Start with an empty stack to build our result

Process Each Character

Add characters one by one to the stack

Pattern Detection

After each addition, check if top forms unwanted pattern

Immediate Removal

Remove pattern immediately when detected

Final Result

Stack contents form the final cleaned string

Key Takeaway

🎯 Key Insight: Using a stack allows us to detect and remove patterns immediately as we build the string, handling chain reactions efficiently in a single pass!

Asked in

a Amazon 45 G Google 32 ⊞ Microsoft 28 f Meta 24

The optimal solution uses a stack-based approach to process characters one by one. As we build the result string, we continuously check if the top of our stack forms the unwanted pattern. This allows us to handle chain reactions efficiently in O(n) time, compared to the brute force O(n²) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Stack-Based Simulation (Optimal)	O(n)	O(n)	Use a stack to build result character by character, checking for pattern matches

Stack-Based Simulation (Optimal) — Algorithm Steps

Initialize an empty stack (or use a list as stack)
Iterate through each character in the input string
Add current character to stack
Check if the last 'len(part)' characters in stack form the pattern 'part'
If yes, remove those characters from stack
Convert final stack contents to string and return

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Character by Character

Add each character to stack

Pattern Detection

Check if stack top forms unwanted pattern

Immediate Removal

Remove pattern immediately when detected

Code -

solution.c — C

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

char* removeOccurrences(char* s, char* part) {
    int sLen = strlen(s);
    int partLen = strlen(part);
    char* stack = malloc(sLen + 1);
    int stackSize = 0;
    
    for (int i = 0; i < sLen; i++) {
        stack[stackSize++] = s[i];
        // Check if last partLen characters match the part
        if (stackSize >= partLen) {
            int match = 1;
            for (int j = 0; j < partLen; j++) {
                if (stack[stackSize - partLen + j] != part[j]) {
                    match = 0;
                    break;
                }
            }
            if (match) {
                // Remove the matched part
                stackSize -= partLen;
            }
        }
    }
    
    stack[stackSize] = '\0';
    return stack;
}

int main() {
    char s[1001], part[1001];
    scanf("%s %s", s, part);
    char* result = removeOccurrences(s, part);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We visit each character exactly once, and stack operations are O(1)

✓ Linear Growth

Space Complexity

O(n)

Stack can hold up to n characters in worst case

⚡ Linearithmic Space

52.2K Views

Medium Frequency

~15 min Avg. Time

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

Constraints

Visualization

Related Problems

Common Approaches

Stack-Based Simulation (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler