Assignment 1: Modeling and Implementing Tournaments (Standard)
Due (part 1): Friday, March 20 at 5pm via Turnin
Due (part 2): Tuesday, March 24 at 11:59pm via Turnin
This assignment will be posted and due in two parts: a first part will be due on Friday, with a second part due on Tuesday. We will post the second part only after the first part comes in, so check back on Friday for the rest of the assignment (it will build off of the first part).
Many tournaments are organized into elimination rounds, in which pairs of remaining contestants play a match and the winner advances onto the next round. In this assignment, we will model and implement programs over tournaments in Java.
The following Scheme/Racket data definitions capture tournaments:
;; A tournament is either |
;; - (make-init-match match-data) |
;; - (make-advance-match match-data tournament tournament) |
(define-struct init-match (data)) |
(define-struct advance-match (data feeder1 feeder2)) |
|
;; a match-data is (make-match-data contestant contestant contestant) |
(define-struct match-data (side1 side2 winner)) |
Different kinds of tournaments capture different information about the contestants. The Cricket World Cup (going on right now!) features internationally-ranked contestants who compete as a nation:
;; a cricket-team is (make-cricket-team string string number) |
(define-struct cricket-team country jersey-color rank) |
A reality-cooking show, in contrast, features chefs who compete individually:
;; a chef is (make-chef string string number) |
(define-struct chef (name cuisine twitterFollowers) |
An inter-university robotics tournament might care about the interesting special capabilities of each robot (such as a powerful arm, rocket-powered jumping, or the ability to spray water):
;; a robot is (make-robot string boolean string) |
(define-struct robot (school competed-before? best-feature) |
1 Part 1: Creating Tournament Data
Develop Java class and interface definitions to capture tournaments with the contents of the Scheme/Racket definitions shown above. Your tournaments definition should be able to support each of our three examples of tournaments (cricket, cooking, and robotics).
Develop Java class and interface definitions for each of cricket teams, chefs, and robots, each with the contents of the Scheme/Racket definitions shown above.
Create several examples of data (in an Examples class) for tournaments. Use each of the three kinds of contestants across your set of examples. Think ahead to variations in the tournaments that might become useful once we ask you to write methods over tournaments for part 2.
Think about how you will capture a tournament that has started, but not yet finished, so winners are not yet known for all matches.
For the first deadline (on Friday), submit the definitions and examples from this part in turnin. You will be able to revise your work once you get to the methods – this deadline is a checkpoint on how you are approaching the assignment.
2 Part 2: Methods
We will run our own set of test cases against your work as part of grading this assignment. This will only work if everyone has used the same names for the classes, interfaces, and methods. Edit your work from part 1 as needed to conform to the following naming conventions:
Your contestant classes should be named CricketTeam, Chef, and Robot. They should all implement an interface called IContestant.
Your tournament classes and interfaces should be named InitMatch, AdvanceMatch, ITournament, and MatchData.
Include a class NotYetKnown that implements IContestant and can be used to capture winners that have not yet been determined.
All method names, parameter types, and parameter orders should exactly match what is stated in the problems below.
To help you test whether your names are correct, use this Main.java (which detects naming errors).
Test cases are graded on this and all assignments unless an assignment states otherwise.
Competitions usually have a notion of an "underdog": a contestant who is unlikely to win many matches. Cricket teams with ranks larger than 20 (such as 21) are underdogs. Chefs with fewer than 100 twitter followers are underdogs. Robots that have not competed before and have "pogo sticks" as their best feature are underdogs.
Edit your class and interface definitions as needed to require that every kind of contestant support an isUnderdog method. Include this method (with the definitions just given) in each of your contestant classes.
Write a method countUnderdogWins on Tournaments on that produces the number of matches in the tournament in which the winner is an underdog.
Write a method winnersAlwaysPlayed on Tournaments that produces a boolean indicating whether every match with a known winner has a winner that was also one of the sides in the match.
Write a method anySkippedMatches on Tournaments that produces a boolean indicating whether any match with a known winner has a feeder match with an unknown winner.
An image consultant for an upcoming cricket tournament wants a method named hasColorClash that works only on cricket tournaments and indicates whether two teams with same jersey color are ever scheduled in the same initial match.
In text (as a comment) discuss whether it is possible to write such a method with (a) the rest of the definitions as you have them, and (b) the Java constructs we have covered so far. If you think it is possible, describe what helper methods you would need in which classes. If you don’t think it is possible, explain as precisely as you can why this can’t work in the portion of Java that you’ve learned so far. you do not have to submit any code for this question, just your analysis.
3 What to Turn In
Submit .java files containing the final versions of all classes, interfaces, and examples developed for this assignment. Do not submit the .class files. Put your Examples class in its own file called Examples.java. Your may put all of your other classes and interfaces either into a single file or into separate ones (as you prefer).
4 Grading and Expectations
Follow the General Formatting Guidelines on assignments. Here is an example of a well-formatted version of the animals programs from early this week.
This assignment will earn points towards the following course themes:
Java Programming (whether you used the constructs properly)
Testing (the correctness and sufficiency of your tests)
Program Design (just a bit, mostly that your structure matches what CS1101 templates would expect, that you documented your methods, etc – nothing new from 2102 yet)
Here are some details on what we will look for in grading this assignment:
Do your classes have appropriate variables and methods for the given problem?
Did you create an appropriate set of classes for the given problem?
Did you use interfaces where appropriate?
Do your methods have appropriate parameters for the given problems?
Do your methods produce the right answer?
Is your code well documented, with brief purpose statements on each method?
Is your code indented and presented in a clean, readable manner?
Are your test cases thorough, covering possible variations in the input data and exercising all of your code?
In previous years, typical submissions have lost the most points on inadequate test cases. A strong test suite indicates that you really understand both the data you are working with and the nuances of the problem. We grade your tests as closely as your code, so take time to think out your test cases and whether they really exercise both the data structure and the methods you are writing.