Lexicographically Smallest String After Adjacent Removals

Lexicographically Smallest String After Adjacent Removals - Problem

Find the lexicographically smallest string after optimally removing consecutive character pairs from a string of lowercase letters.

You're given a string s containing only lowercase English letters. You can perform the following operation any number of times:

• Remove any pair of adjacent characters that are consecutive in the alphabet (like 'a' and 'b', or 'b' and 'a')
• The alphabet is circular, so 'a' and 'z' are also consecutive
• After removal, remaining characters shift left to fill the gap

Your goal is to find the lexicographically smallest string possible after performing these operations optimally.

Example: "abdc" → remove "ab" → "dc" → remove "cd" → "" (empty string)

Input & Output

example_1.py — Basic Elimination

$ Input: s = "abdc"

› Output: ""

💡 Note: Remove 'ab' → 'dc', then remove 'cd' → empty string. This is lexicographically smallest.

example_2.py — Circular Consecutive

$ Input: s = "zabc"

› Output: "bc"

💡 Note: Remove 'za' (circular consecutive) → 'bc'. No more consecutive pairs can be removed.

example_3.py — No Removals

$ Input: s = "aceg"

› Output: "aceg"

💡 Note: No adjacent characters are consecutive, so no pairs can be removed. Original string is returned.

Constraints

1 ≤ s.length ≤ 10⁵
s consists of lowercase English letters only
The alphabet is circular: 'a' and 'z' are consecutive

Visualization

Tap to expand

Understanding the Visualization

Initialize

Start with empty stack and process string left-to-right

Check Top

For each character, check if it forms consecutive pair with stack top

Eliminate or Add

If consecutive, pop the pair. Otherwise, push the character

Continue

Repeat until all characters processed

Key Takeaway

🎯 Key Insight: The stack-based approach automatically finds the optimal solution by processing characters left-to-right and immediately eliminating consecutive pairs, ensuring the lexicographically smallest result without trying all possibilities.

Asked in

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

The optimal solution uses a stack-based approach to process characters left-to-right, immediately eliminating consecutive pairs when they form at the stack top. This single-pass O(n) algorithm automatically produces the lexicographically smallest result without exploring all possible elimination orders.

Common Approaches

Approach	Time	Space	Notes
✓ Stack-Based Elimination (Optimal)	O(n)	O(n)	Use a stack to immediately eliminate consecutive pairs as they form

Stack-Based Elimination (Optimal) — Algorithm Steps

Initialize an empty stack
Process each character from left to right
If stack is empty or current character doesn't form consecutive pair with top, push to stack
If current character forms consecutive pair with stack top, pop the stack (eliminate the pair)
The remaining characters in the stack form the final result

Visualization

Tap to expand

Step-by-Step Walkthrough

Process 'a'

Stack empty, push 'a': [a]

Process 'b'

'b' consecutive with 'a', pop 'a': []

Process 'd'

Stack empty, push 'd': [d]

Process 'c'

'c' consecutive with 'd', pop 'd': []

Code -

solution.c — C

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

int isConsecutive(char a, char b) {
    int diff = abs(a - b);
    return diff == 1 || diff == 25;
}

char* smallestString(char* s) {
    int len = strlen(s);
    char* stack = malloc(len + 1);
    int top = -1;
    
    for (int i = 0; i < len; i++) {
        if (top >= 0 && isConsecutive(stack[top], s[i])) {
            top--; // Remove the consecutive pair
        } else {
            stack[++top] = s[i];
        }
    }
    
    stack[top + 1] = '\0';
    return stack;
}

int main() {
    char input[1001];
    fgets(input, sizeof(input), stdin);
    input[strcspn(input, "\n")] = 0;
    
    // Remove quotes
    char* s = input + 1;
    s[strlen(s) - 1] = '\0';
    
    char* result = smallestString(s);
    printf("\"%s\"\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each character is pushed and popped at most once from the stack

✓ Linear Growth

Space Complexity

O(n)

Stack can contain at most n characters in worst case

⚡ Linearithmic Space

31.3K Views

Medium-High Frequency

~25 min Avg. Time

1.3K 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 Elimination (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler