# 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;
}
}
```