Group the words that are anagrams

def group_anagrams(words):
    where = {}                          # key -> position in groups
    groups = []
    for i, w in enumerate(words):
        key = ''.join(sorted(w))        # anagrams share this key
        if key not in where:
            where[key] = len(groups)
            groups.append([])
        groups[where[key]].append(i)
    return groups

#include <algorithm>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;

vector<vector<int>> solve(const vector<string>& words) {
    unordered_map<string, int> where;   // key -> position in groups
    vector<vector<int>> groups;
    for (int i = 0; i < (int)words.size(); i++) {
        string key = words[i];
        sort(key.begin(), key.end());   // anagrams share this key
        auto it = where.find(key);
        if (it == where.end()) {
            where[key] = groups.size();
            groups.push_back({});
            groups.back().push_back(i);
        } else {
            groups[it->second].push_back(i);
        }
    }
    return groups;
}

import java.util.*;

class Solution {
    public int[][] groupAnagrams(String[] words) {
        Map<String, Integer> where = new HashMap<>();   // key -> position in groups
        List<List<Integer>> groups = new ArrayList<>();
        for (int i = 0; i < words.length; i++) {
            char[] c = words[i].toCharArray();
            Arrays.sort(c);                             // anagrams share this key
            String key = new String(c);
            Integer g = where.get(key);
            if (g == null) {
                g = groups.size();
                where.put(key, g);
                groups.add(new ArrayList<>());
            }
            groups.get(g).add(i);
        }
        int[][] r = new int[groups.size()][];
        for (int k = 0; k < r.length; k++)
            r[k] = groups.get(k).stream().mapToInt(Integer::intValue).toArray();
        return r;
    }
}

function groupAnagrams(words) {
  const where = new Map();              // key -> position in groups
  const groups = [];
  words.forEach((w, i) => {
    const key = [...w].sort().join(''); // anagrams share this key
    if (!where.has(key)) { where.set(key, groups.length); groups.push([]); }
    groups[where.get(key)].push(i);
  });
  return groups;
}

use std::collections::HashMap;

fn solve(words: &[&str]) -> Vec<Vec<i64>> {
    let mut where_: HashMap<Vec<u8>, usize> = HashMap::new(); // key -> position in groups
    let mut groups: Vec<Vec<i64>> = Vec::new();
    for (i, w) in words.iter().enumerate() {
        let mut key = w.as_bytes().to_vec();
        key.sort(); // anagrams share this key
        let g = *where_.entry(key).or_insert_with(|| {
            groups.push(Vec::new());
            groups.len() - 1
        });
        groups[g].push(i as i64);
    }
    groups
}

import Data.List (sort, sortOn)
import qualified Data.Map.Strict as M

-- Key each word by its sorted letters; each group keeps its indices in order, and the groups
-- are put in order of their first index at the end.
solve :: [String] -> [[Int]]
solve ws = map snd (sortOn fst [(head is, is) | is <- M.elems groups])
  where
    groups = M.fromListWith (flip (++)) [(sort w, [i]) | (i, w) <- zip [0 ..] ws]