Apply Operations to Make String Empty

Apply Operations to Make String Empty - Problem

You are given a string s. Consider performing the following operation until s becomes empty:

For every alphabet character from 'a' to 'z', remove the first occurrence of that character in s (if it exists).

For example, let initially s = "aabcbbca". We do the following operations:

Remove the underlined characters s = "aabcbbca". The resulting string is s = "abbca".
Remove the underlined characters s = "abbca". The resulting string is s = "ba".
Remove the underlined characters s = "ba". The resulting string is s = "".

Return the value of the string s right before applying the last operation. In the example above, answer is "ba".

Input & Output

Example 1 — Basic Case

$ Input: s = "aabcbbca"

› Output: "ba"

💡 Note: After round 1: remove first 'a', 'b', 'c' → "abbca". After round 2: remove first 'a', 'b', 'c' → "ba". After round 3: remove first 'a', 'b' → "". Return "ba" from before the last operation.

Example 2 — Single Character

$ Input: s = "abcd"

› Output: ""

💡 Note: All characters appear once. After first round, all are removed and string becomes empty. The string before last operation is empty.

Example 3 — Repeated Pattern

$ Input: s = "aaaa"

› Output: "a"

💡 Note: Character 'a' appears 4 times. Each round removes one 'a', so we get: "aaaa" → "aaa" → "aa" → "a" → "". Return "a" from before the last operation.

Constraints

1 ≤ s.length ≤ 5 × 10⁴
s consists of lowercase English letters only

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is that characters with maximum frequency will be the last ones remaining before the string becomes empty. We can solve this efficiently by counting character frequencies in O(n) time instead of simulating the removal process. Best approach is frequency counting: Time: O(n), Space: O(1).

Common Approaches

✓ One Pass Hash

⏱️ Time: N/A Space: N/A

Frequency Counting Approach

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

Count frequency of each character, then determine how many rounds each character survives. The characters that survive to the second-to-last round form our answer.

Simulation Approach

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

For each operation, scan through the string from left to right and remove the first occurrence of each character from 'a' to 'z'. Continue until the string is empty, keeping track of the previous state.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

void solution(char* s, char* result) {
    static char current[1001];
    static char previous[1001];
    static char next_string[1001];
    
    strcpy(current, s);
    
    while (strlen(current) > 0) {
        strcpy(previous, current);
        next_string[0] = '\0';
        bool used[256] = {false};
        
        int len = strlen(current);
        int next_len = 0;
        
        for (int i = 0; i < len; i++) {
            char c = current[i];
            if (!used[(unsigned char)c]) {
                used[(unsigned char)c] = true;
            } else {
                next_string[next_len++] = c;
            }
        }
        next_string[next_len] = '\0';
        
        if (strcmp(next_string, current) == 0) {
            break;
        }
        strcpy(current, next_string);
        
        if (strlen(current) == 0) {
            strcpy(result, previous);
            return;
        }
    }
    
    strcpy(result, current);
}

int main() {
    char s[1001];
    char result[1001];
    scanf("%s", s);
    solution(s, result);
    printf("%s\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

23.4K Views

Medium Frequency

~15 min Avg. Time

890 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