The k most frequent values

from collections import Counter

def top_k_frequent(nums, k):
    count = Counter(nums)                                  # value -> frequency
    order = sorted(count, key=lambda x: (-count[x], x))    # most frequent first, then smaller
    return order[:k]

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

vector<int> solve(vector<int> nums, int k) {
    unordered_map<int, int> count;                         // value -> frequency
    for (int x : nums) count[x]++;
    vector<pair<int, int>> v(count.begin(), count.end());
    sort(v.begin(), v.end(), [](const pair<int, int>& a, const pair<int, int>& b) {
        return a.second != b.second ? a.second > b.second : a.first < b.first;
    });
    vector<int> out;
    for (int i = 0; i < k; i++) out.push_back(v[i].first);
    return out;
}

import java.util.*;

class Solution {
    public int[] topKFrequent(int[] nums, int k) {
        Map<Integer, Integer> count = new HashMap<>();     // value -> frequency
        for (int x : nums) count.merge(x, 1, Integer::sum);
        List<Integer> vals = new ArrayList<>(count.keySet());
        vals.sort((a, b) -> {
            int ca = count.get(a), cb = count.get(b);
            return ca != cb ? cb - ca : Integer.compare(a, b);
        });
        int[] out = new int[k];
        for (int i = 0; i < k; i++) out[i] = vals.get(i);
        return out;
    }
}

function topKFrequent(nums, k) {
  const count = new Map();                               // value -> frequency
  for (const x of nums) count.set(x, (count.get(x) || 0) + 1);
  return [...count.keys()]
    .sort((a, b) => count.get(b) - count.get(a) || a - b) // most frequent first, then smaller
    .slice(0, k);
}

use std::collections::HashMap;

fn solve(nums: &[i32], k: usize) -> Vec<i32> {
    let mut count: HashMap<i32, usize> = HashMap::new();   // value -> frequency
    for &x in nums {
        *count.entry(x).or_insert(0) += 1;
    }
    let mut v: Vec<(i32, usize)> = count.into_iter().collect();
    v.sort_by(|a, b| b.1.cmp(&a.1).then(a.0.cmp(&b.0)));  // most frequent first, then smaller
    v.into_iter().take(k).map(|(x, _)| x).collect()
}

import qualified Data.Map.Strict as M
import Data.List (sortBy)
import Data.Ord (comparing, Down (..))

solve :: [Int] -> Int -> [Int]
solve xs k = take k (map fst (sortBy (comparing (\(x, c) -> (Down c, x))) (M.toList counts)))
  where
    counts = M.fromListWith (+) [(x, 1 :: Int) | x <- xs]   -- value -> frequency