CS302 -- Lab 2 - Golf Handicaps

In this lab, you will write a non-trivial application that will make you use trees and fields.

In the game of golf, players can rank themselves with a handicap. This is a number that basically tells you how good you are at the game. The lower your handicap, the better you are.

The US Golf Association has a very lengthy description of how you calculate a handicap. It may be found at http://www.usga.org/handicap/, if you're interested. I'm going to simplify it a bit. Here is how you calculate a handicap for a golfer:

The handicap is calculated from the golfer's most recent 20 scores. If the golfer has not played 20 rounds of golf, then we won't compute his or her handicap.
All golf courses are different. To take account of each course's difficulty, each course has two numbers: a rating, and a slope. Each time a golfer plays a round, he computes a differential for that round. That differential is computed from the following formula

differential = (score - rating) * 113 / slope
where score is the player's score for the round, rating is the rating of the course on which the round was played, and slope is the slope of the course on which the round was played.
The handicap is computed to be 96 percent of the average of the lowest 10 differentials of the golfer's most recent 20 scores.

For example, suppose I have played 20 rounds of golf from the white tees at Three Ridges golf course, whose rating is 69.3 and whose slope is 119. On ten of the rounds, I shot 88 and on the other ten, I shot 85. Then I would compute my handicap as follows:

For each round on which I shot an 88, the differential is (88-69.3)*113/119 = 17.757.
For each round on which I shot an 85, the differential is (85-69.3)*113/119 = 14.908.
This means that my best ten differentials are all 14.908, so their average is obviously 14.908, and my handicap is 0.96 * 14.908 = 14.31

Your Job

Your job is to write the program handicap. It should take two command line arguments:

handicap score-file course-file

The score-file is a file that contains scores. Each line of this file is in the following format:

Month Day Year Name Score Course

Month is a number between 1 and 12. Day is a number between 1 and 31. You do not have to error check for legal month/day combinations (i.e. don't worry about 2/30). Year is the year (i.e. 1999, 2000 -- no Y2K bugs on this program). Name is a one-word name of a golfer, and Score is an integer score. Course is the name of a course, and may contain any number of words separated by white space. The scores can be in any order, and there can be any number of golfers in the score file.

There are example score files in /home/parker/courses/cs302/labs/lab2:

score1: An example score file with exactly 20 scores, 10 of which are 88's and 10 of which are 85's, all played on the white tees at Three Ridges. As calculated above, the handicap for this score file should be 14.31.
score2: The same score file as score1, but with a second golfer, Phil, added. Phil has 10 scores of 74 and 10 scores of 78.
score3: The same score file as score2, except that Phil and Jim both have 40 scores. The most recent 20 for each person is the same as in score2.
bigscore: A big score file with 11 different golfers who have a variety of scores.
scorebad1: A bad score file: only 4 scores instead of >= 20.
scorebad2: A bad score file: the golf course does not exist.
scorebad3: A bad score file: bad month declarations.
scorebad4: A bad score file: the golfer's name is two words.
scorebad5: A bad score file: no golf course

The course-file is a file that contains golf courses plus their ratings and slopes. This file has a more loose structure than the score file. It contains three kinds of lines:

Course Lines: These start with the word ``Course'' and then contain the name of the golf course. Again, the name is words separated by white space.
Rating/Slope Lines: These have the word ``Rating'' then the rating (which is a floating point number), then the word ``Slope'' and then the slope (which you should also treat as a floating point number). When you encounter this line, it is the rating and slope for the course named on the most recently encountered ``Course'' line.
All Other Lines: All other lines should be ignored.

An example (the one you should use for your testing) is in courses. Look at the first four lines:

Course Three Ridges -- White Tees Rating 69.3 Slope 119 Par 72

This says that there is a course that's called ``Three Ridges -- White Tees'' with a rating of 69.3 and a slope of 119. You ignore the ``Par'' line, and the blank line after the ``Par'' line.

In both files (scores and courses) you should create a string for a course that is composed of each word separated by a space. For example, the following course specifications should be equivalent:

Course Three Ridges -- White Tees

Course      Three          Ridges          -- White            Tees

Now, your program must read in both of these files, and exit if it sees any errors. If both files are ok, and all golfers have at least 20 scores, then it should compute the handicap for each golfer, and then print out each golfer and his or her handicap ordered by handicap (lowest first). Print out the handicap first (padded to 5 characters and two decimal places), and then the golfer's name.

For example:

UNIX> handicap score1 courses
14.31 Jim
UNIX> handicap score2 courses
 3.70 Phil
14.31 Jim
UNIX> handicap score3 courses
 3.70 Phil
14.31 Jim
UNIX> handicap bigscore courses
 2.58 Tiger
 8.26 Phil
 8.31 Sergio
 9.63 David
 9.77 Anika
10.12 Jose
18.12 Ernie
18.21 Colin
18.50 John
18.88 Se-Ri
39.55 Karrie
UNIX> handicap scorebad1 courses
Jim: Less than 20 scores (only 4)
UNIX> handicap scorebad2 courses
scorebad2 Line 1: Course `` Three Ridges -- Ebony Tees'' not found in course file
UNIX> handicap scorebad3 courses
scorebad3 Line 1: Bad Month
UNIX> handicap scorebad4 courses
scorebad4 Line 1: Bad Score
UNIX> handicap scorebad5 courses
scorebad5 Line 1: No course declaration
Should be month day year name score course
UNIX>

A working executable is available in /home/parker/courses/cs302/labs/lab2. If you set the environment variable PRINTDIFFS to be "yes", then the program will also print out each golfer's differential and date number (defined in step 4 below) or each score. You can use this to test yourself in case your computations do not seem to match those here: (note, you do not have to implement this feature. It is just included it so that you can help test your own code).

UNIX> setenv PRINTDIFFS yes
UNIX> handicap score1 courses
Jim
  Dnum: 743660   Differential: 17.76
  Dnum: 743661   Differential: 17.76
  Dnum: 743691   Differential: 14.91
  Dnum: 743693   Differential: 14.91
  Dnum: 743722   Differential: 17.76
  Dnum: 743725   Differential: 17.76
  Dnum: 743753   Differential: 14.91
  Dnum: 743757   Differential: 14.91
  Dnum: 743784   Differential: 17.76
  Dnum: 743789   Differential: 17.76
  Dnum: 743815   Differential: 14.91
  Dnum: 743821   Differential: 14.91
  Dnum: 743846   Differential: 17.76
  Dnum: 743853   Differential: 17.76
  Dnum: 743877   Differential: 14.91
  Dnum: 743885   Differential: 14.91
  Dnum: 743908   Differential: 17.76
  Dnum: 743939   Differential: 14.91
  Dnum: 743970   Differential: 17.76
  Dnum: 744001   Differential: 14.91

14.31 Jim
UNIX> setenv PRINTDIFFS no
UNIX> handicap score1 courses
14.31 Jim
UNIX>

What To Submit

You should submit the following files:

handicap.h: Even though you are using only one .c file for this assignment you should still place your structs/typedefs in a .h file. Doing so will give you good practice for future labs.
handicap.c
makefile

Remember, you submit labs using the special script discussed on the TA web site.

Suggested steps for writing this program:

Below are outlined suggestions for how to go about writing this program, which you should find helpful.

Step 1: Write a basic program that tests for the right number of command line arguments, and print out the right error message if that was wrong. Get your makefile working.
Step 2: Write a procedure called read_course_file() that takes the course file name as its only argument and returns a red-black tree. This red black tree is keyed on course name, and has pointers to Course structs (which you should define) in the val fields. It tests for all varieties of errors in the course file. When it returns, the main() routine prints out all of the courses in alphabetical order. Test this a bit, especially checking the error handling code.
Step 3: Write a procedure called read_scores_file() that takes the score file name and the course red-black tree as input, and returns a new red-black tree. However, for this step, all it does is read the score file and check for errors. These errors are: bad month/day/year/score, bad line (too few words), and course not found in the course file (which you do check by searching in the course tree). Test this against all the input files listed above.
Step 4. Turn the date into a number. You don't have to do anything fancy here, because all you care about is the relative order. You can compute a date number like this:

number = day + (month*31) + (year * 12 * 31)
Compute this, then print it out for each score and check to make sure that it is working.
Step 5. Now, create a big two-level red-black tree in read_scores_file(). The first level is keyed on golfer name. The val field of each node is another red-black tree, which is keyed on this date number, and whose val field is the differential for the score on that date. If two scores for the same golfer have the same date, don't worry about it -- just insert both differentials into the tree. Now, test this by traversing this big tree and printing out all of the differentials. This is what you get when you set PRINTDIFFS in the provided executable above.
Step 6. Now, test to make sure that all the golfers had at least 20 scores, and print an error if that was not the case. Test this.
Step 7. Now, compute the handicap for each golfer. To do this, use a red-black tree -- insert the last 20 differentials into a red-black tree, and then compute the average of the first ten scores of this tree. Then multiply by 0.96 and print out the handicap. Then delete the red-black tree and move onto the next golfer. Again, test this.
Step 8. Finally, use yet another red-black tree to sort each golfer by their handicap, and print them out in the proper order.
Step 9. More testing, commenting, etc.