Count Anagrams

Count Anagrams - Problem

You are given a string s containing one or more words. Every consecutive pair of words is separated by a single space ' '.

A string t is an anagram of string s if the i-th word of t is a permutation of the i-th word of s.

For example, "acb dfe" is an anagram of "abc def", but "def cab" and "adc bef" are not.

Return the number of distinct anagrams of s. Since the answer may be very large, return it modulo 10^9 + 7.

Input & Output

Example 1 — Basic Case

$ Input: s = "ab"

› Output: 2

💡 Note: The word "ab" can be rearranged as "ab" and "ba", giving us 2 distinct anagrams.

Example 2 — Two Words

$ Input: s = "ab cd"

› Output: 4

💡 Note: Word "ab" has 2 permutations: "ab", "ba". Word "cd" has 2 permutations: "cd", "dc". Total anagrams = 2 × 2 = 4.

Example 3 — Repeated Characters

$ Input: s = "aab"

› Output: 3

💡 Note: The word "aab" can be arranged as "aab", "aba", "baa". Using formula: 3! / 2! = 6 / 2 = 3.

Constraints

1 ≤ s.length ≤ 1000
s contains only lowercase English letters and spaces
s does not have leading or trailing spaces
Every consecutive pair of words is separated by a single space

Visualization

Tap to expand

Asked in

G Google 12 f Facebook 8

The key insight is to use the mathematical formula for permutations with repetitions: n! / (freq1! × freq2! × ... × freqk!) for each word, then multiply the results. The optimal approach uses frequency counting and factorial calculations with modular arithmetic. Time: O(n × k), Space: O(1)

Common Approaches

✓ Generate All Permutations

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

For each word, generate all possible permutations of its characters, count unique permutations, then multiply the counts together. This approach is straightforward but extremely inefficient for longer words.

Mathematical Formula (Optimal)

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

For each word, count character frequencies and apply the formula: n! / (freq1! × freq2! × ... × freqk!) where n is word length and freqi is frequency of character i. This avoids generating actual permutations.

Generate All Permutations — Algorithm Steps

Split string into words
For each word, generate all permutations
Count unique permutations per word
Multiply all counts together

Visualization

Tap to expand

Step-by-Step Walkthrough

Split Words

Separate the input string into individual words

Generate Permutations

Create all possible arrangements of letters for each word

Multiply Counts

Multiply the count of unique permutations from each word

Code -

solution.c — C

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

long long factorial(int n) {
    if (n <= 1) return 1;
    long long result = 1;
    for (int i = 2; i <= n; i++) {
        result *= i;
    }
    return result;
}

int solution(char* s) {
    const int MOD = 1000000007;
    
    long long result = 1;
    
    // Split string into words using strtok
    char* word = strtok(s, " ");
    
    while (word != NULL) {
        // Count frequency of each character in the word
        int freq[26] = {0}; // For lowercase letters a-z
        int n = strlen(word);
        
        for (int i = 0; i < n; i++) {
            freq[word[i] - 'a']++;
        }
        
        // Calculate number of permutations: n! / (n1! * n2! * ... * nk!)
        long long numerator = factorial(n);
        long long denominator = 1;
        
        for (int i = 0; i < 26; i++) {
            if (freq[i] > 0) {
                denominator *= factorial(freq[i]);
            }
        }
        
        long long wordAnagrams = numerator / denominator;
        result = (result * wordAnagrams) % MOD;
        
        word = strtok(NULL, " ");
    }
    
    return (int)result;
}

int main() {
    static char s[1001];
    fgets(s, sizeof(s), stdin);
    
    // Remove newline if present
    int len = strlen(s);
    if (len > 0 && s[len-1] == '\n') {
        s[len-1] = '\0';
    }
    
    int result = solution(s);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × k)

Generating n! permutations for each word, k words total

✓ Linear Growth

Space Complexity

O(n! × k)

Storing all permutations in memory

✓ Linear Space

12.5K Views

Medium Frequency

~25 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

Generate All Permutations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler