Make The String Great

Make The String Great - Problem

String Stack Easy

Given a string s of lower and upper case English letters.

A good string is a string which doesn't have two adjacent characters s[i] and s[i + 1] where:

0 <= i <= s.length - 2
s[i] is a lower-case letter and s[i + 1] is the same letter but in upper-case or vice-versa.

To make the string good, you can choose two adjacent characters that make the string bad and remove them. You can keep doing this until the string becomes good.

Return the string after making it good. The answer is guaranteed to be unique under the given constraints.

Notice that an empty string is also good.

Input & Output

Example 1 — Basic Removal

$ Input: s = "leEeetcode"

› Output: "leetcode"

💡 Note: Remove the 'eE' pair: 'e' and 'E' are the same letter but different cases, so we remove both. Result: "leetcode"

Example 2 — Multiple Removals

$ Input: s = "abBAcC"

› Output: ""

💡 Note: Remove 'bB' → "aAcC", then remove 'cC' → "aA", finally remove 'aA' → "". Result: empty string

Example 3 — No Removals Needed

$ Input: s = "s"

› Output: "s"

💡 Note: Single character has no adjacent pairs to remove. Result: "s"

Constraints

1 ≤ s.length ≤ 100
s contains only lowercase and uppercase English letters

Visualization

Tap to expand

Asked in

f Facebook 15 a Amazon 12

The key insight is to use a stack to efficiently handle cascading character removals. When we encounter a character that forms a bad pair with the stack top (same letter, different case), we pop the stack instead of pushing. Best approach is the stack solution with Time: O(n), Space: O(n).

Common Approaches

✓ Repeated Scanning

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

Keep scanning the string from left to right, removing the first bad pair found. Repeat this process until no more bad pairs exist. This is inefficient because each removal requires rebuilding the string.

Stack-Based Solution

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

Iterate through the string once, using a stack to build the result. When we encounter a character that forms a bad pair with the top of the stack, we pop the stack instead of adding the character. This efficiently handles cascading removals.

Repeated Scanning — Algorithm Steps

Step 1: Scan string for adjacent bad pairs
Step 2: Remove first bad pair found
Step 3: Repeat until no bad pairs remain

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Scan

Find first bad pair

Remove Pair

Create new string without the pair

Repeat

Scan again until no pairs found

Code -

solution.c — C

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

char* solution(char* s) {
    int len = strlen(s);
    char* result = (char*)malloc((len + 1) * sizeof(char));
    
    while (1) {
        int found = 0;
        int pos = 0;
        int i = 0;
        while (i < strlen(s)) {
            if (i < strlen(s) - 1 && s[i] != s[i + 1] && tolower(s[i]) == tolower(s[i + 1])) {
                // Found a bad pair, skip both characters
                i += 2;
                found = 1;
            } else {
                result[pos++] = s[i];
                i++;
            }
        }
        result[pos] = '\0';
        strcpy(s, result);
        if (!found) break;
    }
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n²)

In worst case, we need n/2 iterations, each scanning the entire string

✓ Linear Growth

Space Complexity

O(n)

String operations create temporary strings

⚡ Linearithmic Space

94.0K Views

Medium Frequency

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

Repeated Scanning — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler