Find Players With Zero or One Losses

Find Players With Zero or One Losses - Problem

You are given an integer array matches where matches[i] = [winner_i, loser_i] indicates that the player winner_i defeated player loser_i in a match.

Return a list answer of size 2 where:

answer[0] is a list of all players that have not lost any matches.
answer[1] is a list of all players that have lost exactly one match.

The values in the two lists should be returned in increasing order.

Note:

You should only consider the players that have played at least one match.
The testcases will be generated such that no two matches will have the same outcome.

Input & Output

Example 1 — Basic Tournament

$ 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,6,7,8]]

💡 Note: Players 1, 2, 10 never lost (0 losses). Players 4, 5, 6, 7, 8 lost exactly once. Player 3 lost twice (excluded), player 9 lost twice (excluded).

Example 2 — Simple Case

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

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

💡 Note: Players 1 and 2 never lost. Player 4 lost exactly once. Player 3 lost twice (excluded from both lists).

Example 3 — Single Match

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

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

💡 Note: Player 1 won and never lost (0 losses). Player 2 lost exactly once.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8 f Facebook 6

The key insight is to count losses per player using a hash map. Track all players and increment loss count for losers. Then filter players with exactly 0 or 1 losses and sort the results. Best approach uses hash map counting in O(n + p log p) time and O(p) space.

Common Approaches

✓ Brute Force - Count Losses for Each Player

⏱️ Time: O(n × p) Space: O(p)

Identify all unique players first, then for each player, iterate through all matches to count how many times they appear as a loser. Categorize players based on their loss count.

Hash Map - Count Losses Efficiently

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

Iterate through matches once to count losses for each player using a hash map. Then categorize players based on their loss count and sort the results.

Brute Force - Count Losses for Each Player — Algorithm Steps

Step 1: Find all unique players from matches
Step 2: For each player, count losses by scanning all matches
Step 3: Categorize players by loss count and sort results

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Players

Extract all unique player IDs from matches

Count Losses

For each player, scan all matches to count losses

Categorize

Group players by loss count (0 or 1) and sort

Code -

solution.c — C

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

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

int** solution(int** matches, int matchesSize, int* matchesColSize, int* returnSize, int** returnColumnSizes) {
    // Find all unique players
    static int players[100000];
    int playerCount = 0;
    
    for (int i = 0; i < matchesSize; i++) {
        int winner = matches[i][0];
        int loser = matches[i][1];
        
        // Check if winner exists
        int found = 0;
        for (int j = 0; j < playerCount; j++) {
            if (players[j] == winner) {
                found = 1;
                break;
            }
        }
        if (!found) players[playerCount++] = winner;
        
        // Check if loser exists
        found = 0;
        for (int j = 0; j < playerCount; j++) {
            if (players[j] == loser) {
                found = 1;
                break;
            }
        }
        if (!found) players[playerCount++] = loser;
    }
    
    int* noLosses = (int*)malloc(playerCount * sizeof(int));
    int* oneLoss = (int*)malloc(playerCount * sizeof(int));
    int noLossCount = 0, oneLossCount = 0;
    
    // For each player, count losses
    for (int i = 0; i < playerCount; i++) {
        int lossCount = 0;
        for (int j = 0; j < matchesSize; j++) {
            if (matches[j][1] == players[i]) {
                lossCount++;
            }
        }
        
        if (lossCount == 0) {
            noLosses[noLossCount++] = players[i];
        } else if (lossCount == 1) {
            oneLoss[oneLossCount++] = players[i];
        }
    }
    
    // Sort results
    qsort(noLosses, noLossCount, sizeof(int), compare);
    qsort(oneLoss, oneLossCount, sizeof(int), compare);
    
    // Prepare return arrays
    int** result = (int**)malloc(2 * sizeof(int*));
    *returnColumnSizes = (int*)malloc(2 * sizeof(int));
    
    result[0] = noLosses;
    result[1] = oneLoss;
    (*returnColumnSizes)[0] = noLossCount;
    (*returnColumnSizes)[1] = oneLossCount;
    *returnSize = 2;
    
    return result;
}

int main() {
    static char line[1000000];
    fgets(line, sizeof(line), stdin);
    
    // Parse input - simple parser for [[a,b],[c,d],...] format
    static int matches[100000][2];
    int matchesSize = 0;
    
    char* ptr = line;
    while (*ptr) {
        if (*ptr == '[' && *(ptr+1) != '[') {
            int a, b;
            ptr++;
            a = strtol(ptr, &ptr, 10);
            ptr++; // skip comma
            b = strtol(ptr, &ptr, 10);
            matches[matchesSize][0] = a;
            matches[matchesSize][1] = b;
            matchesSize++;
        }
        ptr++;
    }
    
    int* matchesColSize = (int*)malloc(matchesSize * sizeof(int));
    for (int i = 0; i < matchesSize; i++) matchesColSize[i] = 2;
    
    int** matchesPtr = (int**)malloc(matchesSize * sizeof(int*));
    for (int i = 0; i < matchesSize; i++) {
        matchesPtr[i] = matches[i];
    }
    
    int returnSize;
    int* returnColumnSizes;
    int** result = solution(matchesPtr, matchesSize, matchesColSize, &returnSize, &returnColumnSizes);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("[");
        for (int j = 0; j < returnColumnSizes[i]; j++) {
            printf("%d", result[i][j]);
            if (j < returnColumnSizes[i] - 1) printf(",");
        }
        printf("]");
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × p)

n matches × p players, checking each player against all matches

✓ Linear Growth

Space Complexity

O(p)

Storage for unique players and result lists

✓ Linear Space

83.3K Views

Medium Frequency

~15 min Avg. Time

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