Find Resultant Array After Removing Anagrams

Find Resultant Array After Removing Anagrams - Problem

Find Resultant Array After Removing Anagrams

You are given a 0-indexed string array words, where each words[i] consists of lowercase English letters only.

Your task is to perform a cleanup operation repeatedly: select any index i where 0 < i < words.length and words[i - 1] and words[i] are anagrams, then delete words[i] from the array.

Keep performing this operation until no more adjacent anagram pairs exist. The beauty of this problem is that the order of operations doesn't matter - you'll always get the same final result!

What's an anagram? Two words are anagrams if one can be formed by rearranging the letters of the other using all letters exactly once. For example, "dacb" and "abdc" are anagrams.

Goal: Return the final array after all possible removals.

Input & Output

example_1.py — Basic Case

$ Input: ["abba","baba","bbaa","cd","cd"]

› Output: ["abba","cd"]

💡 Note: "baba" is an anagram of "abba", so remove it. "bbaa" is also an anagram of "abba", so remove it. The second "cd" is an anagram of the first "cd", so remove it. Final result: ["abba", "cd"]

example_2.py — No Removals

$ Input: ["a","b","c"]

› Output: ["a","b","c"]

💡 Note: No two adjacent words are anagrams of each other, so no words are removed. The array remains unchanged.

example_3.py — All Same Anagrams

$ Input: ["a","a","a"]

› Output: ["a"]

💡 Note: All words are identical (and thus anagrams). We keep the first one and remove all subsequent identical words.

Constraints

1 ≤ words.length ≤ 100
1 ≤ words[i].length ≤ 10
words[i] consists of lowercase English letters only
Order of operations doesn't affect the final result

Visualization

Tap to expand

Understanding the Visualization

Start with First Book

Always keep the first book as your reference

Create Signatures

For each book, create a signature by sorting its title letters

Compare and Decide

If the signature matches the last kept book, remove it; otherwise keep it

Update Reference

When keeping a book, update your reference signature

Key Takeaway

🎯 Key Insight: Instead of repeatedly scanning for adjacent anagrams, build the result array in one pass by comparing each word's signature only with the last word you decided to keep. This transforms an O(n²) repeated-scan approach into an optimal O(n × m log m) single-pass solution!

Asked in

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

The optimal solution uses a one-pass approach with signature comparison. Create a signature for each word by sorting its characters, then compare each word's signature only with the last kept word. This eliminates the need for repeated scanning and achieves O(n × m log m) time complexity where n is the number of words and m is the average word length.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Repeated Scanning)	O(n² × m log m)	O(1)	Repeatedly scan the array and remove adjacent anagrams until no more exist
One-Pass Optimal Solution	O(n × m log m)	O(n × m)	Build result array in one pass using signature comparison

Brute Force (Repeated Scanning) — Algorithm Steps

Start with the original array
Scan from index 1 to end, checking if words[i] and words[i-1] are anagrams
If anagrams found, remove words[i] and restart from step 2
If no anagrams found in a complete scan, return the array
Use sorted character comparison to check if two words are anagrams

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Array

Start with the original array of words

First Pass

Scan and remove first adjacent anagram pair found

Restart

Start scanning from beginning again

Continue

Repeat until no more anagrams found

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    return (*(char*)a - *(char*)b);
}

int areAnagrams(char* word1, char* word2) {
    int len1 = strlen(word1), len2 = strlen(word2);
    if (len1 != len2) return 0;
    
    char temp1[100], temp2[100];
    strcpy(temp1, word1);
    strcpy(temp2, word2);
    
    qsort(temp1, len1, sizeof(char), compare);
    qsort(temp2, len2, sizeof(char), compare);
    
    return strcmp(temp1, temp2) == 0;
}

int removeAnagrams(char words[][100], int size) {
    int changed = 1;
    while (changed) {
        changed = 0;
        for (int i = 1; i < size; i++) {
            if (areAnagrams(words[i-1], words[i])) {
                for (int j = i; j < size - 1; j++) {
                    strcpy(words[j], words[j+1]);
                }
                size--;
                changed = 1;
                break;
            }
        }
    }
    return size;
}

int main() {
    char words[100][100] = {"abba", "baba", "bbaa", "cd", "cd"};
    int size = 5;
    int newSize = removeAnagrams(words, size);
    
    printf("[");
    for (int i = 0; i < newSize; i++) {
        printf("\"%s\"", words[i]);
        if (i < newSize - 1) printf(",");
    }
    printf("]\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × m log m)

In worst case, we might need n passes through the array, and for each comparison we sort strings of length m

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for the algorithm (excluding output array modifications)

✓ Linear Space

23.5K Views

Medium Frequency

~15 min Avg. Time

892 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