Resulting String After Adjacent Removals - Practice Coding Problems

Resulting String After Adjacent Removals - Problem

You are given a string s consisting of lowercase English letters. Your task is to repeatedly remove consecutive alphabet pairs until no more removals are possible.

Rules:

Find the leftmost pair of adjacent characters that are consecutive in the alphabet
Characters can be in either order (e.g., 'ab' or 'ba')
The alphabet is circular: 'a' and 'z' are consecutive
After removal, shift remaining characters left to fill the gap
Repeat until no more pairs can be removed

Example: "abdc" → Remove 'ab' → "dc" → Remove 'dc' → ""

Return the final string after all possible removals.

Input & Output

example_1.py — Basic removal

$ Input: s = "abdc"

› Output: ""

💡 Note: Remove 'ab' (consecutive) → 'dc'. Remove 'dc' (consecutive) → empty string.

example_2.py — Circular alphabet

$ Input: s = "zaba"

› Output: ""

💡 Note: Remove 'za' (circular consecutive) → 'ba'. Remove 'ba' (consecutive) → empty string.

example_3.py — No removals possible

$ Input: s = "aceg"

› Output: "aceg"

💡 Note: No adjacent characters are consecutive in alphabet, so no removals possible.

Constraints

1 ≤ s.length ≤ 10⁵
s consists of lowercase English letters only
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

Push or Pop

For each character, either cancel with top (if consecutive) or add to stack

Cascade Effect

Removals can create new consecutive pairs automatically

Final Result

Remaining stack content is the answer

Key Takeaway

🎯 Key Insight: Stack naturally handles the cascade effect where removing one pair can create new consecutive pairs that also need to be removed.

Asked in

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

The optimal solution uses a stack-based simulation approach. Process characters one by one: if the current character forms a consecutive pair with the stack top, pop the stack (simulating removal); otherwise push the character. This naturally handles cascade removals and runs in O(n) time.

Common Approaches

Approach	Time	Space	Notes
✓ Stack-Based Simulation (Optimal)	O(n)	O(n)	Use stack to simulate the removal process efficiently in single pass
Brute Force (Repeated String Scanning)	O(n²)	O(n)	Repeatedly scan string from left to right, remove first consecutive pair found

Stack-Based Simulation (Optimal) — Algorithm Steps

Initialize empty stack
For each character in string:
Check if stack is non-empty and top forms consecutive pair with current char
If yes: pop stack (simulates removal)
If no: push current character to stack
Convert remaining stack to string

Visualization

Tap to expand

Step-by-Step Walkthrough

Process 'a'

Stack empty, push 'a'

Process 'b'

'a' and 'b' consecutive, pop 'a'

Process 'd'

Stack empty, push 'd'

Process 'c'

'd' and 'c' consecutive, pop 'd'

Final Stack

Stack empty, return empty string

Code -

solution.c — C

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

int areConsecutive(char a, char b) {
    int diff = abs(a - b);
    return diff == 1 || (a == 'a' && b == 'z') || (a == 'z' && b == 'a');
}

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

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each character is pushed and popped at most once

✓ Linear Growth

Space Complexity

O(n)

Stack can hold up to n characters in worst case

⚡ Linearithmic Space

38.7K Views

High Frequency

~18 min Avg. Time

1.5K 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 Simulation (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler