Team Formation Splitter - Problem

You are organizing a sports tournament and need to divide N players into K teams of equal size. Each player has a skill level represented by an integer.

Your goal is to create teams such that the difference between the highest and lowest total skill sums across all teams is minimized. This ensures the most balanced competition possible.

Input:

players: Array of integers representing skill levels of N players
k: Number of teams to form

Output:

Return a 2D array where each sub-array represents one team (containing player skill levels). The teams should be arranged to minimize the difference between team totals.

Constraints:

N is divisible by K (equal team sizes guaranteed)
Each team must have exactly N/K players

Input & Output

Example 1 — Basic Team Split

$ Input: players = [8, 2, 6, 4, 1, 9], k = 3

› Output: [[9,1],[8,2],[6,4]]

💡 Note: Sorted: [9,8,6,4,2,1]. Snake draft: Team 1 gets 9,4 (total 13), Team 2 gets 8,2 (total 10), Team 3 gets 6,1 (total 7). Difference: 13-7=6.

Example 2 — Perfect Balance Possible

$ Input: players = [10, 8, 6, 4, 2, 0], k = 2

› Output: [[10,2,0],[8,6,4]]

💡 Note: Both teams get total 12. Snake distribution: Team 1: [10,6,2], Team 2: [8,4,0], both sum to 18. Actually [10,2,0] and [8,6,4] both sum to 12 for perfect balance.

Example 3 — Four Teams

$ Input: players = [9, 7, 5, 3, 8, 6, 4, 2], k = 4

› Output: [[9,3],[8,2],[7,4],[6,5]]

💡 Note: Sorted: [9,8,7,6,5,4,3,2]. Snake pattern distributes evenly across 4 teams, each getting 2 players.

Constraints

2 ≤ players.length ≤ 1000
players.length % k == 0
1 ≤ k ≤ players.length
-1000 ≤ players[i] ≤ 1000

Visualization

Tap to expand

Asked in

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

The key insight is using a snake draft pattern after sorting players by skill. The greedy approach automatically balances teams by alternating distribution direction each round, similar to sports drafts. Time: O(n log n), Space: O(1).

Common Approaches

✓ Brute Force - Try All Combinations

⏱️ Time: O(K^N) Space: O(N)

Use backtracking to generate every possible way to divide players into K teams of equal size. For each valid combination, calculate the difference between highest and lowest team totals. Keep track of the best (most balanced) combination found.

Greedy Snake Draft

⏱️ Time: O(n log n) Space: O(1)

Sort all players by skill level, then distribute them using a snake draft pattern. Assign players to teams in round-robin order (Team 1, 2, 3, 1, 2, 3...) but reverse the direction each round. This mimics how sports drafts naturally create balanced teams.

Smart Backtracking with Pruning

⏱️ Time: O(K^N) Space: O(N)

Improve brute force by adding intelligent pruning. During recursion, if the current partial assignment already produces a larger difference than our best solution, abandon that branch early. This significantly reduces the search space.

Brute Force - Try All Combinations — Algorithm Steps

Step 1: Use recursive backtracking to assign each player to a team
Step 2: Ensure each team gets exactly N/K players
Step 3: Calculate team totals and find min/max difference
Step 4: Track the combination with smallest difference

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate

Try every possible way to assign players to teams

Calculate

Compute team totals and find difference

Compare

Keep the most balanced combination

Code -

solution.c — C

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

int bestTeams[100][100];
int bestTeamSizes[100];
int minDiff = INT_MAX;
int globalK;

void backtrack(int* players, int n, int teams[][100], int teamSizes[], int playerIdx, int teamSize) {
    if (playerIdx == n) {
        int valid = 1;
        for (int i = 0; i < globalK; i++) {
            if (teamSizes[i] != teamSize) {
                valid = 0;
                break;
            }
        }
        
        if (valid) {
            int totals[100];
            for (int i = 0; i < globalK; i++) {
                totals[i] = 0;
                for (int j = 0; j < teamSizes[i]; j++) {
                    totals[i] += teams[i][j];
                }
            }
            
            int maxVal = totals[0], minVal = totals[0];
            for (int i = 1; i < globalK; i++) {
                if (totals[i] > maxVal) maxVal = totals[i];
                if (totals[i] < minVal) minVal = totals[i];
            }
            
            int diff = maxVal - minVal;
            if (diff < minDiff) {
                minDiff = diff;
                for (int i = 0; i < globalK; i++) {
                    bestTeamSizes[i] = teamSizes[i];
                    for (int j = 0; j < teamSizes[i]; j++) {
                        bestTeams[i][j] = teams[i][j];
                    }
                }
            }
        }
        return;
    }
    
    for (int teamIdx = 0; teamIdx < globalK; teamIdx++) {
        if (teamSizes[teamIdx] < teamSize) {
            teams[teamIdx][teamSizes[teamIdx]] = players[playerIdx];
            teamSizes[teamIdx]++;
            backtrack(players, n, teams, teamSizes, playerIdx + 1, teamSize);
            teamSizes[teamIdx]--;
        }
    }
}

void solution(int* players, int n, int k) {
    globalK = k;
    int teamSize = n / k;
    int teams[100][100];
    int teamSizes[100] = {0};
    
    minDiff = INT_MAX;
    
    backtrack(players, n, teams, teamSizes, 0, teamSize);
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int players[100];
    int n = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        int num = atoi(token);
        if (num != 0 || strcmp(token, "0") == 0) {
            players[n++] = num;
        }
        token = strtok(NULL, "[,]");
    }
    
    int k;
    scanf("%d", &k);
    
    solution(players, n, k);
    
    printf("[");
    for (int i = 0; i < k; i++) {
        printf("[");
        for (int j = 0; j < bestTeamSizes[i]; j++) {
            printf("%d", bestTeams[i][j]);
            if (j < bestTeamSizes[i] - 1) printf(",");
        }
        printf("]");
        if (i < k - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(K^N)

Each player can be assigned to any of K teams, creating exponential combinations

✓ Linear Growth

Space Complexity

O(N)

Recursion stack depth up to N players plus team storage

✓ Linear Space

23.4K Views

Medium Frequency

~15 min Avg. Time

890 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

Team Formation Splitter - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Try All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler