Top K Frequent Words

// Accepted solution for LeetCode #692: Top K Frequent Words
class Solution {
    public List<String> topKFrequent(String[] words, int k) {
        Map<String, Integer> cnt = new HashMap<>();
        for (String w : words) {
            cnt.merge(w, 1, Integer::sum);
        }
        Arrays.sort(words, (a, b) -> {
            int c1 = cnt.get(a), c2 = cnt.get(b);
            return c1 == c2 ? a.compareTo(b) : c2 - c1;
        });
        List<String> ans = new ArrayList<>();
        for (int i = 0; i < words.length && ans.size() < k; ++i) {
            if (i == 0 || !words[i].equals(words[i - 1])) {
                ans.add(words[i]);
            }
        }
        return ans;
    }
}

// Accepted solution for LeetCode #692: Top K Frequent Words
func topKFrequent(words []string, k int) (ans []string) {
	cnt := map[string]int{}
	for _, w := range words {
		cnt[w]++
	}
	for w := range cnt {
		ans = append(ans, w)
	}
	sort.Slice(ans, func(i, j int) bool { a, b := ans[i], ans[j]; return cnt[a] > cnt[b] || cnt[a] == cnt[b] && a < b })
	return ans[:k]
}

# Accepted solution for LeetCode #692: Top K Frequent Words
class Solution:
    def topKFrequent(self, words: List[str], k: int) -> List[str]:
        cnt = Counter(words)
        return sorted(cnt, key=lambda x: (-cnt[x], x))[:k]

// Accepted solution for LeetCode #692: Top K Frequent Words
struct Solution;
use std::cmp::Ordering;
use std::collections::HashMap;
struct Pair<'a> {
    word: &'a str,
    freq: usize,
}

impl Solution {
    fn top_k_frequent(words: Vec<String>, k: i32) -> Vec<String> {
        let mut hm: HashMap<&str, usize> = HashMap::new();
        let mut v: Vec<Pair> = vec![];
        for w in words.iter() {
            *hm.entry(w).or_default() += 1;
        }
        for (word, freq) in hm {
            v.push(Pair { word, freq });
        }
        v.sort_unstable_by(|a, b| match b.freq.cmp(&a.freq) {
            Ordering::Equal => a.word.cmp(b.word),
            e => e,
        });
        v.iter()
            .take(k as usize)
            .map(|x| x.word.to_string())
            .collect()
    }
}

#[test]
fn test() {
    let words: Vec<String> = vec_string!["i", "love", "leetcode", "i", "love", "coding"];
    let res: Vec<String> = vec_string!["i", "love"];
    let k = 2;
    assert_eq!(Solution::top_k_frequent(words, k), res);
    let words: Vec<String> =
        vec_string!["the", "day", "is", "sunny", "the", "the", "the", "sunny", "is", "is"];
    let res: Vec<String> = vec_string!["the", "is", "sunny", "day"];
    let k = 4;
    assert_eq!(Solution::top_k_frequent(words, k), res);
}

// Accepted solution for LeetCode #692: Top K Frequent Words
function topKFrequent(words: string[], k: number): string[] {
    const cnt: Map<string, number> = new Map();
    for (const w of words) {
        cnt.set(w, (cnt.get(w) || 0) + 1);
    }
    const ans: string[] = Array.from(cnt.keys());
    ans.sort((a, b) => {
        return cnt.get(a) === cnt.get(b) ? a.localeCompare(b) : cnt.get(b)! - cnt.get(a)!;
    });
    return ans.slice(0, k);
}