Maximum Number of Removable Characters - Practice Coding Problems

Maximum Number of Removable Characters - Problem

Imagine you have a string puzzle where you need to maintain a specific pattern! You're given two strings: a main string s and a pattern string p, where p is guaranteed to be a subsequence of s.

Here's the challenge: You also have an array removable containing indices that specify which characters you can remove from s, and in what order you must remove them. Your goal is to find the maximum number of characters you can remove while still keeping p as a subsequence of the remaining string.

Key Rules:

You must remove characters in the order specified by the removable array
After removals, p must still be a subsequence of the modified s
A subsequence maintains the relative order of characters (but doesn't need to be contiguous)

Example: If s = "abcacb", p = "ab", and removable = [3,1,0], you can remove up to 2 characters and still maintain "ab" as a subsequence!

Input & Output

example_1.py — Basic Case

$ Input: s = "abcacb", p = "ab", removable = [3,1,0]

› Output: 2

💡 Note: After removing indices 3 and 1 (first 2 from removable), s becomes "a_c_cb" → "accb". The subsequence "ab" can still be found as "a" (index 0) and "b" (index 4). If we remove index 0 too, we get "ccb" and can't find "ab" as a subsequence.

example_2.py — All Characters Removable

$ Input: s = "abcbddddd", p = "abcd", removable = [4,5,6,7,8]

› Output: 5

💡 Note: We can remove all characters in removable ([4,5,6,7,8]) since they are all 'd' characters that come after our pattern "abcd". The string becomes "abcb" and "abcd" is still a subsequence using indices [0,1,2,3] → "abc" + "b".

example_3.py — No Removals Possible

$ Input: s = "abcab", p = "abc", removable = [0,1,2,3,4]

› Output: 0

💡 Note: The pattern "abc" requires characters at indices 0,1,2. Since removable[0] = 0, removing even one character (the first 'a') breaks the subsequence. Therefore, we can remove 0 characters maximum.

Constraints

1 ≤ p.length ≤ s.length ≤ 10⁵
0 ≤ removable.length < s.length
0 ≤ removable[i] < s.length
p is a subsequence of s
s and p consist of only lowercase English letters
removable contains distinct integers

Visualization

Tap to expand

Understanding the Visualization

Library Setup

You have books on a shelf (string s) and a reading list (pattern p) that must be found in order

Removal Orders

Librarian gives you removal orders (removable array) - you must follow this sequence

Binary Search

Instead of trying each removal count, use binary search to efficiently find the maximum

Subsequence Check

For each candidate removal count, verify if reading list is still achievable

Key Takeaway

🎯 Key Insight: The monotonic property (if k works, then k-1 works too) allows us to binary search the answer instead of trying every possibility, reducing time complexity from O(n²) to O(n log n).

Asked in

G Google 42 a Amazon 38 ⊞ Microsoft 24 f Meta 18

The optimal solution uses binary search on the answer with time complexity O(n log n). The key insight is the monotonic property: if we can remove k characters and maintain the subsequence, we can remove any number ≤ k. This allows us to binary search for the maximum k, checking subsequence validity in O(n) time for each candidate.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try Every k)	O(n²)	O(n)	Try removing 0, 1, 2, ... k characters until pattern breaks
Binary Search (Optimal)	O(n log n)	O(n)	Binary search on the answer using monotonic property

Brute Force (Try Every k) — Algorithm Steps

Start with k = 0 and increment until removable.length
For each k, create a set of indices to remove (first k elements of removable)
Build the modified string by skipping removed indices
Check if p is still a subsequence of the modified string
Return the maximum k where subsequence check passes

Visualization

Tap to expand

Step-by-Step Walkthrough

Try k=0

Check if p is subsequence of original s

Try k=1

Remove first element from removable, check subsequence

Try k=2

Remove first two elements, check subsequence

Continue

Keep trying until subsequence check fails

Code -

solution.c — C

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

bool isSubsequence(char* s, char* p, bool* removed, int sLen, int pLen) {
    int i = 0, j = 0;
    while (i < sLen && j < pLen) {
        if (!removed[i] && s[i] == p[j]) {
            j++;
        }
        i++;
    }
    return j == pLen;
}

int maximumRemovals(char* s, char* p, int* removable, int removableSize) {
    int sLen = strlen(s);
    int pLen = strlen(p);
    bool* removed = (bool*)calloc(sLen, sizeof(bool));
    
    int maxK = 0;
    for (int k = 0; k <= removableSize; k++) {
        if (k > 0) {
            removed[removable[k-1]] = true;
        }
        if (isSubsequence(s, p, removed, sLen, pLen)) {
            maxK = k;
        } else {
            break;
        }
    }
    
    free(removed);
    return maxK;
}

int main() {
    // Implementation for input parsing would go here
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

O(n) iterations × O(n) subsequence check for each iteration

⚠ Quadratic Growth

Space Complexity

O(n)

Space for the removed indices set and modified string

⚡ Linearithmic Space

68.4K Views

High Frequency

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

Brute Force (Try Every k) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler