Due: Wednesday 14 March
The reading for this assignment is Chapters 15-16 of
How to think....
The following are the possible hands in poker, in increasing order
of value (and decreasing order of probability):
The goal of this homework is to use Monte Carlo simulation to estimate
the probability of drawing these various hands.
- two cards with the same rank
- two pair:
- two pairs of cards with the same rank
- three of a kind:
- three cards with the same rank
- five cards with ranks in sequence (aces can
be high or low, but other than that, there is no wraparound).
- five cards with the same suit
- full house:
- three cards with one rank, two cards with another
- four of a kind:
- four cards with the same rank
- straight flush:
- five cards in sequence and with the same suit
- Type the following commands in your sd directory
to download and unpack a tar file:
tar -xzf poker.tgz
It should create the following files:
As always, you should take some time to familiarize yourself with
the code I give you before you start writing your own code.
- : A complete version of the Card and
Deck classes in the book.
- : An incomplete implementation of a class
that represents a poker hand, and some code that tests it.
- : An example program that shows a graphical
representation of playing cards on a `table'.
- : A directory containing images of playing
cards in a variety of styles.
- If you run PokerHand.py, it deals six 7-card poker hands
and checks to see if any of them contains a flush. Then it uses
Lumpy to generate a UML object diagram and a UML class diagram for
the program. These diagrams might help you understand how the
- Poker.py contains code that displays a table full of
7-card hands and uses the has_flush method to check for
flushes. If you run it and press Deal a few times, you should
see at least one hand with a flush. Your job is to modify PokerHand.py and Poker.py to classify all poker hands.
- Add methods to PokerHand.py named has_pair,
has_twopair, etc. that return True or False according to
whether or not the hand meets the relevant criteria. Your code should
work correctly for `hands' that contain any number of cards
(although 5 and 7 are the most common sizes).
- Write a method named classify that figures out
the highest-value classification for a hand and sets the
label attribute accordingly. For example, a 7-card hand
might contain a flush and a pair; it should be labeled `flush'.
- Modify Poker.py to use your classify method to set the
label on each hand.
- When you are convinced that your classification methods are
working, the next step is to estimate the probablities of the various
hands. Write a function in PokerHand.py that shuffles a deck of
cards, divides it into hands, classifies the hands, and counts the
number of times various classifications appear.
- Print a table of the classifications and their probabilities.
Run your program with larger and larger numbers of hands until the
output values converge to a reasonable degree of accuracy.
- As a JFFE, you can investigate the claim that certain hands
tend to occur in clusters. For example, if you are at a table with
four other players, and you have a flush, is it more likely that
someone else at the table also has a flush? What about a full house?
- As another JFFE, modify your classify methods to handle wild cards
and see what effect wild cards have on the probabilities. Are there
any changes in the probability ordering?
- As always, take some time to improve your code, and
add comments that explain any non-obvious features.
- Please print a copy of PokerHand.py, and also a copy
of the probability table that it outputs.