Find Players With Zero or One Losses - Practice Coding Problems

Find Players With Zero or One Losses - Problem

Tournament Player Analysis

You're analyzing match results from a tournament to identify two specific groups of players based on their loss records. Given an array of match results where each element matches[i] = [winner_i, loser_i] represents that player winner_i defeated player loser_i, you need to:

🏆 Find players with zero losses - These are the undefeated champions who haven't lost a single match
🥈 Find players with exactly one loss - These are the runners-up who lost only once

Important: Only consider players who have participated in at least one match (either as winner or loser). Return both lists in increasing order.

Example: If matches = [[1,3],[2,3],[3,6],[5,6],[5,7],[4,5],[4,8],[4,9],[10,4],[10,9]], then:
- Player 1, 2, 10 never lost → answer[0] = [1,2,10]
- Players 4, 5, 7, 8 lost exactly once → answer[1] = [4,5,7,8]

Input & Output

basic_tournament.py — Python

$ Input: matches = [[1,3],[2,3],[3,6],[5,6],[5,7],[4,5],[4,8],[4,9],[10,4],[10,9]]

› Output: [[1,2,10],[4,5,7,8]]

💡 Note: Players 1, 2, 10 never lost any matches (undefeated). Players 4, 5, 7, 8 each lost exactly one match. Player 3 lost 2 matches, Player 6 lost 2 matches, Player 9 lost 2 matches - these are excluded from results.

simple_case.py — Python

$ Input: matches = [[2,3],[1,3],[1,4],[2,4]]

› Output: [[1,2],[]]

💡 Note: Players 1 and 2 are undefeated (0 losses each). Players 3 and 4 each lost 2 matches, so no players have exactly one loss. Hence the second list is empty.

edge_single_match.py — Python

$ Input: matches = [[1,2]]

› Output: [[1],[2]]

💡 Note: Only one match: Player 1 beats Player 2. Player 1 has 0 losses (undefeated), Player 2 has exactly 1 loss.

Constraints

1 ≤ matches.length ≤ 10⁵
matches[i].length == 2
1 ≤ winner_i, loser_i ≤ 10⁵
winner_i ≠ loser_i
All matches[i] are unique (no duplicate matches)

Visualization

Tap to expand

Understanding the Visualization

Initialize Scoreboard

Start with empty loss tracking system

Process Match Results

For each match announcement, update winner (ensure 0 if new) and increment loser's count

Award Categories

Identify players for Gold Medal (0 losses) and Silver Medal (1 loss) ceremonies

Ceremony Order

Sort both lists for organized award presentation

Key Takeaway

🎯 Key Insight: Instead of checking each player against all matches (O(n²)), we process each match once and update loss counts in constant time, achieving optimal O(n + k log k) performance.

Asked in

a Amazon 45 G Google 38 f Meta 32 ⊞ Microsoft 28 Apple 22

The optimal approach uses a single-pass hash table to track loss counts efficiently. As we process each match, we ensure winners exist with 0 losses and increment losers' counts. This gives us O(n + k log k) time complexity where n is matches and k is unique players, with the sorting step being the only additional overhead after the optimal O(n) counting phase.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Count Losses for Each Player)	O(n² + k log k)	O(k)	For each unique player, count their losses by scanning all matches
One-Pass Hash Table (Optimal)	O(n + k log k)	O(k)	Count losses for all players in a single pass through matches

Brute Force (Count Losses for Each Player) — Algorithm Steps

Find all unique players from both winner and loser positions
For each player, iterate through all matches to count losses
Categorize players: 0 losses go to answer[0], 1 loss goes to answer[1]
Sort both result lists in ascending order

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract Players

Collect all unique players from matches

Count Losses

For each player, scan all matches to count losses

Categorize

Place players in appropriate result lists

Code -

solution.c — C

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

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

int** findWinners(int** matches, int matchesSize, int* matchesColSize, int* returnSize, int** returnColumnSizes) {
    // Find unique players and count losses
    int players[100001] = {0}; // loss count for each player
    int seen[100001] = {0};    // whether player exists
    
    for (int i = 0; i < matchesSize; i++) {
        int winner = matches[i][0];
        int loser = matches[i][1];
        
        seen[winner] = 1;
        seen[loser] = 1;
        players[loser]++; // increment loss count
    }
    
    // Collect results
    int* zeroLosses = (int*)malloc(100001 * sizeof(int));
    int* oneLoss = (int*)malloc(100001 * sizeof(int));
    int zeroCount = 0, oneCount = 0;
    
    for (int i = 1; i <= 100000; i++) {
        if (seen[i]) {
            if (players[i] == 0) {
                zeroLosses[zeroCount++] = i;
            } else if (players[i] == 1) {
                oneLoss[oneCount++] = i;
            }
        }
    }
    
    // Sort results
    qsort(zeroLosses, zeroCount, sizeof(int), compare);
    qsort(oneLoss, oneCount, sizeof(int), compare);
    
    // Prepare return values
    int** result = (int**)malloc(2 * sizeof(int*));
    *returnColumnSizes = (int*)malloc(2 * sizeof(int));
    
    result[0] = (int*)realloc(zeroLosses, zeroCount * sizeof(int));
    result[1] = (int*)realloc(oneLoss, oneCount * sizeof(int));
    (*returnColumnSizes)[0] = zeroCount;
    (*returnColumnSizes)[1] = oneCount;
    *returnSize = 2;
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² + k log k)

O(n²) to count losses for each player, O(k log k) to sort results where k is number of players

⚠ Quadratic Growth

Space Complexity

O(k)

O(k) space to store unique players and result lists

✓ Linear Space

89.2K Views

Medium-High Frequency

~15 min Avg. Time

2.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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Count Losses for Each Player) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler