algorithms for tournament brackets (NCAA, etc.)

Question

I'm trying implement a bracket in my program (using C#/.NET MVC) and I am stuck trying to figure out some algorithm.

For example, I have a bracket like this with 8 entries (A,B,C,D,E,F,G,H)

I'm trying to figure out if there's an algorithmic way to

1. depending on # of entries, find # of games per round

2. depending on # of entries, for a specific game #, what is the corresponding game # in the next round?

For example, in this case, for 8 entries, the example are:

1. for round 1, there are 4 games. Round 2, 2 games. Round 3, 1 game
2. game 2 in round 1 corresponds to game 5 in round 2.

I also thought about storing this info in a table, but it seems overkill since it never changes, but here it is anyway:

Any help will be greatly appreciated!

Cheers,

Dean

Answer 1

C# code for the first part of your question:

// N = Initial Team Count
// R = Zero-Based Round #
// Games = (N / (2 ^ R)) / 2
public double GamesPerRound(int totalTeams, int currentRound) {
    var result = (totalTeams / Math.Pow(2, currentRound)) / 2;

    // Happens if you exceed the maximum possible rounds given number of teams
    if (result < 1.0F) throw new InvalidOperationException();

    return result;
}

The next step in solving part (2) is to know the minimum game number for a given round. An intuitive way to do that would be through a for loop, but there's probably a better method:

var totalTeams = 8;
var selectedRound = 2;
var firstGame = 1;
// If we start with round 1, this doesn't execute and firstGame remains at 1
for (var currentRound = 1; currentRound < selectedRound; currentRound++) {
    var gamesPerRound = GamesPerRound(totalTeams, currentRound);
    firstGame += gamesPerRound;
}

Answer 2

Quoting @Yuck who answered the first question perfectly.

C# code for the first part of your question:

// N = Initial Team Count
// R = Zero-Based Round #
// Games = (N / (2 ^ R)) / 2
public double GamesPerRound(int totalTeams, int currentRound) {
    var result = (totalTeams / Math.Pow(2, currentRound)) / 2;

    // Happens if you exceed the maximum possible rounds given number of teams
    if (result < 1.0F) throw new InvalidOperationException();

    return result;
}

Moving on to the second question:

//G = current game.
//T = total teams
//Next round game = (T / 2) + RoundedUp(G / 2)
//i. e.: G = 2, T = 8
       //Next round game = (8 / 2) + RoundedUp(2 / 2) = 5
public int NextGame(int totalTeams, int currentGame) {
    return (totalTeams / 2) + (int)Math.Ceiling((double)currentGame / 2);
}