Minimum Length of Anagram Concatenation solution and explanation

from math import gcd
from collections import Counter

def min_length_of_t(s):
    freq = Counter(s)
    values = freq.values()
    result = 0
    for value in values:
        result = gcd(result, value)
    return result

# Testing the function
s = "abba"
print(min_length_of_t(s))  # Output: 2

import java.util.HashMap;

public class AnagramConcatenation {

    public static int gcd(int a, int b) {
        if (b == 0) return a;
        return gcd(b, a % b);
    }

    public static int minLengthOfT(String s) {
        HashMap<Character, Integer> freq = new HashMap<>();
        for (char c : s.toCharArray()) {
            freq.put(c, freq.getOrDefault(c, 0) + 1);
        }
        int result = 0;
        for (int value : freq.values()) {
            result = gcd(result, value);
        }
        return result;
    }

    public static void main(String[] args) {
        String s = "abba";
        System.out.println(minLengthOfT(s));  // Output: 2
    }
}

#include <iostream>
#include <unordered_map>
#include <numeric>
using namespace std;

int gcd(int a, int b) {
    return b == 0 ? a : gcd(b, a % b);
}

int minLengthOfT(const string& s) {
    unordered_map<char, int> freq;
    for (const char& c : s) {
        freq[c]++;
    }
    int result = 0;
    for (const auto& pair : freq) {
        result = gcd(result, pair.second);
    }
    return result;
}

// Testing the function
int main() {
    string s = "abba";
    cout << minLengthOfT(s) << endl;  // Output: 2
    return 0;
}

function gcd(a, b) {
  if (b == 0) return a;
  return gcd(b, a % b);
}

function minLengthOfT(s) {
  const freq = {};
  for (const char of s) {
    freq[char] = (freq[char] || 0) + 1;
  }
  let result = 0;
  for (const value of Object.values(freq)) {
    result = gcd(result, value);
  }
  return result;
}

// Testing the function
const s = "abba";
console.log(minLengthOfT(s));  // Output: 2

using System;
using System.Collections.Generic;

class AnagramConcatenation {

    static int GCD(int a, int b) {
        if (b == 0) return a;
        return GCD(b, a % b);
    }

    static int MinLengthOfT(string s) {
        Dictionary<char, int> freq = new Dictionary<char, int>();
        foreach (char c in s) {
            if (freq.ContainsKey(c)) {
                freq[c]++;
            } else {
                freq[c] = 1;
            }
        }
        int result = 0;
        foreach (int value in freq.Values) {
            result = GCD(result, value);
        }
        return result;
    }

    static void Main() {
        string s = "abba";
        Console.WriteLine(MinLengthOfT(s));  // Output: 2
    }
}

from collections import Counter

# Helper function to compute gcd using Euclidean algorithm
from math import gcd

def min_length_of_t_modular(s):
    freq = Counter(s)
    total_length = len(s)
    max_gcd = 1
    for k in range(1, total_length + 1):
        if total_length % k == 0:
            gcd_check = all(v % k == 0 for v in freq.values())
            if gcd_check:
                max_gcd = k
    return max_gcd

# Testing the function
s = "abba"
print(min_length_of_t_modular(s))  # Output: 2

function minLengthOfTModular(s) {
  const freq = {};
  const n = s.length;
  let maxGCD = 1;

  // Count characters frequency
  for (const char of s) {
    freq[char] = (freq[char] || 0) + 1;
  }
  
  for (let k = 1; k <= n; k++) {
    if (n % k === 0) {
      const gcdCheck = Object.values(freq).every(v => v % k === 0);
      if (gcdCheck) {
        maxGCD = k;
      }
    }
  }

  return maxGCD;
}

// Testing the function
const s = "abba";
console.log(minLengthOfTModular(s));  // Output: 2

function minAnagramLength(s: string): number {
    const n = s.length;
    const cnt: Record<string, number> = {};
    for (let i = 0; i < n; i++) {
        cnt[s[i]] = (cnt[s[i]] || 0) + 1;
    }
    const check = (k: number): boolean => {
        for (let i = 0; i < n; i += k) {
            const cnt1: Record<string, number> = {};
            for (let j = i; j < i + k; j++) {
                cnt1[s[j]] = (cnt1[s[j]] || 0) + 1;
            }
            for (const [c, v] of Object.entries(cnt)) {
                if (cnt1[c] * ((n / k) | 0) !== v) {
                    return false;
                }
            }
        }
        return true;
    };
    for (let i = 1; ; ++i) {
        if (n % i === 0 && check(i)) {
            return i;
        }
    }
}

func minAnagramLength(s string) int {
	n := len(s)
	cnt := [26]int{}
	for _, c := range s {
		cnt[c-'a']++
	}
	check := func(k int) bool {
		for i := 0; i < n; i += k {
			cnt1 := [26]int{}
			for j := i; j < i+k; j++ {
				cnt1[s[j]-'a']++
			}
			for j, v := range cnt {
				if cnt1[j]*(n/k) != v {
					return false
				}
			}
		}
		return true
	}
	for i := 1; ; i++ {
		if n%i == 0 && check(i) {
			return i
		}
	}
}