Count Pairs Of Similar Strings

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.

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.

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.

Input & Output

Example 1 — Basic Case

$ Input: words = ["aba","aab","abc","cba"]

› Output: 2

💡 Note: Pairs (0,1) and (2,3) are similar: "aba" and "aab" both have characters {a,b}, while "abc" and "cba" both have characters {a,b,c}

Example 2 — All Different

$ Input: words = ["aab","ab","aa"]

› Output: 1

💡 Note: Only pair (0,1) is similar: "aab" and "ab" both have characters {a,b}, while "aa" only has character {a}

Example 3 — All Same

$ Input: words = ["abc","bac","cab"]

› Output: 3

💡 Note: All strings have the same character set {a,b,c}, so all 3 pairs (0,1), (0,2), and (1,2) are similar

Constraints

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

Visualization

Tap to expand

Asked in

a Amazon 15 M Microsoft 12 G Google 8

The key insight is that two strings are similar if they contain the exact same set of unique characters, regardless of frequency or order. The most efficient approach uses bit manipulation to represent character sets as integers, enabling O(1) comparisons and efficient grouping. Time: O(n × m), Space: O(n).

Common Approaches

✓ Bit Mask Optimization

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

Represent each string's character set as a 26-bit integer where bit i indicates presence of character 'a'+i. This allows O(1) comparison and efficient grouping using hash maps.

Brute Force Comparison

⏱️ Time: O(n² × m) Space: O(m)

For every pair of strings, convert each to a set of unique characters and check if the sets are equal. This directly implements the definition of similarity.

Character Signature Grouping

⏱️ Time: O(n × m) Space: O(n × k)

Convert each string to a canonical signature representing its unique characters, then group strings with identical signatures. The number of pairs in a group of size n is n*(n-1)/2.

Bit Mask Optimization — Algorithm Steps

Convert each string to a bit mask representing its character set
Group strings by identical bit masks using hash map
Count pairs within each group using combinatorial formula

Visualization

Tap to expand

Step-by-Step Walkthrough

Create Bit Masks

Convert each string to binary representation of character set

Group by Mask

Group strings with identical bit patterns

Count Combinations

Calculate pairs using combinatorial math

Code -

solution.c — C

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

typedef struct {
    int mask;
    int count;
} Group;

int solution(char words[][101], int n) {
    Group groups[1000];
    int groupCount = 0;
    
    for (int i = 0; i < n; i++) {
        int mask = 0;
        for (int j = 0; words[i][j]; j++) {
            mask |= (1 << (words[i][j] - 'a'));
        }
        
        int found = -1;
        for (int j = 0; j < groupCount; j++) {
            if (groups[j].mask == mask) {
                found = j;
                break;
            }
        }
        
        if (found >= 0) {
            groups[found].count++;
        } else {
            groups[groupCount].mask = mask;
            groups[groupCount].count = 1;
            groupCount++;
        }
    }
    
    int count = 0;
    for (int i = 0; i < groupCount; i++) {
        int groupSize = groups[i].count;
        count += groupSize * (groupSize - 1) / 2;
    }
    
    return count;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    char words[1000][101];
    int n = 0;
    
    char* ptr = line;
    
    while (*ptr) {
        // Find opening quote
        while (*ptr && *ptr != '"') ptr++;
        if (!*ptr) break;
        ptr++; // skip opening quote
        
        // Copy characters until closing quote
        int k = 0;
        while (*ptr && *ptr != '"' && k < 100) {
            words[n][k++] = *ptr++;
        }
        words[n][k] = '\0';
        n++;
        
        if (*ptr == '"') ptr++; // skip closing quote
    }
    
    int result = solution(words, n);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

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

✓ Linear Growth

Space Complexity

O(n)

Hash map stores at most n different bit masks (integers)

⚡ Linearithmic Space

25.0K Views

Medium Frequency

~15 min Avg. Time

450 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

Bit Mask Optimization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler