Maximum Matching of Players With Trainers

Maximum Matching of Players With Trainers - Problem

Imagine you're running a sports academy where you need to match players with trainers for optimal training sessions. Each player has a specific ability level, and each trainer has a training capacity that represents the maximum ability level they can effectively coach.

Given two arrays:

players[i] - the ability of the i-th player
trainers[j] - the training capacity of the j-th trainer

A player can only be matched with a trainer if the player's ability ≤ trainer's capacity. Additionally, each player can have at most one trainer, and each trainer can coach at most one player.

Goal: Find the maximum number of valid player-trainer pairs you can create.

Example: If players = [4,7,9] and trainers = [8,2,5,8], you can match:
• Player with ability 4 → Trainer with capacity 8
• Player with ability 7 → Trainer with capacity 8
• Player with ability 9 → Cannot be matched (no trainer with capacity ≥ 9)
Result: 2 matches

Input & Output

example_1.py — Basic Matching

$ Input: players = [4,7,9], trainers = [8,2,5,8]

› Output: 2

💡 Note: Player with ability 4 can match with trainer capacity 5 or 8. Player with ability 7 can match with trainer capacity 8. Player with ability 9 cannot match with any trainer (all have capacity < 9). Maximum matches = 2.

example_2.py — Perfect Matching

$ Input: players = [1,1,1], trainers = [10,10,10]

› Output: 3

💡 Note: All players have ability 1 and all trainers have capacity 10. Since 1 ≤ 10, every player can match with any trainer. Maximum matches = 3.

example_3.py — No Matches Possible

$ Input: players = [10,20,30], trainers = [1,2,3]

› Output: 0

💡 Note: Every player's ability is greater than every trainer's capacity. No valid matches can be made. Result = 0.

Visualization

Tap to expand

Understanding the Visualization

Sort by Skill Level

Line up players and trainers by their abilities - weakest to strongest. This helps us make optimal decisions.

Start with Weakest Player

Always try to match the weakest available player first. They have the most limited options.

Find Cheapest Suitable Trainer

For each player, find the weakest trainer who can still handle them. This preserves stronger trainers for harder cases.

Greedy Choice Property

This greedy strategy works because using a stronger trainer for a weaker player never improves the total - it only wastes resources.

Key Takeaway

🎯 Key Insight: The greedy approach works because using a minimal sufficient trainer for each player preserves stronger trainers for players who truly need them, maximizing total matches.

Time & Space Complexity

Time Complexity

⏱️

O(n log n + m log m)

Dominated by sorting both arrays where n=players.length and m=trainers.length

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for pointers and counter (excluding sorting space)

✓ Linear Space

Constraints

1 ≤ players.length, trainers.length ≤ 10⁵
1 ≤ players[i], trainers[j] ≤ 10⁹
Each player can match with at most one trainer
Each trainer can match with at most one player

Asked in

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

The optimal solution uses a greedy two-pointers approach after sorting both arrays. The key insight is that matching the weakest available player with the weakest suitable trainer preserves stronger trainers for stronger players, maximizing total matches. Time complexity: O(n log n + m log m) for sorting, space complexity: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Greedy Optimal)	O(n log n + m log m)	O(1)	Sort both arrays and use greedy matching with two pointers
Brute Force (Try All Combinations)	O(2^(n+m))	O(n+m)	Generate all possible matchings and find the one with maximum pairs

Two Pointers (Greedy Optimal) — Algorithm Steps

Sort both players and trainers arrays in ascending order
Initialize two pointers: player_ptr=0, trainer_ptr=0
If current player can be matched with current trainer (player ≤ trainer), increment both pointers and count++
If current trainer is too weak, move to next trainer
Continue until we've processed all players or trainers
Return the total count of matches

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort both arrays

Players: [4,7,9], Trainers: [2,5,8,8]

Initialize pointers

Start with both pointers at position 0

Compare and match

If player ≤ trainer, increment both; else increment trainer pointer

Continue until done

Process all elements to find maximum matches

Code -

solution.c — C

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

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

int maxPairs(int* players, int playersLen, int* trainers, int trainersLen) {
    qsort(players, playersLen, sizeof(int), compare);
    qsort(trainers, trainersLen, sizeof(int), compare);
    
    int playerPtr = 0;
    int trainerPtr = 0;
    int matches = 0;
    
    while (playerPtr < playersLen && trainerPtr < trainersLen) {
        if (players[playerPtr] <= trainers[trainerPtr]) {
            // Match found
            matches++;
            playerPtr++;
            trainerPtr++;
        } else {
            // Current trainer is too weak, try next trainer
            trainerPtr++;
        }
    }
    
    return matches;
}

int main() {
    int players[] = {4, 7, 9};
    int trainers[] = {8, 2, 5, 8};
    printf("%d\n", maxPairs(players, 3, trainers, 4));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n + m log m)

Dominated by sorting both arrays where n=players.length and m=trainers.length

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for pointers and counter (excluding sorting space)

✓ Linear Space

Constraints

1 ≤ players.length, trainers.length ≤ 10⁵
1 ≤ players[i], trainers[j] ≤ 10⁹
Each player can match with at most one trainer
Each trainer can match with at most one player

28.4K Views

Medium Frequency

~12 min Avg. Time

892 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Two Pointers (Greedy Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler