Find the Number of Winning Players - Problem

You are given an integer n representing the number of players in a game and a 2D array pick where pick[i] = [x_i, y_i] represents that the player x_i picked a ball of color y_i.

Player i wins the game if they pick strictly more than i balls of the same color. In other words:

Player 0 wins if they pick any ball (at least 1 ball of any color)
Player 1 wins if they pick at least 2 balls of the same color
Player i wins if they pick at least i + 1 balls of the same color

Return the number of players who win the game. Note that multiple players can win the game.

Input & Output

Example 1 — Basic Game

$ Input: n = 4, pick = [[0,0],[1,0],[1,0],[2,1],[2,1],[2,0]]

› Output: 2

💡 Note: Player 0 picks 1 ball of color 0, needs ≥1, wins. Player 1 picks 2 balls of color 0, needs ≥2, wins. Player 2 picks 2 balls of color 1 and 1 of color 0, needs ≥3 of same color, loses. Player 3 picks nothing, loses.

Example 2 — Single Winner

$ Input: n = 5, pick = [[1,3],[4,4],[1,3],[3,0]]

› Output: 1

💡 Note: Player 1 picks 2 balls of color 3, needs ≥2, wins. Player 3 picks 1 ball of color 0, needs ≥4, loses. Player 4 picks 1 ball of color 4, needs ≥5, loses. Players 0 and 2 pick nothing, lose.

Example 3 — No Winners

$ Input: n = 3, pick = [[1,1],[2,2]]

› Output: 0

💡 Note: Player 0 picks nothing, loses. Player 1 picks 1 ball of color 1, needs ≥2, loses. Player 2 picks 1 ball of color 2, needs ≥3, loses.

Constraints

2 ≤ n ≤ 10
1 ≤ pick.length ≤ 100
pick[i].length == 2
0 ≤ x_i < n
0 ≤ y_i ≤ 10

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 A Amazon 8

The key insight is that player i needs at least i+1 balls of the same color to win. Best approach uses frequency counting with nested maps to track each player's color picks in one pass, then checks winning conditions. Time: O(m + n), Space: O(n × colors).

Common Approaches

✓ Sort First

⏱️ Time: N/A Space: N/A

Stack

⏱️ Time: N/A Space: N/A

Brute Force - Check Each Player Individually

⏱️ Time: O(n × m) Space: O(colors)

Iterate through all players from 0 to n-1. For each player, go through all picks to count how many balls of each color they picked, then check if any color count meets the winning condition.

Frequency Count - One Pass with Nested Maps

⏱️ Time: O(m + n) Space: O(n × colors)

Create a nested structure where we track count[player][color] for each pick. Then iterate through players to check winning conditions based on their maximum color count.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MAX_PLAYERS 1000
#define MAX_COLORS 1000

static int playerColors[MAX_PLAYERS][MAX_COLORS];

int solution(int n, int pick[][2], int pickSize) {
    // Initialize player colors count
    for (int i = 0; i < MAX_PLAYERS; i++) {
        for (int j = 0; j < MAX_COLORS; j++) {
            playerColors[i][j] = 0;
        }
    }
    
    // Count balls of each color for each player
    for (int i = 0; i < pickSize; i++) {
        int player = pick[i][0];
        int color = pick[i][1];
        playerColors[player][color]++;
    }
    
    int winners = 0;
    
    for (int player = 0; player < n; player++) {
        // Player i wins if they have strictly more than i balls of the same color
        // In other words, they need at least (i + 1) balls of the same color
        int required = player + 1;
        
        // Check if this player has enough balls of any color
        bool hasEnough = false;
        for (int color = 0; color < MAX_COLORS; color++) {
            if (playerColors[player][color] >= required) {
                hasEnough = true;
                break;
            }
        }
        
        if (hasEnough) {
            winners++;
        }
    }
    
    return winners;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    int n = atoi(line);
    
    fgets(line, sizeof(line), stdin);
    
    int pick[1000][2];
    int pickSize = 0;
    
    char* ptr = line;
    while (*ptr && *ptr != '[') ptr++;
    ptr++;
    
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            char* end;
            pick[pickSize][0] = strtol(ptr, &end, 10);
            ptr = end;
            while (*ptr && *ptr != ',') ptr++;
            if (*ptr == ',') ptr++;
            pick[pickSize][1] = strtol(ptr, &end, 10);
            ptr = end;
            while (*ptr && *ptr != ']') ptr++;
            if (*ptr == ']') ptr++;
            pickSize++;
        } else {
            ptr++;
        }
    }
    
    printf("%d\n", solution(n, pick, pickSize));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

23.4K Views

Medium Frequency

~12 min Avg. Time

856 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