In order to make the schedule work, I devised a new type of round-robin schedule for an even numbers of teams that gives each team 1 bye; I call it a “limited single-bye” round-robin (in that there is 1 bye per team, but the way byes are distributed is limited). This thread is a resource for information about the format, can be used to ask questions, and will be updated with a FAQ as appropriate.

**On “limited single-bye” prelims:**

A “limited single-bye” schedule is in contrast to a “double-bye” schedule (see Berkeley’s Scheduling Guide). To briefly expound on the theory: a “double-bye” schedule takes

*n*+ 1 rounds, where

*n*is the number of (even) teams for which you are doing a round-robin, and (as suggested by its name) gives every team 2 byes. It is generated by taking the schedule for

*n*+ 1 (odd) teams and making the last team a bye. (Example: an 8-team double-bye schedule is generated from a 9-team single-bye schedule by designating the 9th team as a bye and condensing the schedule.)

A “limited single-bye” schedule takes

*n*rounds, where

*n*is the number of (even) teams for which you are doing a round-robin, and (as suggested by its name) gives every team 1 bye. The manner in which a limited single-bye schedule is generated is very different, and there is no universal scheduling theory; every schedule

*can*be different. So, how do you generate a limited single-bye schedule?

You start with the schedule for an even team round-robin; we’ll use 10 teams since that’s an example I’ve already generated. A 10-team round robin takes 9 rounds. You generate byes by moving

*some*games from rounds 1 thru 9 into a new “round 10” (4 games to be precise; for an even team round-robin of

*n*teams, you move

*n*– 1 games). Assuming you move games from the different rounds, you create 1 bye for 2 teams in each round, for a total of 5 rounds with 2 teams on bye (4 rooms) and 5 rounds with no teams on bye (5 rooms). Note that “round 10” is in quotes for a reason—remember, you can order the rounds however you like! An example is in order:

Code: Select all

```
Round Room 1 Room 2 Room 3 Room 4 Room 5 BYE
1 5 v 9 4 v 10 6 v 7 2 v 3 1 v 8
2 3 v 10 6 v 9 1 v 4 2 v 7 5, 8
3 2 v 4 5 v 7 8 v 9 1 v 10 3, 6
4 6 v 8 1 v 3 7 v 9 4 v 5 2, 10
5 2 v 8 3 v 5 4 v 6 9 v 10 1, 7
6 3 v 4 5 v 10 7 v 8 1 v 9 2 v 6
7 5 v 6 3 v 9 1 v 2 7 v 10 4 v 8
8 8 v 10 1 v 6 4 v 9 2 v 5 3 v 7
9 2 v 9 4 v 7 6 v 10 3 v 8 1 v 5
10 1 v 7 2 v 10 5 v 8 3 v 6 4, 9
```

*n*of

*n*+ 1 rounds (even team double-bye schedule for

*n*teams); instead, you eliminate one room per two “paired” brackets, in the case where all the byes for each “paired” bracket are in different rounds. (This case does not occur, for example, if you have 2 brackets and a packet with 2 authors that are in different brackets, as you obviously must have a round where there is a bye for both brackets.)

The properties of a limited single-bye schedule are a hybrid of the (odd team) single-bye and (even team) double-bye schedules, with its own unique disadvantages:

Properties:

- Takes
*n*rounds, where*n*is the (even) number of teams for which you are doing a round-robin (single-bye). - Can handle packets with 1 packet author in a bracket (single-bye) or 2 packet authors in a bracket (double-bye); the latter is an ideal case since you immediately know which match to move to your “new” round.

- Only generates byes for half the rounds, and so can only be used if a bracket contain teams who've written
**at most***n*/ 2 different packets.

**When Should You Use It?**

This schedule works very well in some situations and not so well in others; here are two examples:

- A 12-team ACF Regionals field where you need to use at most 6 submitted packets.
- A bracketed prelim with brackets of
*n*– 1 odd teams and*n*even teams.

*n*even teams and

*n*+ 1 odd teams because you would have some brackets taking

*n*rounds and some brackets taking

*n*+ 1 rounds.

The reason it works for

*n*– 1 odd teams is that the same principles of the “limited single-bye” schedule for

*n*teams can be used to extend an

*n*– 1 round odd team schedule to an

*n*round odd team schedule, creating an odd team “limited double-bye” schedule. (This schedule has (

*n*– 2)/2 rounds with 3 byes and the rest of the rounds with 1 bye.) (I use

*n*– 2 in order to have

*n*consistently refer to the number of even teams for which you are doing the round-robin; it is

*n*– 1 if you are referencing the number of odd teams for which you are doing a round-robin.) An odd team double-bye schedule has the same advantages as an even team double-bye schedule in that it can handle 2 authors of the same packet in a single bracket, but is “limited” because the rounds with 3 byes only occur for less than half the rounds.

Obviously, due to point #1, this schedule would not work for a 16-team CO field where you need to use 16 submitted packets.

Hopefully this is a clear explanation of the format; again, this thread is intended to serve as a resource about the format, so drop any questions below.