Minimum String Length After Removing Substrings

Minimum String Length After Removing Substrings - Problem

Problem: You are given a string s consisting only of uppercase English letters. Your task is to repeatedly remove occurrences of the substrings "AB" or "CD" from the string until no more such substrings exist.

Goal: Return the minimum possible length of the resulting string after all possible removals.

Important: After removing a substring, the remaining parts concatenate and may form new "AB" or "CD" substrings that can be removed in subsequent operations.

Example: For string "ABFCDB", we can remove "AB" to get "FCDB", then remove "CD" to get "FB". The final length is 2.

Input & Output

example_1.py — Basic Removal

$ Input: s = "ABFCDB"

› Output: 2

💡 Note: We can remove 'AB' to get 'FCDB', then remove 'CD' to get 'FB'. No more removals possible, so final length is 2.

example_2.py — Multiple Cascading Removals

$ Input: s = "ACBDCD"

› Output: 2

💡 Note: First remove 'CD' to get 'ACBD', then we can remove 'CB' (no, wait - only AB and CD can be removed). Actually, we remove 'CD' to get 'ACBD', no further removals possible. Length is 4. Let me recalculate: Remove 'CD' -> 'ACB' + 'D' = 'ACBD'. No AB or CD found. Wait, that's wrong. Let me trace: 'ACBDCD' - we can remove the last 'CD' to get 'ACBD', but we're looking for 'AB' or 'CD' only. Actually 'ACBD' has no removable substrings. But if we had 'ACDBCD', removing first 'CD' gives 'ABCD', then 'AB' gives 'CD', then 'CD' gives ''. Let me use a proper example.

example_2.py — Multiple Cascading Removals

$ Input: s = "ACDBCD"

› Output: 0

💡 Note: Remove 'CD' to get 'ABCD', then remove 'AB' to get 'CD', finally remove 'CD' to get empty string. Length is 0.

example_3.py — No Removals Possible

$ Input: s = "CXABY"

› Output: 5

💡 Note: The string contains no 'AB' or 'CD' substrings that can be removed, so the length remains 5.

Constraints

1 ≤ s.length ≤ 100
s consists only of uppercase English letters
Only substrings 'AB' and 'CD' can be removed

Visualization

Tap to expand

B forms AB pair
→ Pop AStep 3FPush FStep 4-5CFPush C, then
D forms CD pair
→ Pop CFinalBFPush B
Final length: 2

Understanding the Visualization

Start with Empty Stack

Begin processing the string with an empty stack representing the final result

Process Each Character

For each character, decide whether to add it or remove a previous character

Check for Removable Pairs

If current character forms 'AB' or 'CD' with stack top, remove the pair

Build Final Result

Characters remaining in stack represent the minimum length string

Key Takeaway

🎯 Key Insight: The stack naturally handles the 'last-in, first-out' behavior needed when removals create new adjacent pairs that can also be removed!

Asked in

a Amazon 25 ⊞ Microsoft 18 G Google 15 f Meta 12

The optimal solution uses a stack-based approach to simulate string removals in O(n) time. As we iterate through each character, we either push it onto the stack or pop the previous character if they form a removable 'AB' or 'CD' pair. This elegantly handles the cascading effect of removals without actually modifying strings, making it both time and space efficient.

Common Approaches

Approach	Time	Space	Notes
✓ Stack-Based Simulation (Optimal)	O(n)	O(n)	Use a stack to simulate the removal process in a single pass through the string
Brute Force (Repeated String Search)	O(n²)	O(n)	Repeatedly scan the string and remove the first occurrence of AB or CD until no more exist

Stack-Based Simulation (Optimal) — Algorithm Steps

Initialize an empty stack
Iterate through each character in the string
For each character, check if it can form 'AB' or 'CD' with the top of stack
If yes, pop the stack (simulating removal of the pair)
If no, push the current character onto the stack
Return the size of the final stack

Visualization

Tap to expand

Step-by-Step Walkthrough

Process Each Character

Iterate through the string one character at a time

Check for Pairs

Compare current character with the top of stack for 'AB' or 'CD' patterns

Remove or Add

Either pop the stack (remove pair) or push the character

Final Count

The stack size represents the minimum possible string length

Code -

solution.c — C

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

int minLength(char* s) {
    char stack[1000];
    int top = -1;
    int len = strlen(s);
    
    for (int i = 0; i < len; i++) {
        char c = s[i];
        
        // Check if current char forms a removable pair with stack top
        if (top >= 0 &&
            ((stack[top] == 'A' && c == 'B') ||
             (stack[top] == 'C' && c == 'D'))) {
            top--;  // Remove the pair
        } else {
            stack[++top] = c;  // Add current character
        }
    }
    
    return top + 1;
}

int main() {
    char s[1000];
    fgets(s, sizeof(s), stdin);
    
    // Remove newline and quotes
    s[strcspn(s, "\n")] = 0;
    if (s[0] == '"' && s[strlen(s)-1] == '"') {
        s[strlen(s)-1] = 0;
        memmove(s, s + 1, strlen(s));
    }
    
    printf("%d\n", minLength(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We iterate through each character exactly once, and each stack operation is O(1)

✓ Linear Growth

Space Complexity

O(n)

In worst case, all characters remain in the stack (no removals possible)

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~12 min Avg. Time

845 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