CSci 490-1 (Special Topics) / Engr 596-6 (Special Projects)
Software Design and Scala Programming
Spring 2010

Assignment #3
Due Midnight, Tuesday. 27 April 2010

Note: This exercise is based on a practice programming problem used at the ACM Southeast Regional programming contest a few years ago.

Bingo is a popular game played on a 5 by 5 grid, called a card. Normally we associate each column of the card with the letters B-I-N-G-O from left to right. Each square on the grid has a number in it. As numbers are selected, they are marked off the card. When a line of five squares, horizontal, vertical or diagonal, is marked out, the card is a winner. When a player gets a winning card, he or she shouts BINGO!

A sample bingo card is shown below:

If the numbers 3, 45, 53, 75, and 26 are picked, then there will be a horizontal bingo on the second row.

The five entries in a column are random integers in the range selected from the ranges indicated below:

• under B, 1-15
• under I, 16-30
• under N, 31-45
• under G, 46-60
• under O, 61-75

The goal of this assignment is to design and implement a Scala program to play a game of bingo.

• Design and implement a BingoCard ADT (e.g., Scala trait or class) to represent a bingo card. A concrete instance of the ADT should include appropriate internal state and operations to manipulate that state during a bingo game. By default, a BingoCard should be initialized to a valid set of random values. (You likely will want to provide the ability to initialize the card to specific values as an aid in debugging and testing.)

  You will, of course, need operations to mark the card appropriately when numbers are called, determine whether the card is a winner, to "print" the card (e.g., return the card as a string so that it can be printed), and so forth.

• Design and implement a GameCards ADT (trait or class) to represent a collection of bingo cards being played at the same time. A concrete instance of the ADT should create the number of desired cards and then accept a sequence of random values in the range 1 to 75 that are played on the cards. It should detect a winner and make that information available through an appropriate feature of its interface. It should also be possible to print the winning card(s) and/or the entire collection.

  Constructing your own iterator to work on the GameCards collection might be a good idea.

• Design and implement other needed classes as appropriate.

• To facilitate my evaluation of your program, please make the startup command be
  scala PlayBingo n

  where n is the number of cards to include in the game.

  The program should display the numbers called during the game. At the completion of the game, the program should display the winning card and give other information useful in evaluation of your program. (It would be helpful in debugging if this output went to a file instead of just to the screen.) It is not necessary to do a GUI!

• Design and implement other needed classes as appropriate.

• Generalizations.. Look for ways you can make your program classes more flexible. For example, what about cards with other sizes? what about strings instead of numbers in the grid? what about different ranges of values? what about different winning patterns? Etc.

• Graduate students are required to implement at least one significant generalization as described in the previous item or under the comments below. This is optional (but recommended) for undergraduates. Please write documentation giving the nature of your generalizations.

• Test your program appropriately and thoroughly.

• Please format and document your program source code appropriately. Use of preconditions, postconditions, and invariants is recommended. Use of scaladoc annotations is also suggested.

• This is an individual programming assignment. Each student is expected to do his or her own work.

• Submit your source code, documentation, testing output, and execution instructions in a zip file using Blackboard.

• Also submit a paper listing of your files to the instructor.

Comments

This is not a particularly difficult assignment. My purposes are:

• To give all students an opportunity to learn more about the Scala language.

• To get all students to think more about implementing abstract data types in Scala, in a more "realistic" program setting than assignment #2.

• To help students learn to look for reasonable generalizations of programs.

Note that I do want the classes and methods specified using preconditions, postconditions, and invariants.

If any of you are looking for more of a challenge, you might think about developing the program, in particular the BingoCard and GameCards classes, as an "application framework" for a whole class of Bingo-like games. By application framework, I mean a set of abstract base classes, interfaces, and concrete library classes that can be extended, implemented, or used to provide different specific games. The set of classes making up the framework represent the common aspects of the family of programs. The extensions represent the variable aspects of the family. Here are some ideas--perhaps all cannot coexist within the same design.

• Consider changes such as having the space in the middle of the board a "free space" (that can be marked by any number), making the size of the board variable, making the techniques for initializing the board, ranges on values, etc., something that can be done in different ways (e.g., in an overridden method), etc. perhaps in a more precise way than they have previously.

• The row, column, and diagonal winning patterns are not the only ones used in Bingo. Perhaps allow design the class where different winning pattern detection techniques can be "plugged into" the class in some way. You may need to do some research into what different kinds of patterns are used in various Bingo games. perhaps in a more precise way than they have previously.

  You might want to investigate the Template Method, Strategy, Decorator, Visitor, and other design patterns for ideas on how to implement this (and other of the possible enhancements).

• Consider using a general class of objects for the labels in the Bingo grid, not just Ints. Since an equality operation is needed you will need to define an appropriate base class or interface to represent this hierarchy of labels.

• I implied a simple text-based display of the bingo card. If you like graphics, you might consider having the game to have a "real-time" display of bingo cards on the screen. This capability should not be built directly into the BingoCard class but should be a separate class that gets its information from a BingoCard instance. You would probably need to be able to selectively choose cards to display, since all in a GameCards class will not likely fit on a screen at once.
• Etc.

Finally, if you have a programming problem you would like to tackle, then let me know. I could perhaps substitute it for this one, but more likely I might consider it for future individual or group programming exercises.

UP to Engr 692 Assignments page?