Algorithm that creates "teams" based on a numeric skill value

Question

I am building an application that helps manage frisbee "hat tournaments". The idea is people sign up for this "hat tournament". When they sign up, the provide us with a numeric value between 1 and 6 which represents their skill level.

Currently, we are taking this huge list of people who signed up, and manually trying to create teams out of this based on the skill levels of each player. I figured, I could automate this by creating an algorithm that splits up the teams as evenly as possible.

The only data feeding into this is the array of "players" and a desired "number of teams". Generally speaking we are looking at 120 players and 8 teams.

My current thought process is to basically have a running "score" for each team. This running score is the total of all assigned players skill levels. I loop through each skill level. I go through rounds of picks once inside skill level loop. The order of the picks is recalculated each round based on the running score of a team.

This actually works fairly well, but its not perfect. For example, I had a range of 5 pts in my sample data array. I could very easily, manually swap players around and make the discrepancy no more then 1 pt between teams.. the problem is getting that done programatically.

Here is my code thus far: http://pastebin.com/LAi42Brq

Snippet of what data looks like:

[2] => Array
    (
        [user__id] => 181
        [user__first_name] => Stephen
        [user__skill_level] => 5
    )

[3] => Array
    (
        [user__id] => 182
        [user__first_name] => Phil
        [user__skill_level] => 6
    )

Can anyone think of a better, easier, more efficient way to do this? Many thanks in advance!!

Answer 1

I think you're making things too complicated. If you have T teams, sort your players according to their skill level. Choose the top T players to be captains of the teams. Then, starting with captain 1, each captain in turn chooses the player (s)he wants on the team. This will probably be the person at the top of the list of unchosen players.

This algorithm has worked in playgrounds (and, I dare say on the frisbee fields of California) for aeons and will produce results as 'fair' as any more complicated pseudo-statistical method.

Answer 2

A simple solution could be to first generating a team selection order, then each team would "select" one of the highest skilled player available. For the next round the order is reversed, the last team to select a player gets first pick and the first team gets the last pick. For each round you reverse the picking order.

First round picking order could be:

A - B - C - D - E

second round would then be:

E - D - C - B - A

and then

A - B - C - D - E etc.