Remove All Adjacent Duplicates In String - Practice Coding Problems

Remove All Adjacent Duplicates In String - Problem

String Stack Easy

Imagine you have a string of lowercase letters, and you have a special power: whenever you see two identical letters sitting next to each other, you can make them both disappear instantly! 💨

Your mission is to repeatedly use this power until there are no more adjacent duplicate pairs left. The fascinating thing is that removing one pair might create new adjacent duplicates elsewhere in the string.

Goal: Return the final string after all possible adjacent duplicate removals have been made.

Example: "abbaca" → Remove "bb" → "aaca" → Remove "aa" → "ca"

Note: The answer is guaranteed to be unique!

Input & Output

example_1.py — Basic Adjacent Duplicates

$ Input: s = "abbaca"

› Output: "ca"

💡 Note: First remove 'bb' → 'aaca', then remove 'aa' → 'ca'. No more adjacent duplicates remain.

example_2.py — Cascading Removal

$ Input: s = "azxxzy"

› Output: "ay"

💡 Note: Remove 'xx' → 'azzy', then remove 'zz' → 'ay'. The removal of one pair creates a new adjacent pair.

example_3.py — No Duplicates

$ Input: s = "abc"

› Output: "abc"

💡 Note: No adjacent duplicate characters exist, so the string remains unchanged.

Constraints

1 ≤ s.length ≤ 10⁵
s consists of lowercase English letters only
The answer is guaranteed to be unique

Visualization

Tap to expand

POP! (Cancel out)4Process 'a': Top = 'a' → POP! (Cancel out)5Process 'c': Stack empty → Push 'c'6Process 'a': Top ≠ 'a' → Push 'a'

Understanding the Visualization

Setup

Start with an empty stack and process string left to right

Push Rule

If stack is empty or top differs from current char, push current char

Pop Rule

If stack top equals current char, pop (both chars cancel out)

Result

Final stack contents form the answer

Key Takeaway

🎯 Key Insight: The stack automatically handles cascading removals - when we pop a duplicate pair, the previous character (now on top) might match the next character we process!

Asked in

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

The optimal solution uses a stack-based approach in O(n) time. Process each character: if it matches the stack top, pop (remove duplicate pair); otherwise push. This naturally handles cascading removals where removing one pair creates new adjacent duplicates.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Repeated String Scanning)	O(n²)	O(1)	Repeatedly scan the string and remove the first adjacent duplicate pair found
Stack-Based Solution (Optimal)	O(n)	O(n)	Use a stack to efficiently handle adjacent duplicates in one pass

Brute Force (Repeated String Scanning) — Algorithm Steps

Start with the original string
Scan through each character and its neighbor
If two adjacent characters are the same, remove both
Restart scanning from the beginning
Repeat until no adjacent duplicates remain

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial String

Start with the original string 'abbaca'

First Scan

Find 'bb' at positions 1-2, remove them → 'aaca'

Second Scan

Start over, find 'aa' at positions 0-1, remove them → 'ca'

Final Scan

No more adjacent duplicates found, return 'ca'

Code -

solution.c — C

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

char* removeDuplicates(char* s) {
    int len = strlen(s);
    
    while (true) {
        bool found = false;
        char* result = malloc(len + 1);
        int j = 0;
        
        for (int i = 0; i < strlen(s); i++) {
            if (i < strlen(s) - 1 && s[i] == s[i + 1]) {
                // Skip both duplicate characters
                i++; // Skip next char too
                found = true;
            } else {
                result[j++] = s[i];
            }
        }
        
        result[j] = '\0';
        strcpy(s, result);
        free(result);
        
        if (!found) break;
    }
    
    return s;
}

int main() {
    char input[100001];
    fgets(input, sizeof(input), stdin);
    
    // Remove quotes and newline
    char s[100001];
    int j = 0;
    for (int i = 0; input[i]; i++) {
        if (input[i] != '"' && input[i] != '\n') {
            s[j++] = input[i];
        }
    }
    s[j] = '\0';
    
    printf("\"%s\"\n", removeDuplicates(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

In worst case, we might need to scan the string n/2 times, each scan taking O(n) time

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables, modifying string in place

✓ Linear Space

87.5K Views

High Frequency

~15 min Avg. Time

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

Brute Force (Repeated String Scanning) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler