Frequency-Matched Strings - Problem

Given two strings, determine if they have identical character frequency distributions. This means both strings must have the same pattern of character occurrences, but not necessarily the same characters.

For example, "abc" and "def" both have frequency pattern [1,1,1] (each character appears once), so they match. Similarly, "aab" and "xxy" both have pattern [2,1] (one character appears twice, one appears once).

The strings are considered frequency-matched if their character frequency histograms have the same shape when sorted.

Input & Output

Example 1 — Same Pattern Different Characters

$ Input: str1 = "aab", str2 = "xxy"

› Output: true

💡 Note: Both strings have frequency pattern [1,2] when sorted: str1 has 'a' appearing 2 times and 'b' appearing 1 time, str2 has 'x' appearing 2 times and 'y' appearing 1 time.

Example 2 — Different Patterns

$ Input: str1 = "abc", str2 = "def"

› Output: true

💡 Note: Both strings have frequency pattern [1,1,1]: each character appears exactly once in both strings, so they have identical frequency distributions.

Example 3 — Unmatched Patterns

$ Input: str1 = "aab", str2 = "abc"

› Output: false

💡 Note: str1 has pattern [1,2] (one char appears 2 times, one appears 1 time) while str2 has pattern [1,1,1] (all chars appear 1 time each). Different patterns.

Constraints

1 ≤ str1.length, str2.length ≤ 1000
str1 and str2 consist of lowercase English letters only

Visualization

Tap to expand

Asked in

G Google 35 a Amazon 28 M Microsoft 22 f Facebook 18

The key insight is that two strings have identical frequency distributions if their sorted frequency patterns match, regardless of which specific characters appear. Best approach uses frequency counting with pattern comparison: build frequency maps, extract frequency values, sort them, and compare. Time: O(n + k log k), Space: O(k) where k ≤ 26.

Common Approaches

✓ Brute Force Character Counting

⏱️ Time: O(n + m + k log k) Space: O(k)

Build frequency maps for both strings by counting each character, then compare the maps by checking if they contain the same frequency values (ignoring which characters have those frequencies).

Optimized Frequency Counting

⏱️ Time: O(n + k log k) Space: O(k)

Build frequency maps for both strings in a single pass, then compare the frequency patterns directly by sorting the frequency values and checking for equality.

Brute Force Character Counting — Algorithm Steps

Count frequency of each character in first string
Count frequency of each character in second string
Extract frequency values from both maps
Sort both frequency lists and compare element by element

Visualization

Tap to expand

Step-by-Step Walkthrough

Count str1

Build frequency map for first string

Count str2

Build frequency map for second string

Compare

Sort frequency values and compare

Code -

solution.c — C

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

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

int solution(char* str1, char* str2) {
    int len1 = strlen(str1);
    int len2 = strlen(str2);
    
    if (len1 != len2) {
        return 0;
    }
    
    // Count frequencies using arrays (assuming ASCII)
    int freq1[256] = {0};
    int freq2[256] = {0};
    
    for (int i = 0; i < len1; i++) {
        freq1[(unsigned char)str1[i]]++;
    }
    
    for (int i = 0; i < len2; i++) {
        freq2[(unsigned char)str2[i]]++;
    }
    
    // Extract non-zero frequency values
    int values1[256], values2[256];
    int count1 = 0, count2 = 0;
    
    for (int i = 0; i < 256; i++) {
        if (freq1[i] > 0) {
            values1[count1++] = freq1[i];
        }
        if (freq2[i] > 0) {
            values2[count2++] = freq2[i];
        }
    }
    
    if (count1 != count2) {
        return 0;
    }
    
    // Sort and compare
    qsort(values1, count1, sizeof(int), compare);
    qsort(values2, count2, sizeof(int), compare);
    
    for (int i = 0; i < count1; i++) {
        if (values1[i] != values2[i]) {
            return 0;
        }
    }
    
    return 1;
}

int main() {
    char str1[1001], str2[1001];
    
    fgets(str1, sizeof(str1), stdin);
    str1[strcspn(str1, "\n")] = 0;
    
    fgets(str2, sizeof(str2), stdin);
    str2[strcspn(str2, "\n")] = 0;
    
    int result = solution(str1, str2);
    printf(result ? "true\n" : "false\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + m + k log k)

O(n) to count str1, O(m) to count str2, O(k log k) to sort frequencies where k ≤ 26

⚡ Linearithmic

Space Complexity

O(k)

Two frequency maps storing at most 26 characters each

✓ Linear Space

73.9K Views

Medium Frequency

~15 min Avg. Time

1.8K 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

Frequency-Matched Strings - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Character Counting — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler