Find the Number of Winning Players - Practice Coding Problems

Find the Number of Winning Players - Problem

🏆 Gaming Tournament Analysis

You're organizing a competitive ball-picking game tournament with n players, numbered from 0 to n-1. Each player picks colored balls throughout the game, and their picks are recorded in a 2D array pick where pick[i] = [player, color] represents that player picked a ball of color.

The winning condition is progressive - higher numbered players need more balls of the same color to win:

Player 0 wins if they pick any ball at all (≥ 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

Goal: Return the total number of players who meet their winning condition. Note that multiple players can win simultaneously!

Example: If Player 2 picks 3 red balls, they win because 3 ≥ (2 + 1). If Player 0 picks 1 blue ball, they also win because 1 ≥ (0 + 1).

Input & Output

example_1.py — Basic Tournament

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

› Output: 2

💡 Note: Player 0 picks 1 ball (color 0), needs ≥1, so wins. Player 1 picks 2 balls of color 0, needs ≥2, so wins. Player 2 picks 2 balls of color 1 and 1 of color 0, max is 2 but needs ≥3, so loses. Player 3 picks nothing, needs ≥4, so loses. Winners: 2

example_2.py — Single Winner

$ Input: n = 5, picks = [[1,1],[1,2],[1,3],[2,4]]

› Output: 0

💡 Note: Player 1 picks 1 ball each of colors 1,2,3 (max=1) but needs ≥2, so loses. Player 2 picks 1 ball of color 4 but needs ≥3, so loses. Players 0,3,4 pick nothing. No winners.

example_3.py — Edge Case

$ Input: n = 2, picks = [[0,5]]

› Output: 1

💡 Note: Player 0 picks 1 ball of color 5, needs ≥1, so wins. Player 1 picks nothing, needs ≥2, so loses. Winners: 1

Visualization

Tap to expand

Understanding the Visualization

Setup

Initialize empty scoreboard and winner's podium

Live Updates

For each ball pick, update the player's count for that color

Instant Check

Check if the updated count meets the player's winning threshold

Victory

If threshold is met and player hasn't won yet, add to winners

Final Count

Return total number of unique winners

Key Takeaway

🎯 Key Insight: By tracking counts in real-time and checking win conditions immediately upon each update, we avoid redundant scanning and achieve optimal linear time complexity.

Time & Space Complexity

Time Complexity

⏱️

O(m)

Single pass through m picks, each hash map operation is O(1) average case

✓ Linear Growth

Space Complexity

O(n × k)

Hash map storing up to k colors for each of n players, plus winners set

⚡ Linearithmic Space

Constraints

2 ≤ n ≤ 10
0 ≤ picks.length ≤ 100
picks[i].length == 2
0 ≤ x_i < n
0 ≤ y_i ≤ 10
Each pick represents one ball selection

Asked in

G Google 12 a Amazon 8 ⊞ Microsoft 6 f Meta 4

The optimal solution uses a one-pass hash table approach with O(m) time complexity. As we process each pick, we increment the player's color count and immediately check if they now meet their winning condition (count ≥ player_id + 1). This avoids redundant scanning and efficiently tracks winners using a hash set to prevent duplicates.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n × m)	O(1)	For each player, scan all picks to count each color separately
One-Pass Hash Table (Optimal)	O(m)	O(n × k)	Process picks once, tracking each player's color counts and checking win conditions immediately

Brute Force (Nested Loops) — Algorithm Steps

Initialize winner counter to 0
For each player from 0 to n-1:
Count their picks for each color by scanning all picks
Find their maximum count for any single color
If max count ≥ (player_id + 1), increment winner counter
Return total winners

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with player 0, winners = 0

Scan All Picks

For current player, count each color from all picks

Find Maximum

Determine the highest count for any single color

Check Win Condition

If max_count ≥ player_id + 1, increment winners

Next Player

Repeat for all players 0 to n-1

Code -

solution.c — C

int winningPlayerCount(int n, int** picks, int picksSize, int* picksColSize) {
    int winners = 0;
    
    for (int player = 0; player < n; player++) {
        int colorCount[11] = {0}; // Assuming colors 0-10
        
        // Count each color for this player
        for (int i = 0; i < picksSize; i++) {
            if (picks[i][0] == player) {
                colorCount[picks[i][1]]++;
            }
        }
        
        // Check if player wins
        int maxCount = 0;
        for (int i = 0; i < 11; i++) {
            if (colorCount[i] > maxCount) {
                maxCount = colorCount[i];
            }
        }
        
        if (maxCount >= player + 1) {
            winners++;
        }
    }
    
    return winners;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

For each of n players, we scan all m picks to count their colors

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables for counting, no additional data structures

✓ Linear Space

Constraints

2 ≤ n ≤ 10
0 ≤ picks.length ≤ 100
picks[i].length == 2
0 ≤ x_i < n
0 ≤ y_i ≤ 10
Each pick represents one ball selection

52.3K Views

Medium Frequency

~12 min Avg. Time

1.8K 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

🏆 Gaming Tournament Analysis

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler