Apply Operations to Make String Empty - Practice Coding Problems

Apply Operations to Make String Empty - Problem

You are given a string s. Your task is to repeatedly apply a special operation until the string becomes empty, then return the string right before the final operation.

The Operation: In each round, scan through the alphabet from 'a' to 'z' and remove the first occurrence of each letter that exists in the current string.

Example walkthrough:

Initial: s = "aabcbbca"
Round 1: Remove first 'a', first 'b', first 'c' → "abbca"
Round 2: Remove first 'a', first 'b', first 'c' → "ba"
Round 3: Remove first 'a', first 'b' → "" (empty)
Answer: "ba" (string before the final operation)

This problem tests your ability to simulate operations efficiently and understand when to stop the process.

Input & Output

example_1.py — Standard Case

$ Input: "aabcbbca"

› Output: "ba"

💡 Note: Round 1: Remove first 'a', 'b', 'c' → 'abbca'. Round 2: Remove first 'a', 'b', 'c' → 'ba'. Round 3: Remove 'a', 'b' → empty. Answer is 'ba' (before final round).

example_2.py — Single Character Types

$ Input: "abcdef"

› Output: ""

💡 Note: Round 1: Remove 'a', 'b', 'c', 'd', 'e', 'f' → empty string. Since it becomes empty in one round, return empty string.

example_3.py — Multiple Same Characters

$ Input: "aaaa"

› Output: "a"

💡 Note: Round 1: Remove first 'a' → 'aaa'. Round 2: Remove first 'a' → 'aa'. Round 3: Remove first 'a' → 'a'. Round 4: Remove 'a' → empty. Answer is 'a'.

Visualization

Tap to expand

Understanding the Visualization

Day 1 Setup

Books arranged: A A B C B B C A

Day 1 Collection

Collect first A, first B, first C → Remaining: A B B C A

Day 2 Collection

Collect first A, first B, first C → Remaining: B A

Day 3 Collection

Collect A and B → Empty pile

Answer

The day before the pile became empty, we had: B A

Key Takeaway

🎯 Key Insight: Each character's survival depends on how many identical characters come before it in the original string. We need the second-to-last non-empty state!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to count frequencies and another pass to build result

✓ Linear Growth

Space Complexity

O(1)

Only need constant space for character counting (at most 26 characters)

✓ Linear Space

Constraints

1 ≤ s.length ≤ 10⁵
s consists of only lowercase English letters
The string will always become empty after finite operations

Asked in

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

The optimal solution uses character frequency counting to determine how many rounds each character survives. Key insight: each character survives exactly as many rounds as there are characters of the same type before it. We find characters that survive exactly max_rounds - 1 to get the second-to-last state.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (String Simulation)	O(n²)	O(n)	Simulate each operation by scanning and removing characters repeatedly
One-Pass Counting (Optimal)	O(n)	O(1)	Count character frequencies and determine survival rounds in one pass

Brute Force (String Simulation) — Algorithm Steps

Start with the original string
For each operation round, create a new result string
Scan through alphabet 'a' to 'z'
For each letter, find and skip its first occurrence in current string
Continue until string becomes empty
Return the last non-empty string

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial String

Start with original string 'aabcbbca'

Round 1 - Remove a,b,c

First 'a', first 'b', first 'c' are removed

Result: 'abbca'

Remaining characters after round 1

Round 2 - Remove a,b,c

Again remove first occurrence of each

Result: 'ba'

This is our answer - last non-empty state

Code -

solution.c — C

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

char* lastRemaining(char* s) {
    if (!s || strlen(s) == 0) return "";
    
    char* prev = malloc(strlen(s) + 1);
    char* current = malloc(strlen(s) + 1);
    strcpy(prev, s);
    strcpy(current, s);
    
    while (strlen(current) > 0) {
        strcpy(prev, current);
        char nextString[1001] = "";
        bool used[26] = {false};
        int nextIdx = 0;
        
        // Go through each character in current string
        for (int i = 0; current[i]; i++) {
            char c = current[i];
            // If we haven't used this character type yet in this round
            if (!used[c - 'a']) {
                used[c - 'a'] = true;
            } else {
                // Keep this character for next round
                nextString[nextIdx++] = c;
            }
        }
        
        strcpy(current, nextString);
    }
    
    return prev;
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    // Remove quotes and newline
    char* clean = s + 1;
    clean[strlen(clean) - 2] = '\0';
    printf("\"%s\"\n", lastRemaining(clean));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Each operation can take O(n) time to process the string, and we might need O(n) operations in worst case

⚠ Quadratic Growth

Space Complexity

O(n)

We create new strings for each operation, storing intermediate results

⚡ Linearithmic Space

Constraints

1 ≤ s.length ≤ 10⁵
s consists of only lowercase English letters
The string will always become empty after finite operations

43.5K Views

Medium-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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (String Simulation) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler