Count Pairs Of Similar Strings - Practice Coding Problems

Count Pairs Of Similar Strings - Problem

You are given a 0-indexed string array words.

Two strings are similar if they consist of the same characters (regardless of frequency or order).

For example, "abca" and "cba" are similar since both consist of characters 'a', 'b', and 'c'.
However, "abacba" and "bcfd" are not similar since they do not consist of the same characters.

Goal: Return the number of pairs (i, j) such that 0 <= i < j < words.length and the two strings words[i] and words[j] are similar.

Think of this as finding strings that have the same "character signature" - the unique set of characters they contain!

Input & Output

example_1.py — Basic Case

$ Input: ["aba", "aabb", "abcd", "bac", "aabc"]

› Output: 2

💡 Note: The pairs of similar strings are: ("aba", "aabb") - both have characters {a,b}, and ("abcd", "aabc") - both have characters {a,b,c,d}. Note that "aba" and "bac" are also similar (both have {a,b,c}), wait let me recalculate... Actually: "aba"→{a,b}, "aabb"→{a,b}, "abcd"→{a,b,c,d}, "bac"→{a,b,c}, "aabc"→{a,b,c}. So pairs are: (0,1) both {a,b}, and (3,4) both {a,b,c}.

example_2.py — All Different

$ Input: ["aaa", "bb", "ccc"]

› Output: 0

💡 Note: No two strings are similar. "aaa" has {a}, "bb" has {b}, and "ccc" has {c}. All have different character sets, so no pairs are formed.

example_3.py — All Same Signature

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

› Output: 6

💡 Note: All four strings have the same character set {a,b,c}, so they're all similar to each other. With 4 strings, we get C(4,2) = 4×3/2 = 6 pairs: (0,1), (0,2), (0,3), (1,2), (1,3), (2,3).

Visualization

Tap to expand

Understanding the Visualization

Extract Signatures

Convert each string to a unique signature representing its character set

Group by Signature

Collect all strings that have the same signature

Count Pairs per Group

For each group with n strings, calculate n×(n-1)/2 pairs

Sum All Groups

Add up pairs from all signature groups to get final answer

Key Takeaway

🎯 Key Insight: Convert the comparison problem into a counting problem by grouping strings with identical character signatures, then use the combination formula to count pairs efficiently.

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

n strings, each taking O(m) time to create signature where m is string length

✓ Linear Growth

Space Complexity

O(n)

Hash map storing signatures for up to n unique character sets

⚡ Linearithmic Space

Constraints

1 ≤ words.length ≤ 100
1 ≤ words[i].length ≤ 100
words[i] consists of only lowercase English letters

Asked in

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

The optimal solution uses a hash map with character signatures. Create a unique signature for each string (like sorted unique characters), count strings per signature, then apply the combination formula n×(n-1)/2 for each group. Time: O(n×m), Space: O(n).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n² × m)	O(m)	Compare every pair of strings by checking if they have the same character set
One-Pass Hash Table (Optimal)	O(n × m)	O(n)	Create unique signatures for strings and count matches using a hash map

Brute Force (Nested Loops) — Algorithm Steps

Use nested loops to generate all pairs (i, j) where i < j
For each pair, convert both strings to character sets
Check if the two sets are equal
If equal, increment the result counter

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Pairs

Use nested loops to create all pairs (i,j) where i < j

Convert to Sets

Convert both strings in each pair to character sets

Compare Sets

Check if the two character sets are identical

Count Matches

Increment counter when sets match

Code -

solution.c — C

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

bool haveSameChars(char* word1, char* word2) {
    bool chars1[26] = {false};
    bool chars2[26] = {false};
    
    // Mark characters in first word
    for (int i = 0; word1[i]; i++) {
        chars1[word1[i] - 'a'] = true;
    }
    
    // Mark characters in second word
    for (int i = 0; word2[i]; i++) {
        chars2[word2[i] - 'a'] = true;
    }
    
    // Compare character sets
    for (int i = 0; i < 26; i++) {
        if (chars1[i] != chars2[i]) {
            return false;
        }
    }
    
    return true;
}

int similarPairs(char** words, int wordsSize) {
    int count = 0;
    
    for (int i = 0; i < wordsSize; i++) {
        for (int j = i + 1; j < wordsSize; j++) {
            if (haveSameChars(words[i], words[j])) {
                count++;
            }
        }
    }
    
    return count;
}

int main() {
    char** words = malloc(100 * sizeof(char*));
    int wordCount = 0;
    char buffer[1000];
    
    fgets(buffer, sizeof(buffer), stdin);
    
    // Simple parsing for demo
    char* token = strtok(buffer, ",");
    while (token != NULL && wordCount < 100) {
        words[wordCount] = malloc(100);
        sscanf(token, "\"%[^\"]\"", words[wordCount]);
        wordCount++;
        token = strtok(NULL, ",");
    }
    
    printf("%d\n", similarPairs(words, wordCount));
    
    for (int i = 0; i < wordCount; i++) {
        free(words[i]);
    }
    free(words);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × m)

n² for all pairs, m for converting each string to a set

⚠ Quadratic Growth

Space Complexity

O(m)

Space for temporary character sets, where m is average string length

✓ Linear Space

Constraints

1 ≤ words.length ≤ 100
1 ≤ words[i].length ≤ 100
words[i] consists of only lowercase English letters

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler