Remove All Adjacent Duplicates in String II

Remove All Adjacent Duplicates in String II - Problem

String Stack Medium

You are given a string s and an integer k. A k duplicate removal consists of choosing k adjacent and equal letters from s and removing them, causing the left and the right side of the deleted substring to concatenate together.

We repeatedly make k duplicate removals on s until we no longer can.

Return the final string after all such duplicate removals have been made. It is guaranteed that the answer is unique.

Input & Output

Example 1 — Basic Case

$ Input: s = "abccba", k = 2

› Output: ""

💡 Note: Remove "cc" → "abba", then remove "bb" → "aa", then remove "aa" → "" (empty string).

Example 2 — Multiple Removals

$ Input: s = "abbbaaca", k = 3

› Output: "ca"

💡 Note: First remove "bbb" → "abaaca", then remove "aaa" → "ca". No more k=3 adjacent duplicates.

Example 3 — No Removals

$ Input: s = "aa", k = 3

› Output: "aa"

💡 Note: No groups of 3 consecutive identical characters exist, so string remains unchanged.

Constraints

1 ≤ s.length ≤ 10⁵
2 ≤ k ≤ 10⁴
s only contains lower case English letters.

Visualization

Tap to expand

Asked in

F Facebook 45 a Amazon 35 G Google 30 M Microsoft 25

The key insight is to use a stack to track characters and their consecutive counts. When we encounter k consecutive identical characters, we remove them immediately. The stack approach is optimal with Time: O(n), Space: O(n).

Common Approaches

✓ Brute Force - Repeated String Search

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

Keep scanning the entire string from left to right to find k consecutive identical characters. When found, remove them and start over. Continue until no more removals possible.

Stack with Character Counting

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

Process string character by character. Use a stack where each element stores a character and its count. When we encounter the same character, increment count. When count reaches k, remove the stack element.

Brute Force - Repeated String Search — Algorithm Steps

Scan string for k consecutive identical characters
Remove them if found and restart from beginning
Repeat until no more removals possible

Visualization

Tap to expand

Step-by-Step Walkthrough

Scan

Find first group of k consecutive identical characters

Remove

Delete the k characters and restart from beginning

Repeat

Continue until no more groups found

Code -

solution.c — C

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

char* solution(char* s, int k) {
    int len = strlen(s);
    char* result = malloc((len + 1) * sizeof(char));
    strcpy(result, s);
    
    while (true) {
        bool found = false;
        len = strlen(result);
        for (int i = 0; i <= len - k; i++) {
            bool allSame = true;
            for (int j = 1; j < k; j++) {
                if (result[i] != result[i + j]) {
                    allSame = false;
                    break;
                }
            }
            if (allSame) {
                memmove(result + i, result + i + k, len - i - k + 1);
                found = true;
                break;
            }
        }
        if (!found) break;
    }
    return result;
}

int main() {
    char s[100001];
    int k;
    scanf("%s", s);
    scanf("%d", &k);
    
    char* result = solution(s, k);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

In worst case, each character removal requires full string scan, leading to O(n) scans × O(n) work per scan

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables, no extra data structures

✓ Linear Space

67.5K Views

Medium Frequency

~15 min Avg. Time

1.9K 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 Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler