Design a Leaderboard — Score Tracking with Top K

Problem

Design a leaderboard:

addScore(playerId, score) — add score to player's total
top(K) — return sum of top K scores
reset(playerId) — reset player's score to 0

Solutions

Python

import heapq
from collections import defaultdict

class Leaderboard:
    def __init__(self):
        self.scores = defaultdict(int)

    def addScore(self, playerId: int, score: int) -> None:
        self.scores[playerId] += score

    def top(self, K: int) -> int:
        return sum(heapq.nlargest(K, self.scores.values()))

    def reset(self, playerId: int) -> None:
        self.scores[playerId] = 0

Python — Sorted List (O(log n) per add)

from sortedcontainers import SortedList
from collections import defaultdict

class Leaderboard:
    def __init__(self):
        self.scores = defaultdict(int)
        self.sl = SortedList()

    def addScore(self, playerId, score):
        if playerId in self.scores:
            self.sl.remove(self.scores[playerId])
        self.scores[playerId] += score
        self.sl.add(self.scores[playerId])

    def top(self, K):
        return sum(self.sl[-K:])

    def reset(self, playerId):
        self.sl.remove(self.scores[playerId])
        self.scores[playerId] = 0

JavaScript

class Leaderboard {
    constructor() { this.scores = new Map(); }
    addScore(id, score) { this.scores.set(id, (this.scores.get(id) || 0) + score); }
    top(K) {
        return [...this.scores.values()].sort((a,b) => b-a).slice(0, K).reduce((a,b) => a+b, 0);
    }
    reset(id) { this.scores.set(id, 0); }
}

Java

import java.util.*;
class Leaderboard {
    Map<Integer,Integer> scores = new HashMap<>();
    public void addScore(int id, int score) { scores.merge(id, score, Integer::sum); }
    public int top(int K) {
        return scores.values().stream().sorted(Comparator.reverseOrder()).limit(K).mapToInt(Integer::intValue).sum();
    }
    public void reset(int id) { scores.put(id, 0); }
}

C++

#include <unordered_map>
#include <queue>
using namespace std;
class Leaderboard {
    unordered_map<int,int> scores;
public:
    void addScore(int id, int score) { scores[id] += score; }
    int top(int K) {
        priority_queue<int> pq;
        for (auto& [_,s] : scores) pq.push(s);
        int sum = 0;
        while (K-- && !pq.empty()) { sum += pq.top(); pq.pop(); }
        return sum;
    }
    void reset(int id) { scores[id] = 0; }
};

C

int player_scores[10001] = {0};
void addScore(int id, int score) { player_scores[id] += score; }
void reset(int id) { player_scores[id] = 0; }
/* top(K): partial sort the scores array */