Design A Leaderboard - Practice Coding Problems

Design A Leaderboard - Problem

Design a Leaderboard class for competitive gaming or sports applications.

Your leaderboard must support three key operations:

🏆 addScore(playerId, score): Add points to a player's total score. If the player doesn't exist, create a new entry.

📊 top(K): Return the sum of scores from the top K highest-scoring players.

🔄 reset(playerId): Remove a player from the leaderboard (reset their score to 0).

Example: In an esports tournament, players earn points throughout multiple matches. You need to efficiently track rankings and calculate prize pools for top performers.

The leaderboard starts empty, and you're guaranteed that any player being reset was previously added.

Input & Output

example_1.py — Basic Operations

$ Input: leaderboard = Leaderboard() leaderboard.addScore(1, 73) # Player 1: 73 leaderboard.addScore(2, 56) # Player 2: 56 leaderboard.addScore(3, 39) # Player 3: 39 leaderboard.top(2) # Query top 2

› Output: 129

💡 Note: Top 2 players are Player 1 (73) and Player 2 (56). Sum = 73 + 56 = 129

example_2.py — Reset Operation

$ Input: leaderboard.reset(1) # Remove Player 1 leaderboard.addScore(2, 51) # Player 2: 56 + 51 = 107 leaderboard.top(3) # Query top 3

› Output: 146

💡 Note: After reset, remaining players: Player 2 (107), Player 3 (39). Top 3 sum = 107 + 39 = 146

example_3.py — Edge Case

$ Input: new_board = Leaderboard() new_board.addScore(1, 100) new_board.top(5) # K > number of players

› Output: 100

💡 Note: Only 1 player exists but K=5 requested. Return sum of all available players (just 100)

Constraints

1 ≤ playerId ≤ 10⁵
1 ≤ score ≤ 10⁵
1 ≤ K ≤ total number of players
At most 1000 operations will be performed
It is guaranteed that playerId exists before calling reset

Visualization

Tap to expand

Understanding the Visualization

Player Registration

New players are added to hash table when they first score points

Score Updates

During matches, player scores are updated instantly in O(1) time using hash table lookups

Live Rankings

When broadcast needs top K players, all scores are extracted and sorted once

Player Elimination

Disqualified players are removed from the leaderboard instantly

Key Takeaway

🎯 Key Insight: Use hash tables for lightning-fast score updates during live gameplay, accepting the cost of sorting only when rankings are actually needed for broadcasts or prize calculations.

Asked in

a Amazon 35 G Google 28 ⊞ Microsoft 22 f Meta 18

The optimal approach uses a hash table for O(1) player score updates and resets, combined with sorting on-demand for top(K) queries. This provides the best balance between update performance and query accuracy, making it ideal for live tournament systems where score updates are frequent but ranking queries are occasional.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Sort Every Query)	O(n log n) per top(K), O(1) for addScore/reset	O(n)	Store scores in hash table, sort all players for every top(K) query
Hash Table with Sorting (Optimal)	O(1) for addScore/reset, O(n log n) for top(K)	O(n)	Use hash table for updates, sort only during top(K) queries for best balance

Brute Force (Sort Every Query) — Algorithm Steps

Store player scores in a hash table (playerId -> score)
addScore: Update or create entry in hash table - O(1)
reset: Remove entry from hash table - O(1)
top(K): Extract all scores, sort descending, sum first K - O(n log n)

Visualization

Tap to expand

Step-by-Step Walkthrough

Add Scores

Store player scores in hash table for O(1) access

Sort All Scores

Extract all scores and sort them in descending order

Sum Top K

Take first K scores from sorted list and calculate sum

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_PLAYERS 1000

typedef struct {
    int playerIds[MAX_PLAYERS];
    int scores[MAX_PLAYERS];
    int size;
} Leaderboard;

Leaderboard* leaderboardCreate() {
    Leaderboard* lb = (Leaderboard*)malloc(sizeof(Leaderboard));
    lb->size = 0;
    return lb;
}

int findPlayer(Leaderboard* lb, int playerId) {
    for (int i = 0; i < lb->size; i++) {
        if (lb->playerIds[i] == playerId) return i;
    }
    return -1;
}

void leaderboardAddScore(Leaderboard* lb, int playerId, int score) {
    int idx = findPlayer(lb, playerId);
    if (idx == -1) {
        lb->playerIds[lb->size] = playerId;
        lb->scores[lb->size] = score;
        lb->size++;
    } else {
        lb->scores[idx] += score;
    }
}

int compare(const void* a, const void* b) {
    return *(int*)b - *(int*)a;
}

int leaderboardTop(Leaderboard* lb, int K) {
    int* scoresCopy = (int*)malloc(lb->size * sizeof(int));
    memcpy(scoresCopy, lb->scores, lb->size * sizeof(int));
    
    qsort(scoresCopy, lb->size, sizeof(int), compare);
    
    int sum = 0;
    int limit = K < lb->size ? K : lb->size;
    for (int i = 0; i < limit; i++) {
        sum += scoresCopy[i];
    }
    
    free(scoresCopy);
    return sum;
}

void leaderboardReset(Leaderboard* lb, int playerId) {
    int idx = findPlayer(lb, playerId);
    if (idx != -1) {
        for (int i = idx; i < lb->size - 1; i++) {
            lb->playerIds[i] = lb->playerIds[i + 1];
            lb->scores[i] = lb->scores[i + 1];
        }
        lb->size--;
    }
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n) per top(K), O(1) for addScore/reset

Each top(K) query requires sorting all n players. AddScore and reset are hash table operations.

⚡ Linearithmic

Space Complexity

O(n)

Hash table stores one entry per active player

⚡ Linearithmic Space

43.5K Views

Medium Frequency

~25 min Avg. Time

1.5K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Sort Every Query) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler