My March Madness Bracket 2016

So I wrote a blog post about my process of creating my March Madness bracket last year, so I figure this year I’ll revisit it and explain what I changed. (Note: I know this post is actually after March Madness started… but I’ve been busy. I did actually create the bracket before the games began.)

I used Coder’s Bracket again for a couple reasons. First, it was pretty cool last year, and I wanted to try it again. The second was that I was really busy all week at Big Break with Cru, and I didn’t have much extra time to fill out a bracket, so just slightly modifying last year’s algorithm was really easy.

If you haven’t read my post from last year, you should probably go back and read it first for context.

I stuck with forcing seeds better than 5 in the first round and better than 2 in the second round to win. I did this to make sure my bracket doesn’t end up too crazy. Next year, I should try to remove that and see how I do.

What I changed, however, was making that check actually work :) . Last year, I used the >= operator for the condition, checking if the seed was greater than or equal to 5 and 2, which had the opposite effect than what I intended. This year, I’m using the <= operator, which actually does what I want.

I’ve also changed my scoring algorithm to remove winning percentage from the calculation. I’m already using RPI, so it seemed a tad redundant.

Additionally, I messed with the weights, because I felt like it. This isn’t a totally scientific process, contrary to what my comment might indicate :)

And that’s pretty much all there is to it! You can view my completed bracket on the Coder’s Bracket site here.

Here’s the code:

// My algorithm from 2015, with a couple tweaks for this year.
// Didn't work last year, probably won't work this year either,
// but I've been busy this week.

function(game, team1, team2){
  // Seeds 5 and better don't lose in the first round
  if (game.round == 5) {
    if (team1.seed <= 5 || team2.seed <= 5) { if (team1.seed > team2.seed) {
        team2.winsGame();
      } else {
        team1.winsGame();
      }
    }
  }
  // Seeds 2 and better don't lose in the second round
  if (game.round == 4) {
    if (team1.seed <= 3 || team2.seed <= 3) { if (team1.seed > team2.seed) {
        team2.winsGame();
      } else {
        team1.winsGame();
      }
    }
  }
  // Everyone else goes through my TOTALLY SCIENTIFIC scoring algorithm
  if (calcScore(team1) > calcScore(team2)) {
    team1.winsGame();
  } else {
    team2.winsGame();
  }

  // Scoring algorithm
  // Mostly objective, but I tweaked the weights to make my bracket interesting
  // I'm using the RPI, apparently a ranking of schedule difficulty to make win percentage be somewhat fair.
  // It's divided by two to lessen it's impact
  //
  // The numbers on the far side are the weights for each item
  function calcScore(team) {
    var myScore = 0;
    //myScore += team.rpi/2 * team.win_pct * 10; // Winning percentage
    myScore += team.rpi/2 * team.field_goal_pct * 7; // Field Goal percentage
    myScore += team.rpi/2 * team.free_throw_pct * 5; // Free Throw percentage
    myScore += team.rpi/2 * team.three_point_pct * 7; // 3's percentage
    // Penalty for missing 3's. About 10 per game on average, so I divided by 20 to lessen the impact.
    myScore -= team.rpi/2 * (team.threes_attempted - team.threes_made)/20 * 3;
    return myScore;
  }
}

My March Madness Bracket 2015

I’m just okay at picking basketball brackets. I usually finish somewhere in the upper third of the pack, IIRC.

However, it’s interesting to enter a bracket and watch the results come in (I almost never watch the games), so I usually make a bracket.

This year, I decided to use Coder’s Bracket to create my bracket.

If you haven’t already seen Coder’s Bracket, you should take a look. Basically, you algorithmically generate your bracket using JavaScript. However, setting that up manually is a lot of work. Fortunately, Coder’s Bracket has already done that for you. You provide a function taking three object parameters (game, team1, team2) that will call team1.winsGame() or team2.winsGame() depending on what you determine. You start with a simple seed-rules algorithm and work from there.

My algorithm runs basically like this:

  1. If it’s round 1 and the seed is greater than 5, it wins.
  2. If it’s round 2 and the seed is greater than 2, it wins.
  3. Otherwise, compute my extremely not scientific score for each team and the higher score wins.

My scoring algorithm takes into account strength of schedule (RPI), Field Goal %, Free Throw %, 3’s %, and Missed 3’s. I weight the values to make my bracket interesting (probably at the cost of correctness…).

There are probably a million and a half (exactly) problems with this algorithm, but it was fun to create.

You can see my bracket on Coder’s Bracket’s website.

I’ve included my algorithm below.

function(game, team1, team2){
  // Seeds 5 and better don't lose in the first round
  if (game.round == 5) {
    if (team1.seed >= 5 || team2.seed >= 5) {
      if (team1.seed > team2.seed) {
        team2.winsGame();
      } else {
        team1.winsGame();
      }
    }
  }
  // Seeds 2 and better don't lose in the second round
  if (game.round == 4) {
    if (team1.seed >= 3 || team2.seed >= 3) {
      if (team1.seed > team2.seed) {
        team2.winsGame();
      } else {
        team1.winsGame();
      }
    }
  }
  // Everyone else goes through my TOTALLY SCIENTIFIC scoring algorithm
  if (calcScore(team1) > calcScore(team2)) {
    team1.winsGame();
  } else {
    team2.winsGame();
  }

  // Scoring algorithm
  // Mostly objective, but I tweaked the weights to make my bracket interesting
  // I'm using the RPI, apparently a ranking of schedule difficulty to make win percentage be somewhat fair.
  // It's divided by two to lessen it's impact
  //
  // The numbers on the far side are the weights for each item
  function calcScore(team) {
    var myScore = 0;
    myScore += team.rpi/2 * team.win_pct * 10; // Winning percentage
    myScore += team.rpi/2 * team.field_goal_pct * 7; // Field Goal percentage
    myScore += team.rpi/2 * team.free_throw_pct * 4; // Free Throw percentage
    myScore += team.rpi/2 * team.three_point_pct * 5; // 3's percentage
    // Penalty for missing 3's. About 10 per game on average, so I divided by 20 to lessen the impact.
    myScore -= team.rpi/2 * (team.threes_attempted - team.threes_made)/20 * 3;
    return myScore;
  }
}