Minimum Length of Anagram Concatenation - Practice Coding Problems

Minimum Length of Anagram Concatenation - Problem

You are given a string s that represents a concatenation of multiple anagrams of some unknown string t. Your task is to find the minimum possible length of the original string t.

An anagram is formed by rearranging the letters of a string. For example, "aab", "aba", and "baa" are all anagrams of "aab".

Key insight: Since s is formed by concatenating anagrams of t, the length of t must be a divisor of the length of s. We need to find the smallest such divisor where each segment of that length in s contains the same character frequencies.

Example: If s = "abcabc", it could be two anagrams of t = "abc", so the answer is 3.

Input & Output

example_1.py — Basic case

$ Input: s = "abcabc"

› Output: 3

💡 Note: The string can be split into two anagrams of "abc": "abc" and "abc". Both segments have the same character frequencies (a:1, b:1, c:1), so the minimum length is 3.

example_2.py — Multiple valid lengths

$ Input: s = "abcabcabcabc"

› Output: 3

💡 Note: The string has length 12. Possible divisors are 1, 2, 3, 4, 6, 12. Length 3 works (four segments: "abc", "abc", "abc", "abc"), so we return 3 as the minimum.

example_3.py — Single character

$ Input: s = "aaaa"

› Output: 1

💡 Note: The string consists of the same character repeated. Each segment of length 1 contains the same character frequencies, so the minimum length is 1.

Constraints

1 ≤ s.length ≤ 10⁵
s consists of lowercase English letters only
The string s is guaranteed to be a concatenation of anagrams of some string t

Visualization

Tap to expand

Understanding the Visualization

Identify Constraints

The pattern length must divide the total length evenly

Generate Candidates

Find all divisors of the string length efficiently

Validate Patterns

Check if all segments have identical character frequencies

Return Minimum

The first valid divisor is our answer

Key Takeaway

🎯 Key Insight: The minimum anagram length must be a divisor of the total string length, and all segments of that length must contain identical character frequency distributions.

Asked in

G Google 42 a Amazon 38 f Meta 29 ⊞ Microsoft 24

The key insight is that the length of the original string t must be a divisor of the total string length. The optimal approach generates all divisors efficiently using the √n method, then validates each divisor by comparing character frequencies of segments. Time complexity is O(n√n) where we check √n divisors, each requiring O(n) validation time.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Divisors)	O(n² * d)	O(n)	Check every possible divisor from 1 to n and validate if segments have same character frequencies
Optimized Hash Table (Optimal)	O(n * √n)	O(n)	Generate divisors efficiently and validate using character frequency comparison

Brute Force (Check All Divisors) — Algorithm Steps

Iterate through all possible lengths from 1 to len(s)
For each length that divides len(s) evenly, split string into segments
Count character frequencies in the first segment
Compare all other segments with the first segment's frequency
Return the first valid length found

Visualization

Tap to expand

Step-by-Step Walkthrough

Try length = 1

Check if entire string is one character repeated

Try length = 2

Split into pairs and compare character frequencies

Continue until valid

Keep testing divisors until we find matching segments

Code -

solution.c — C

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

bool compareFreq(int freq1[26], int freq2[26]) {
    for (int i = 0; i < 26; i++) {
        if (freq1[i] != freq2[i]) return false;
    }
    return true;
}

int minimumLength(char* s) {
    int n = strlen(s);
    
    // Try each possible divisor
    for (int length = 1; length <= n; length++) {
        if (n % length != 0) continue;
        
        // Check if all segments of this length are anagrams
        int segments = n / length;
        int firstCount[26] = {0};
        
        // Count characters in first segment
        for (int i = 0; i < length; i++) {
            firstCount[s[i] - 'a']++;
        }
        
        // Check all other segments
        bool valid = true;
        for (int seg = 1; seg < segments; seg++) {
            int segCount[26] = {0};
            int start = seg * length;
            
            // Count characters in current segment
            for (int i = start; i < start + length; i++) {
                segCount[s[i] - 'a']++;
            }
            
            // Compare with first segment
            if (!compareFreq(firstCount, segCount)) {
                valid = false;
                break;
            }
        }
        
        if (valid) return length;
    }
    
    return n;
}

int main() {
    char s[100001];
    scanf("%s", s);
    
    // Remove quotes if present
    int len = strlen(s);
    if (s[0] == '"') {
        memmove(s, s + 1, len - 1);
        s[len - 2] = '\0';
    }
    
    printf("%d\n", minimumLength(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² * d)

For each divisor d, we check n/d segments, each taking O(n/d) time to count characters. With O(n) divisors, total is O(n² * d)

⚠ Quadratic Growth

Space Complexity

O(n)

Space for character frequency counting in each segment

⚡ Linearithmic Space

48.6K Views

Medium Frequency

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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Check All Divisors) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler