Divide Players Into Teams of Equal Skill - Problem

You are given a positive integer array skill of even length n where skill[i] denotes the skill of the i^th player.

Divide the players into n / 2 teams of size 2 such that the total skill of each team is equal.

The chemistry of a team is equal to the product of the skills of the players on that team.

Return the sum of the chemistry of all the teams, or return -1 if there is no way to divide the players into teams such that the total skill of each team is equal.

Input & Output

Example 1 — Basic Valid Case

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

› Output: 22

💡 Note: Sort to [1,2,3,3,4,5]. Pair from ends: (1,5) sum=6 chemistry=5, (2,4) sum=6 chemistry=8, (3,3) sum=6 chemistry=9. Total: 5+8+9=22

Example 2 — Impossible Case

$ Input: skill = [3,4]

› Output: 12

💡 Note: Only one possible pairing: (3,4). Team sum=7, chemistry=3×4=12. Since there's only one team, all teams have equal sums.

Example 3 — Cannot Form Equal Teams

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

› Output: -1

💡 Note: Sort to [1,1,2,3]. Try pairing from ends: (1,3) sum=4, (1,2) sum=3. Team sums are not equal, so return -1.

Constraints

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

Visualization

Tap to expand

Asked in

M Meta 15 a Amazon 12 G Google 8

The key insight is that after sorting, pairing players from opposite ends (weakest with strongest) guarantees equal team sums if a solution exists. The optimal approach sorts the array and uses two pointers, achieving O(n log n) time and O(1) space complexity.

Common Approaches

✓ Dfs

⏱️ Time: N/A Space: N/A

Brute Force - Try All Pairings

⏱️ Time: O(n! / (2^(n/2) × (n/2)!)) Space: O(n)

Try every possible way to divide players into pairs. For each configuration, check if all teams have the same skill total. If found, calculate chemistry sum; otherwise return -1.

Frequency Map Validation

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

Count frequency of each skill level and check if equal team sums are possible by analyzing the distribution. This approach validates feasibility before attempting pairing.

Sort and Two Pointers

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

Sort the skill array and use two pointers from start and end. This ensures that if equal team totals are possible, pairing weakest with strongest will achieve it.

Algorithm Steps — Algorithm Steps

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* skill, int n) {
    if (n % 2 != 0) {
        return -1;
    }
    
    qsort(skill, n, sizeof(int), compare);
    int targetSum = skill[0] + skill[n-1];
    int chemistrySum = 0;
    
    int left = 0, right = n - 1;
    
    while (left < right) {
        int currentSum = skill[left] + skill[right];
        if (currentSum != targetSum) {
            return -1;
        }
        
        chemistrySum += skill[left] * skill[right];
        left++;
        right--;
    }
    
    return chemistrySum;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    if (strstr(line, "[]")) {
        printf("-1\n");
        return 0;
    }
    
    int skill[1000];
    int size = 0;
    char* token = strtok(line + 1, ",]");
    
    while (token) {
        skill[size++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int result = solution(skill, size);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

⚡ Linearithmic Space

23.5K Views

Medium Frequency

~15 min Avg. Time

847 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