Remove All Occurrences of a Substring

Remove All Occurrences of a Substring - Problem

Given two strings s and part, perform the following operation on s until all occurrences of the substring part are removed:

Find the leftmost occurrence of the substring part and remove it from s.

Return s after removing all occurrences of part.

A substring is a contiguous sequence of characters in a string.

Input & Output

Example 1 — Basic Removal

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

› Output: "dab"

💡 Note: Remove first "abc" → "daabcbbc", then remove second "abc" → "dabb", then remove "bbc" doesn't contain "abc", final result is "dab"

Example 2 — Complete Removal

$ Input: s = "aabababa", part = "aba"

› Output: "ba"

💡 Note: Remove "aba" from position 1 → "ababa", remove "aba" from position 0 → "ba", no more occurrences found

Example 3 — No Occurrences

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

› Output: "hello"

💡 Note: The substring "world" is not found in "hello", so the original string is returned unchanged

Constraints

1 ≤ s.length ≤ 1000
1 ≤ part.length ≤ 1000
s and part consist of lowercase English letters

Visualization

Tap to expand

Asked in

f Facebook 15 a Amazon 12 M Microsoft 8

The key insight is that removing one occurrence of a substring might create new occurrences. The optimal approach uses a stack-based method to process characters one by one, checking for pattern matches at the end of the stack. Time: O(n), Space: O(n)

Common Approaches

✓ Brute Force - Repeated Find and Remove

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

Keep searching for the leftmost occurrence of the substring 'part' in string 's'. When found, remove it and start searching again from the beginning. Continue until no more occurrences are found.

Stack-Based Approach

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

Build the result character by character using a stack. When we detect that the last 'part.length' characters form the pattern, we remove them from the stack. This allows us to handle cases where removing one occurrence creates a new occurrence.

Brute Force - Repeated Find and Remove — Algorithm Steps

Step 1: Search for the leftmost occurrence of 'part' in 's'
Step 2: If found, remove it and create a new string
Step 3: Repeat until no more occurrences exist

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial String

Start with original string

Find & Remove

Locate leftmost occurrence and remove it

Repeat

Continue until no more occurrences exist

Code -

solution.c — C

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

char* solution(char* s, char* part) {
    int sLen = strlen(s);
    int partLen = strlen(part);
    char* result = (char*)malloc((sLen + 1) * sizeof(char));
    strcpy(result, s);
    
    char* pos;
    while ((pos = strstr(result, part)) != NULL) {
        memmove(pos, pos + partLen, strlen(pos + partLen) + 1);
    }
    return result;
}

int main() {
    char s[1001], part[1001];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    fgets(part, sizeof(part), stdin);
    part[strcspn(part, "\n")] = 0;
    
    char* result = solution(s, part);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

In worst case, we might need to scan the entire string multiple times. Each removal operation can take O(n) time and we might do this O(n) times.

✓ Linear Growth

Space Complexity

O(n)

We create new strings during each removal operation, requiring additional space proportional to string length.

⚡ Linearithmic Space

28.5K Views

Medium Frequency

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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Repeated Find and Remove — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler