Resulting String After Adjacent Removals

Resulting String After Adjacent Removals - Problem

You are given a string s consisting of lowercase English letters. You must repeatedly perform the following operation while the string s has at least two consecutive characters:

Remove the leftmost 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 resulting string after no more operations can be performed.

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

Input & Output

Example 1 — Basic Removal

$ Input: s = "cabd"

› Output: "cd"

💡 Note: First we find the consecutive pair 'a' and 'b' at positions 1,2. After removing them, we get 'cd' with no more consecutive pairs.

Example 2 — Multiple Removals

$ Input: s = "dcba"

› Output: ""

💡 Note: Remove 'dc' → 'ba', then remove 'ba' → empty string.

Example 3 — Circular Case

$ Input: s = "za"

› Output: ""

💡 Note: Since the alphabet is circular, 'z' and 'a' are consecutive, so they form a removable pair.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8 f Meta 6

The key insight is to use a stack to process characters sequentially, removing consecutive pairs as we encounter them. The stack approach is optimal with O(n) time and O(n) space complexity, efficiently handling the leftmost pair requirement.

Common Approaches

✓ Brute Force - Repeated Scanning

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

Keep scanning the string from left to right, finding the leftmost consecutive pair and removing it. After each removal, restart the scan from the beginning. Continue until no more pairs can be found.

Stack-Based Approach

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

Process characters one by one from left to right. For each character, check if it forms a consecutive pair with the top of the stack. If yes, pop the stack (removing the pair). If no, push the current character. The stack contains the final result.

Brute Force - Repeated Scanning — Algorithm Steps

Scan string from left to find leftmost consecutive pair
Remove the pair and shift remaining characters
Repeat until no pairs found

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Scan

Find leftmost consecutive pair 'ab'

Remove Pair

Remove pair and shift remaining characters

Repeat

Scan again from start until no pairs found

Code -

solution.c — C

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

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

void solution(char* s) {
    int len = strlen(s);
    
    while (true) {
        bool found = false;
        for (int i = 0; i < len - 1; i++) {
            if (areConsecutive(s[i], s[i + 1])) {
                // Remove characters at i and i+1
                for (int j = i; j < len - 2; j++) {
                    s[j] = s[j + 2];
                }
                len -= 2;
                s[len] = '\0';
                found = true;
                break;
            }
        }
        if (!found) break;
    }
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    // Remove quotes if present
    int len = strlen(s);
    if (len > 0 && s[0] == '"') {
        memmove(s, s + 1, len);
        len--;
    }
    if (len > 0 && s[len - 1] == '"') {
        s[len - 1] = '\0';
    }
    
    solution(s);
    printf("%s\n", s);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

In worst case, we remove one pair per iteration, requiring O(n) iterations, each taking O(n) time to scan

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables (modifying input string in place conceptually)

✓ Linear Space

24.9K 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Repeated Scanning — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler