Divide Players Into Teams of Equal Skill - Practice Coding Problems

Divide Players Into Teams of Equal Skill - Problem

Divide Players Into Teams of Equal Skill

You are the coach of an esports tournament and need to organize n players into balanced teams! 🎮

Given an array skill of even length n where skill[i] represents the skill level of the i-th player, your task is to:

1. Divide all players into exactly n/2 teams of size 2
2. Ensure each team has the same total skill sum
3. Calculate the chemistry of each team (product of both players' skills)
4. Return the sum of all team chemistries

If it's impossible to create teams with equal skill sums, return -1.

Example: With skills [3,2,5,1,3,4], you can form teams: (1,5), (2,4), (3,3). Each team sums to 6, and total chemistry = 1×5 + 2×4 + 3×3 = 22.

Input & Output

example_1.py — Basic case with valid teams

$ Input: [3,2,5,1,3,4]

› Output: 22

💡 Note: After sorting: [1,2,3,3,4,5]. Pairs: (1,5)=6, (2,4)=6, (3,3)=6. All sums equal 6. Chemistry = 1×5 + 2×4 + 3×3 = 5+8+9 = 22.

example_2.py — Impossible case

$ Input: [3,4]

› Output: -1

💡 Note: Only one possible team (3,4) with sum=7. Since there's only one team, equal sums are impossible (need at least 2 teams to compare).

example_3.py — Simple valid case

$ Input: [1,1,2,3]

› Output: -1

💡 Note: After sorting: [1,1,2,3]. Trying pairs: (1,3)=4 and (1,2)=3. Sums are different (4≠3), so return -1.

Constraints

2 ≤ skill.length ≤ 10⁵
skill.length is even
1 ≤ skill[i] ≤ 1000

Visualization

Tap to expand

Understanding the Visualization

Sort by Skill

Arrange all players from weakest to strongest

Pair Extremes

Match the weakest available player with the strongest available player

Check Balance

Verify that all teams have the same total skill level

Calculate Chemistry

Sum up the chemistry (product of skills) for all valid teams

Key Takeaway

🎯 Key Insight: In a sorted array, if equal-sum pairs exist, pairing elements from opposite ends (smallest+largest, second-smallest+second-largest, etc.) always produces the optimal solution with O(n log n) time complexity.

Asked in

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

The optimal solution uses a two-pointers approach after sorting. Key insight: if equal-sum pairs exist, pairing the smallest with largest elements always works. Time complexity: O(n log n) due to sorting, space complexity: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Sorted Array)	O(n log n)	O(1)	Sort array and pair elements from opposite ends to achieve equal team sums
Brute Force (Try All Combinations)	O((n-1)!!)	O(n)	Generate all possible team pairings and check if any configuration has equal team sums

Two Pointers (Sorted Array) — Algorithm Steps

Sort the skill array in ascending order
Calculate target sum: total_sum / (n/2)
Use two pointers: left at start, right at end
For each pair, check if sum equals target
If all pairs have target sum, calculate total chemistry
If any pair doesn't match target, return -1

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Array

Sort skills in ascending order

Set Target

Calculate target sum from first and last elements

Pair from Ends

Use two pointers to pair smallest with largest

Validate & Calculate

Check if each pair sum equals target, compute chemistry

Code -

solution.c — C

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

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

long long dividePlayers(int* skill, int skillSize) {
    qsort(skill, skillSize, sizeof(int), compare);
    int targetSum = skill[0] + skill[skillSize - 1];
    long long totalChemistry = 0;
    
    int left = 0, right = skillSize - 1;
    
    while (left < right) {
        int currentSum = skill[left] + skill[right];
        
        if (currentSum != targetSum) {
            return -1;
        }
        
        totalChemistry += (long long)skill[left] * skill[right];
        left++;
        right--;
    }
    
    return totalChemistry;
}

int main() {
    int n;
    scanf("%d", &n);
    int* skill = malloc(n * sizeof(int));
    
    for (int i = 0; i < n; i++) {
        scanf("%d", &skill[i]);
    }
    
    printf("%lld\n", dividePlayers(skill, n));
    free(skill);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Dominated by sorting step. The two-pointer pairing is O(n)

⚡ Linearithmic

Space Complexity

O(1)

Only uses constant extra space for pointers and variables

✓ Linear Space

35.2K Views

Medium Frequency

~15 min Avg. Time

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

Two Pointers (Sorted Array) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler