Make The String Great - Practice Coding Problems

Make The String Great - Problem

String Stack Easy

Given a string s containing both lowercase and uppercase English letters, your task is to make it "great" by removing problematic character pairs.

A great string is one where no two adjacent characters are the same letter in different cases (like 'a' next to 'A' or 'B' next to 'b'). These problematic pairs create bad adjacencies that need to be eliminated.

The Process: You can repeatedly choose any two adjacent characters that form a bad pair and remove both of them. Continue this process until no more bad pairs exist.

Goal: Return the final great string after all possible removals. The result is guaranteed to be unique, and an empty string is considered great too!

Example: "leEeetcode" → "leetcode" (remove 'e' and 'E')

Input & Output

example_1.py — Basic Case

$ Input: s = "leEeetcode"

› Output: "leetcode"

💡 Note: First, we remove 'eE' (positions 1,2) to get 'leetcode'. No more bad pairs exist, so we return 'leetcode'.

example_2.py — Complete Elimination

$ Input: s = "abBAcC"

› Output: ""

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

example_3.py — No Bad Pairs

$ Input: s = "s"

› Output: "s"

💡 Note: Single character string has no adjacent pairs, so it's already great. Return as is.

Constraints

1 ≤ s.length ≤ 100
s contains only English letters (both lowercase and uppercase)
Adjacent characters must be checked for same letter different case

Visualization

Tap to expand

Understanding the Visualization

Type Characters

As you type, the editor maintains a buffer of 'good' characters

Detect Mistakes

When a bad pair is detected (like 'eE'), the editor automatically backspaces

Auto-Correct

The mistake is removed, and typing continues seamlessly

Clean Text

Final result is clean text with no case-conflict pairs

Key Takeaway

🎯 Key Insight: Use a stack to maintain 'good' characters - when a bad pair is detected, simply pop the conflicting character, just like hitting backspace!

Asked in

f Facebook 15 a Amazon 12 G Google 8 ⊞ Microsoft 6

The optimal solution uses a stack-based approach to process characters in a single pass. When encountering a character that forms a bad pair with the stack top (same letter, different case), we pop the stack to remove the pair. Otherwise, we push the character. This achieves O(n) time complexity and elegantly handles cascading removals.

Common Approaches

Approach	Time	Space	Notes
✓ Stack-Based Approach (Optimal)	O(n)	O(n)	Use a stack to build result, pop when bad pair is found

Stack-Based Approach (Optimal) — Algorithm Steps

Initialize an empty stack (or result string)
Process each character in the input string from left to right
If stack is empty or current character doesn't form bad pair with stack top, push to stack
If current character forms bad pair with stack top, pop from stack (removes the pair)
Convert final stack to string and return

Visualization

Tap to expand

Step-by-Step Walkthrough

Process 'l'

Stack empty, push 'l' → Stack: [l]

Process 'e'

No bad pair with 'l', push 'e' → Stack: [l,e]

Process 'E'

Bad pair with 'e'! Pop 'e' → Stack: [l]

Continue...

Process remaining chars: 'eetcode' → Final: 'leetcode'

Code -

solution.c — C

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

char* makeGood(char* s) {
    int len = strlen(s);
    char* stack = malloc((len + 1) * sizeof(char));
    int top = -1;
    
    for (int i = 0; i < len; i++) {
        char c = s[i];
        if (top >= 0 && 
            tolower(stack[top]) == tolower(c) && stack[top] != c) {
            // Found bad pair with stack top, remove it
            top--;
        } else {
            // No bad pair, add current character
            stack[++top] = c;
        }
    }
    
    stack[top + 1] = '\0';
    return stack;
}

int main() {
    char input[1001];
    fgets(input, sizeof(input), stdin);
    // Remove quotes and newline
    char* s = malloc(strlen(input));
    strncpy(s, input + 1, strlen(input) - 3);
    s[strlen(input) - 3] = '\0';
    
    char* result = makeGood(s);
    printf("\"%s\"", result);
    free(s);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

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

✓ Linear Growth

Space Complexity

O(n)

In worst case (no bad pairs), the stack stores all n characters

⚡ Linearithmic Space

125.0K Views

Medium Frequency

~12 min Avg. Time

2.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

Stack-Based Approach (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler