Group and count

Counter(events) does the whole first half in one call. The ranking is the only code left to write: sorted with a key that returns (-count, key) so one comparison does both the descending count and the ascending tie-break.

"""Group and count: tally how often each key appears, then rank the tallies."""
from collections import Counter

EVENTS = [
    "home", "docs", "home", "blog", "pricing", "docs", "home", "blog",
    "docs", "home", "pricing", "docs", "blog", "pricing", "home", "docs",
]


def ranked_counts(events: list[str]) -> list[tuple[str, int]]:
    """Highest count first; equal counts broken by key, ascending."""
    counts = Counter(events)
    return sorted(counts.items(), key=lambda kv: (-kv[1], kv[0]))


def main() -> None:
    for key, count in ranked_counts(EVENTS):
        print(f"{key}: {count}")


if __name__ == "__main__":
    main()

A Map preserves insertion order but has no tally helper, so counts.get(key) || 0 plus one is the increment. The sort comparator chains the two criteria with ||: the count difference first, the string comparison only when that is zero.

"use strict";
/* Group and count: tally how often each key appears, then rank the tallies. */

const EVENTS = [
  "home", "docs", "home", "blog", "pricing", "docs", "home", "blog",
  "docs", "home", "pricing", "docs", "blog", "pricing", "home", "docs",
];

function rankedCounts(events) {
  const counts = new Map();
  for (const key of events) {
    counts.set(key, (counts.get(key) || 0) + 1);
  }
  // Highest count first; equal counts broken by key, ascending.
  return [...counts.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]));
}

function main() {
  for (const [key, count] of rankedCounts(EVENTS)) {
    console.log(`${key}: ${count}`);
  }
}

main();

Identical to JavaScript with Map<string, number> naming what is already there. ?? instead of || because a key could in principle map to 0, which || would treat as falsy -- the type checker does not force this, habit and strictness do.

/* Group and count: tally how often each key appears, then rank the tallies. */

const EVENTS: string[] = [
  "home", "docs", "home", "blog", "pricing", "docs", "home", "blog",
  "docs", "home", "pricing", "docs", "blog", "pricing", "home", "docs",
];

function rankedCounts(events: string[]): [string, number][] {
  const counts = new Map<string, number>();
  for (const key of events) {
    counts.set(key, (counts.get(key) ?? 0) + 1);
  }
  // Highest count first; equal counts broken by key, ascending.
  return [...counts.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]));
}

function main(): void {
  for (const [key, count] of rankedCounts(EVENTS)) {
    console.log(`${key}: ${count}`);
  }
}

main();

groupingBy { it }.eachCount() is the grouping and the counting as one expression -- closer to Python's Counter than to the hand-rolled maps either side of it. The sort chains two comparator builders, compareByDescending then .thenBy, instead of one hand-written function.

// Group and count: tally how often each key appears, then rank the tallies.

val EVENTS = listOf(
    "home", "docs", "home", "blog", "pricing", "docs", "home", "blog",
    "docs", "home", "pricing", "docs", "blog", "pricing", "home", "docs"
)

fun rankedCounts(events: List<String>): List<Pair<String, Int>> {
    val counts = events.groupingBy { it }.eachCount()
    // Highest count first; equal counts broken by key, ascending.
    return counts.entries
        .sortedWith(compareByDescending<Map.Entry<String, Int>> { it.value }.thenBy { it.key })
        .map { it.key to it.value }
}

fun main() {
    for ((key, count) in rankedCounts(EVENTS)) {
        println("$key: $count")
    }
}

A plain map[string]int, and counts[key]++ works on a missing key because Go's maps return the zero value rather than an error -- the increment needs no existence check at all. There is no comparator-chaining shorthand, so the tie-break is an explicit if inside sort.Slice.

// Group and count: tally how often each key appears, then rank the tallies.
package main

import (
	"fmt"
	"sort"
)

var events = []string{
	"home", "docs", "home", "blog", "pricing", "docs", "home", "blog",
	"docs", "home", "pricing", "docs", "blog", "pricing", "home", "docs",
}

type keyCount struct {
	key   string
	count int
}

func rankedCounts(events []string) []keyCount {
	counts := make(map[string]int)
	for _, key := range events {
		counts[key]++
	}
	ranked := make([]keyCount, 0, len(counts))
	for key, count := range counts {
		ranked = append(ranked, keyCount{key, count})
	}
	// Highest count first; equal counts broken by key, ascending.
	sort.Slice(ranked, func(i, j int) bool {
		if ranked[i].count != ranked[j].count {
			return ranked[i].count > ranked[j].count
		}
		return ranked[i].key < ranked[j].key
	})
	return ranked
}

func main() {
	for _, kc := range rankedCounts(events) {
		fmt.Printf("%s: %d\n", kc.key, kc.count)
	}
}

counts.entry(key).or_insert(0) is the explicit version of what Go's zero value does silently: ask for the entry, supplying what to put there if it is not found yet, then deref and add. Ordering::then_with chains the two comparisons lazily -- the key comparison only runs when the counts tie.

// Group and count: tally how often each key appears, then rank the tallies.
use std::collections::HashMap;

const EVENTS: [&str; 16] = [
    "home", "docs", "home", "blog", "pricing", "docs", "home", "blog",
    "docs", "home", "pricing", "docs", "blog", "pricing", "home", "docs",
];

fn ranked_counts(events: &[&str]) -> Vec<(String, usize)> {
    let mut counts: HashMap<&str, usize> = HashMap::new();
    for &key in events {
        *counts.entry(key).or_insert(0) += 1;
    }
    let mut ranked: Vec<(String, usize)> =
        counts.into_iter().map(|(k, v)| (k.to_string(), v)).collect();
    // Highest count first; equal counts broken by key, ascending.
    ranked.sort_by(|a, b| b.1.cmp(&a.1).then_with(|| a.0.cmp(&b.0)));
    ranked
}

fn main() {
    for (key, count) in ranked_counts(&EVENTS) {
        println!("{}: {}", key, count);
    }
}

counts.merge(key, 1, Integer::sum) is one call that inserts 1 for a new key or adds 1 to an existing one, avoiding the separate contains-check Java's older map API would need. The comparator is written as an int arithmetic difference first, falling back to compareTo only when that difference is zero.

// Group and count: tally how often each key appears, then rank the tallies.
import java.util.*;

public class GroupCount {
    static final List<String> EVENTS = List.of(
        "home", "docs", "home", "blog", "pricing", "docs", "home", "blog",
        "docs", "home", "pricing", "docs", "blog", "pricing", "home", "docs"
    );

    static List<Map.Entry<String, Integer>> rankedCounts(List<String> events) {
        Map<String, Integer> counts = new HashMap<>();
        for (String key : events) {
            counts.merge(key, 1, Integer::sum);
        }
        List<Map.Entry<String, Integer>> ranked = new ArrayList<>(counts.entrySet());
        // Highest count first; equal counts broken by key, ascending.
        ranked.sort((a, b) -> {
            int byCount = b.getValue() - a.getValue();
            return byCount != 0 ? byCount : a.getKey().compareTo(b.getKey());
        });
        return ranked;
    }

    public static void main(String[] args) {
        for (Map.Entry<String, Integer> e : rankedCounts(EVENTS)) {
            System.out.println(e.getKey() + ": " + e.getValue());
        }
    }
}

unordered_map's operator[] default-constructs a missing key to 0 before the ++ runs, the same zero-value trick as Go. Structured bindings (auto& [key, count]) unpack the pairs in both the sort comparator and the final loop without naming .first/.second.

// Group and count: tally how often each key appears, then rank the tallies.
#include <algorithm>
#include <iostream>
#include <string>
#include <unordered_map>
#include <vector>

const std::vector<std::string> EVENTS = {
    "home", "docs", "home", "blog", "pricing", "docs", "home", "blog",
    "docs", "home", "pricing", "docs", "blog", "pricing", "home", "docs",
};

std::vector<std::pair<std::string, int>> ranked_counts(const std::vector<std::string>& events) {
    std::unordered_map<std::string, int> counts;
    for (const auto& key : events) {
        counts[key]++;
    }
    std::vector<std::pair<std::string, int>> ranked(counts.begin(), counts.end());
    // Highest count first; equal counts broken by key, ascending.
    std::sort(ranked.begin(), ranked.end(), [](const auto& a, const auto& b) {
        if (a.second != b.second) return a.second > b.second;
        return a.first < b.first;
    });
    return ranked;
}

int main() {
    for (const auto& [key, count] : ranked_counts(EVENTS)) {
        std::cout << key << ": " << count << "\n";
    }
    return 0;
}

No hash map in the standard library, so the table is a fixed-size array of structs and find_or_add is a linear scan comparing every existing key with strcmp before adding a new one. It is exactly what the hash maps above are doing per bucket, just without the hashing step that makes it fast at scale. qsort takes a comparator in the oldest C idiom here: a function pointer and two void*.

/* Group and count: tally how often each key appears, then rank the tallies.
 * No hash map in the standard library, so counting is a linear scan over a
 * small fixed array of (key, count) pairs -- the thing every map above does
 * underneath, just without the amortised O(1) lookup. */
#include <stdio.h>
#include <string.h>

static const char *EVENTS[] = {
    "home", "docs", "home", "blog", "pricing", "docs", "home", "blog",
    "docs", "home", "pricing", "docs", "blog", "pricing", "home", "docs",
};
#define N_EVENTS (sizeof(EVENTS) / sizeof(EVENTS[0]))

typedef struct { const char *key; int count; } KeyCount;

static int find_or_add(KeyCount *table, int *n, const char *key) {
    for (int i = 0; i < *n; i++) {
        if (strcmp(table[i].key, key) == 0) return i;
    }
    table[*n].key = key;
    table[*n].count = 0;
    return (*n)++;
}

static int cmp(const void *pa, const void *pb) {
    const KeyCount *a = pa, *b = pb;
    if (a->count != b->count) return b->count - a->count;
    return strcmp(a->key, b->key);
}

int main(void) {
    KeyCount table[8];
    int n = 0;
    for (size_t i = 0; i < N_EVENTS; i++) {
        int idx = find_or_add(table, &n, EVENTS[i]);
        table[idx].count++;
    }
    qsort(table, n, sizeof(KeyCount), cmp);
    for (int i = 0; i < n; i++) {
        printf("%s: %d\n", table[i].key, table[i].count);
    }
    return 0;
}

counts[key, default: 0] += 1 folds the missing-key case into the subscript itself, reading closest to Python's one-liner of any manually-incremented map here. sorted(by:) takes a single closure, so the two-part comparison is one ?: expression rather than a chained call.

// Group and count: tally how often each key appears, then rank the tallies.

let events = [
    "home", "docs", "home", "blog", "pricing", "docs", "home", "blog",
    "docs", "home", "pricing", "docs", "blog", "pricing", "home", "docs",
]

func rankedCounts(_ events: [String]) -> [(key: String, count: Int)] {
    var counts: [String: Int] = [:]
    for key in events {
        counts[key, default: 0] += 1
    }
    // Highest count first; equal counts broken by key, ascending.
    return counts.sorted { a, b in
        a.value != b.value ? a.value > b.value : a.key < b.key
    }.map { (key: $0.key, count: $0.value) }
}

for (key, count) in rankedCounts(events) {
    print("\(key): \(count)")
}