Lexicographically Smallest String After Adjacent Removals

Lexicographically Smallest String After Adjacent Removals - Problem

You are given a string s consisting of lowercase English letters. You can perform the following operation any number of times (including zero):

Remove any pair of adjacent characters in the string that are consecutive in the alphabet, in either order (e.g., 'a' and 'b', or 'b' and 'a'). Shift the remaining characters to the left to fill the gap.

Return the lexicographically smallest string that can be obtained after performing the operations optimally.

Note: Consider the alphabet as circular, thus 'a' and 'z' are consecutive.

Input & Output

Example 1 — Consecutive Pairs

$ Input: s = "abdc"

› Output: ""

💡 Note: Remove 'ab' to get "dc", then remove 'dc' to get empty string. Result is lexicographically smallest.

Example 2 — Circular Case

$ Input: s = "azyx"

› Output: "yx"

💡 Note: Remove 'za' (circular consecutive) to get "yx". No more consecutive pairs can be removed.

Example 3 — No Removals

$ Input: s = "aceg"

› Output: "aceg"

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

Constraints

1 ≤ s.length ≤ 1000
s consists of lowercase English letters

Visualization

Tap to expand

Asked in

G Google 45 f Meta 35 a Amazon 30

The key insight is to use a stack for greedy removal of consecutive adjacent pairs. As we process each character, if it forms a consecutive pair with the stack top, we remove both (pop from stack). Otherwise, we add the character to stack. Best approach is the Stack-Based Greedy solution. Time: O(n), Space: O(n)

Common Approaches

✓ Sliding Window

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

Brute Force with Recursion

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

For each string, find all possible consecutive adjacent pairs, remove each one recursively, and return the lexicographically smallest result among all possibilities.

Stack-Based Greedy Approach

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

Process characters one by one, using a stack to store result. When adding a character, check if it forms a consecutive pair with the top of stack - if so, remove the pair (pop from stack). Otherwise, push the character.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

bool areConsecutive(char a, char b) {
    int diff1 = (b - a + 26) % 26;
    int diff2 = (a - b + 26) % 26;
    return diff1 == 1 || diff2 == 1;
}

void simulateRemovals(char* s, char* result) {
    int stackSize = 0;
    static char stack[1001];
    
    int len = strlen(s);
    for (int i = 0; i < len; i++) {
        char c = s[i];
        if (stackSize > 0 && areConsecutive(stack[stackSize-1], c)) {
            stackSize--;
        } else {
            stack[stackSize++] = c;
        }
    }
    
    for (int i = 0; i < stackSize; i++) {
        result[i] = stack[i];
    }
    result[stackSize] = '\0';
}

void solution(char* s, char* result) {
    static char temp1[1001], temp2[1001];
    strcpy(temp1, s);
    
    while (true) {
        simulateRemovals(temp1, temp2);
        if (strcmp(temp1, temp2) == 0) {
            break;
        }
        strcpy(temp1, temp2);
    }
    
    strcpy(result, temp1);
}

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

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

28.5K Views

Medium Frequency

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