Группировка анаграмм

public class Solution
{
    public static List<List<string>> GroupAnagrams(List<string> strs)
    {
        if (strs.Count == 0)
        {
            return new List<List<string>>();
        }

        Dictionary<string, List<string>> anagramGroups = new Dictionary<string, List<string>>();
        int[] count = new int[26]; // Массив для подсчёта букв

        foreach (string s in strs)
        {
            // Сбрасываем массив подсчёта символов
            Array.Clear(count, 0, 26);

            // Подсчитываем количество каждой буквы в строке
            foreach (char c in s)
            {
                count[c - 'a']++;
            }

            // Генерируем ключ для данной группы анаграмм
            string key = "";
            for (int i = 0; i < 26; i++)
            {
                key += "#" + count[i].ToString();
            }

            // Если ключа ещё нет в словаре, создаём новую группу
            if (!anagramGroups.ContainsKey(key))
            {
                anagramGroups[key] = new List<string>();
            }

            // Добавляем строку в соответствующую группу
            anagramGroups[key].Add(s);
        }

        // Формируем результат из значений словаря
        return new List<List<string>>(anagramGroups.Values);
    }
}

#include <vector>
#include <string>
#include <unordered_map>

using namespace std;

vector<vector<string>> groupAnagrams(vector<string>& strs) {
    if (strs.empty()) {
        return vector<vector<string>>();
    }

    unordered_map<string, vector<string>> anagramGroups;
    int count[26]; // Массив для подсчёта букв

    for (const string& s : strs) {
        // Сбрасываем массив подсчёта символов
        fill(begin(count), end(count), 0);

        // Подсчитываем количество каждой буквы в строке
        for (char c : s) {
            count[c - 'a']++;
        }

        // Генерируем ключ для данной группы анаграмм
        string key = "";
        for (int i = 0; i < 26; i++) {
            key += "#";
            key += to_string(count[i]);
        }

        // Если ключа ещё нет в map, создаём новую группу
        if (anagramGroups.find(key) == anagramGroups.end()) {
            anagramGroups[key] = vector<string>();
        }

        // Добавляем строку в соответствующую группу
        anagramGroups[key].push_back(s);
    }

    // Формируем результат из значений map
    vector<vector<string>> result;
    for (auto itr = anagramGroups.begin(); itr != anagramGroups.end(); ++itr) {
        result.push_back(move(itr->second));
    }

    return result;
}

package main;

func groupAnagrams(strs []string) [][]string {
    anagramGroups := make(map[[26]int][]string)

    for _, anagram := range strs {
        // индекс - соответствует букве (0 - 'a', 1 - 'b', ...)
        // значение - сколько раз встретили букву
        countChars := [26]int{}
        for _, ch := range anagram {
            countChars[ch-'a']++
        }

        // добавляем анаграмму в группу
        anagramGroups[countChars] = append(anagramGroups[countChars], anagram)
    }

    result := make([][]string, 0, len(anagramGroups))
    for _, group := range anagramGroups {
        result = append(result, group)
    }

    return result
}

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Solution {
    public List<List<String>> groupAnagrams(List<String> strs) {
        Map<String, List<String>> anagramGroups = new HashMap<>();

        for (String anagram : strs) {
            // индекс - соответствует букве (0 - 'a', 1 - 'b', ...)
            //  значение - сколько раз встретили букву
            int[] countChars = new int[26];
            for (char ch : anagram.toCharArray()) {
                countChars[ch - 'a']++;
            }

            StringBuilder key = new StringBuilder();
            for (int count : countChars) {
                key.append('#').append(count);
            }

            // добавляем анаграмму группу
            String keyStr = key.toString();
            anagramGroups.computeIfAbsent(keyStr, k -> new ArrayList<>()).add(anagram);
        }

        return new ArrayList<>(anagramGroups.values());
    }
}

from typing import *
from collections import defaultdict

def group_anagrams(strs: List[str]) -> List[List[str]]:
    anagram_groups = defaultdict(list)
    for aragram in strs:
        # индекс - соответствует букве (0 - 'a', 1 - 'b', ...)
        #  значение - сколько раз встретили букву
        count_chars = [0 for j in range(26)]
        for ch in aragram:
            count_chars[ord(ch) - ord('a')] += 1

        # добавляем анаграмму группу
        anagram_groups[tuple(count_chars)].append(aragram)
    
    return list(anagram_groups.values())

export function groupAnagrams(strs) {
    const anagramGroups = new Map();

    for (const word of strs) {
        // индекс - соответствует букве (0 - 'a', 1 - 'b', ...)
        //  значение - сколько раз встретили букву
        const countChars = Array(26).fill(0);
        for (const ch of word) {
            countChars[ch.charCodeAt(0) - 'a'.charCodeAt(0)]++;
        }

        const key = countChars.join(',');

        // добавляем анаграмму группу
        if (!anagramGroups.has(key)) {
            anagramGroups.set(key, []);
        }
        anagramGroups.get(key).push(word);
    }

    return Array.from(anagramGroups.values());
}