Design A Leaderboard

Design A Leaderboard - Problem

Design a Leaderboard class with three main functions:

addScore(playerId, score): Update the leaderboard by adding the given score to the player's existing score. If the player doesn't exist, add them with the given score.
top(K): Return the sum of scores of the top K players on the leaderboard.
reset(playerId): Reset the player's score to 0 (remove them from the leaderboard). The player is guaranteed to exist.

Initially, the leaderboard is empty.

Input & Output

Example 1 — Basic Operations

$ Input: operations = ["Leaderboard","addScore","addScore","top"], parameters = [[],[1,73],[2,56],[2]]

› Output: [129]

💡 Note: Create leaderboard, add player 1 with 73 points, add player 2 with 56 points, then get top 2 sum: 73 + 56 = 129

Example 2 — Multiple Updates

$ Input: operations = ["Leaderboard","addScore","addScore","addScore","top"], parameters = [[],[1,73],[2,56],[1,39],[3]]

› Output: [168]

💡 Note: Player 1 gets 73+39=112 total, player 2 has 56. Top 3 sum: 112 + 56 = 168

Example 3 — Reset Operation

$ Input: operations = ["Leaderboard","addScore","addScore","reset","top"], parameters = [[],[1,73],[2,56],[1],[1]]

› Output: [56]

💡 Note: After adding scores and resetting player 1, only player 2 remains with 56 points

Constraints

1 ≤ playerId ≤ 10⁴
1 ≤ K ≤ total number of players
1 ≤ score ≤ 100
At most 1000 calls will be made to addScore, top, and reset

Visualization

Tap to expand

Asked in

a Amazon 15 G Google 12 M Microsoft 8

The key insight is to separate data storage from querying. Use a HashMap for O(1) score updates and resets, then sort scores only when top(K) is needed. Best approach: HashMap + sort on demand. Time: O(n log n) for queries, O(1) for updates. Space: O(n).

Common Approaches

✓ Brute Force with List

⏱️ Time: O(n log n) Space: O(n)

Maintain a simple list of all player scores. For each top(K) query, sort the entire list and sum the top K elements. This is inefficient but straightforward.

HashMap + Sort on Demand

⏱️ Time: O(n log n) Space: O(n)

Store scores in a HashMap for fast updates and lookups. Only sort the scores when top(K) is called, avoiding unnecessary sorting operations.

Brute Force with List — Algorithm Steps

Store all scores in a list
For top(K), sort entire list in descending order
Sum first K elements

Visualization

Tap to expand

Step-by-Step Walkthrough

Add Scores

Store player scores in array

Sort for Query

Sort entire array when top(K) is called

Sum Top K

Add up first K elements from sorted array

Code -

solution.c — C

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

#define MAX_PLAYERS 1000
#define MAX_LINE 10000

typedef struct {
    int playerId;
    int score;
} PlayerScore;

typedef struct {
    PlayerScore players[MAX_PLAYERS];
    int size;
} Leaderboard;

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

static void leaderboardAddScore(Leaderboard* obj, int playerId, int score) {
    for (int i = 0; i < obj->size; i++) {
        if (obj->players[i].playerId == playerId) {
            obj->players[i].score += score;
            return;
        }
    }
    obj->players[obj->size].playerId = playerId;
    obj->players[obj->size].score = score;
    obj->size++;
}

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

static int leaderboardTop(Leaderboard* obj, int K) {
    static int scores[MAX_PLAYERS];
    for (int i = 0; i < obj->size; i++) {
        scores[i] = obj->players[i].score;
    }
    
    qsort(scores, obj->size, sizeof(int), compare);
    
    int sum = 0;
    for (int i = 0; i < K && i < obj->size; i++) {
        sum += scores[i];
    }
    return sum;
}

static void leaderboardReset(Leaderboard* obj, int playerId) {
    for (int i = 0; i < obj->size; i++) {
        if (obj->players[i].playerId == playerId) {
            for (int j = i; j < obj->size - 1; j++) {
                obj->players[j] = obj->players[j + 1];
            }
            obj->size--;
            return;
        }
    }
}

static char* parseString(char* line, char* operations[], int* opCount) {
    *opCount = 0;
    char* start = strchr(line, '[');
    char* end = strrchr(line, ']');
    if (!start || !end) return NULL;
    
    start++;
    *end = '\0';
    
    char* token = strtok(start, ",");
    while (token && *opCount < 1000) {
        while (*token == ' ' || *token == '"') token++;
        char* endToken = token + strlen(token) - 1;
        while (endToken > token && (*endToken == ' ' || *endToken == '"')) {
            *endToken = '\0';
            endToken--;
        }
        operations[*opCount] = strdup(token);
        (*opCount)++;
        token = strtok(NULL, ",");
    }
    return NULL;
}

static void parseParams(char* line, int params[][10], int paramCounts[], int opCount) {
    for (int i = 0; i < opCount; i++) {
        paramCounts[i] = 0;
    }
    
    char* ptr = line;
    int opIndex = 0;
    
    while (*ptr && opIndex < opCount) {
        if (*ptr == '[') {
            ptr++;
            char* start = ptr;
            while (*ptr && *ptr != ']') ptr++;
            if (*ptr == ']') {
                *ptr = '\0';
                if (strlen(start) > 0) {
                    char* num = strtok(start, ",");
                    while (num && paramCounts[opIndex] < 10) {
                        while (*num == ' ') num++;
                        if (*num >= '0' && *num <= '9') {
                            params[opIndex][paramCounts[opIndex]] = (int)strtol(num, NULL, 10);
                            paramCounts[opIndex]++;
                        }
                        num = strtok(NULL, ",");
                    }
                }
                ptr++;
                opIndex++;
            }
        } else {
            ptr++;
        }
    }
}

int main() {
    static char opsLine[MAX_LINE];
    static char paramsLine[MAX_LINE];
    static char* operations[1000];
    static int params[1000][10];
    static int paramCounts[1000];
    static int results[1000];
    
    fgets(opsLine, MAX_LINE, stdin);
    fgets(paramsLine, MAX_LINE, stdin);
    
    int opCount;
    parseString(opsLine, operations, &opCount);
    parseParams(paramsLine, params, paramCounts, opCount);
    
    Leaderboard* lb = leaderboardCreate();
    int resultCount = 0;
    
    for (int i = 0; i < opCount; i++) {
        if (strcmp(operations[i], "Leaderboard") == 0) {
            continue;
        } else if (strcmp(operations[i], "addScore") == 0) {
            leaderboardAddScore(lb, params[i][0], params[i][1]);
        } else if (strcmp(operations[i], "top") == 0) {
            results[resultCount++] = leaderboardTop(lb, params[i][0]);
        } else if (strcmp(operations[i], "reset") == 0) {
            leaderboardReset(lb, params[i][0]);
        }
    }
    
    printf("[");
    for (int i = 0; i < resultCount; i++) {
        printf("%d", results[i]);
        if (i < resultCount - 1) printf(",");
    }
    printf("]\n");
    
    for (int i = 0; i < opCount; i++) {
        free(operations[i]);
    }
    free(lb);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Each top(K) operation requires sorting all n scores

⚡ Linearithmic

Space Complexity

O(n)

List stores all player scores

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~25 min Avg. Time

890 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 with List — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler