Groups of Special-Equivalent Strings - Practice Coding Problems

Groups of Special-Equivalent Strings - Problem

Groups of Special-Equivalent Strings

You are given an array of strings words where all strings have the same length. Here's the twist: you can perform special swaps within each string!

Special Swap Rules:
• You can swap any two characters at even indices (0, 2, 4, ...)
• You can swap any two characters at odd indices (1, 3, 5, ...)
• You can perform these swaps as many times as you want

Two strings are special-equivalent if you can transform one into the other using these special swaps. For example, "zzxy" and "xyzz" are special-equivalent because:
"zzxy" → "xzzy" (swap even indices 0,2)
"xzzy" → "xyzz" (swap odd indices 1,3)

Your Goal: Find the number of groups where each group contains all strings that are special-equivalent to each other, and no string from different groups can be special-equivalent.

Input & Output

example_1.py — Basic Example

$ Input: ["abcd","cdab","cbad","xyzz","zzxy","zzyx"]

› Output: 3

💡 Note: Group 1: ["abcd","cdab","cbad"] - all have even chars [a,c] and odd chars [b,d]. Group 2: ["xyzz","zzxy"] - both have even chars [x,z] and odd chars [y,z]. Group 3: ["zzyx"] - has even chars [z,y] and odd chars [z,x], which is unique.

example_2.py — All Same Group

$ Input: ["abc","acb","bac","bca","cab","cba"]

› Output: 3

💡 Note: For length 3 strings: Group 1: ["abc","bac"] (even:[a,c], odd:[b]). Group 2: ["acb","cab"] (even:[a,b], odd:[c]). Group 3: ["bca","cba"] (even:[b,a], odd:[c]).

example_3.py — Single Characters

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

› Output: 3

💡 Note: Each single character string forms its own group since they have different even characters and no odd characters.

Constraints

1 ≤ words.length ≤ 1000
1 ≤ words[i].length ≤ 20
words[i] consists of lowercase English letters
All the strings are of the same length

Visualization

Tap to expand

Understanding the Visualization

Separate Card Positions

For each deck, separate cards at even and odd positions into two groups

Sort Each Group

Sort the even-position cards and odd-position cards independently

Create Deck Signature

Combine the sorted groups to create a unique fingerprint for each deck

Count Unique Signatures

Decks with the same signature belong to the same group

Key Takeaway

🎯 Key Insight: Two strings are special-equivalent if and only if they have the same sorted characters at even positions AND the same sorted characters at odd positions. This allows us to create unique signatures and count groups efficiently!

Asked in

G Google 15 a Amazon 8 ⊞ Microsoft 5 f Facebook 3

The optimal approach uses a hash-based signature method. For each string, we extract characters at even and odd positions separately, sort them independently, and create a unique signature. Two strings are special-equivalent if and only if they have the same signature. The answer is the number of unique signatures, which can be efficiently computed using a hash set in O(n × m log m) time.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Compare All Pairs)	O(n² × m)	O(n)	Compare every string with every other string to check if they're special-equivalent
Hash Table with Signature (Optimal)	O(n × m log m)	O(n × m)	Create unique signatures for each string and count distinct signatures

Brute Force (Compare All Pairs) — Algorithm Steps

For each pair of strings in the array
Extract characters at even and odd positions for both strings
Check if even characters of first string can be rearranged to match even characters of second string
Check if odd characters of first string can be rearranged to match odd characters of second string
If both conditions are true, mark them as equivalent
Count connected components using Union-Find or DFS

Visualization

Tap to expand

Step-by-Step Walkthrough

Compare First Pair

Take first unprocessed string and compare with all others

Extract Characters

Separate even and odd positioned characters

Sort and Compare

Sort both even and odd character arrays and compare

Group Formation

Mark equivalent strings as visited

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 areEquivalent(char* s1, char* s2) {
    int len = strlen(s1);
    if (len != strlen(s2)) return 0;
    
    char even1[100], odd1[100], even2[100], odd2[100];
    int evenIdx1 = 0, oddIdx1 = 0, evenIdx2 = 0, oddIdx2 = 0;
    
    for (int i = 0; i < len; i++) {
        if (i % 2 == 0) {
            even1[evenIdx1++] = s1[i];
            even2[evenIdx2++] = s2[i];
        } else {
            odd1[oddIdx1++] = s1[i];
            odd2[oddIdx2++] = s2[i];
        }
    }
    
    qsort(even1, evenIdx1, sizeof(char), compare);
    qsort(odd1, oddIdx1, sizeof(char), compare);
    qsort(even2, evenIdx2, sizeof(char), compare);
    qsort(odd2, oddIdx2, sizeof(char), compare);
    
    return strncmp(even1, even2, evenIdx1) == 0 && strncmp(odd1, odd2, oddIdx1) == 0;
}

int numSpecialEquivGroups(char** words, int wordsSize) {
    int* visited = (int*)calloc(wordsSize, sizeof(int));
    int groups = 0;
    
    for (int i = 0; i < wordsSize; i++) {
        if (!visited[i]) {
            groups++;
            visited[i] = 1;
            for (int j = i + 1; j < wordsSize; j++) {
                if (!visited[j] && areEquivalent(words[i], words[j])) {
                    visited[j] = 1;
                }
            }
        }
    }
    
    free(visited);
    return groups;
}

int main() {
    char* words[] = {"abcd", "cdab", "cbad", "xyzz", "zzxy", "zzyx"};
    int size = 6;
    printf("%d\n", numSpecialEquivGroups(words, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × m)

n² for comparing all pairs, m for checking if two strings are equivalent

⚠ Quadratic Growth

Space Complexity

O(n)

Space for visited array and recursion stack for grouping

⚡ Linearithmic Space

28.0K Views

Medium Frequency

~12 min Avg. Time

850 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 (Compare All Pairs) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler