Before starting to work with your partner, you should go through Question 1 yourself on paper. When you meet with your partner, check if you made the same predictions. If there are any discrepancies, try to decide which is correct before using DrScheme to evaluate the expressions.
You and your partner should work together on the rest of the assignment. However, you will each turn in separate stapled documents containing your answers to the written questions. You should read the whole problem set yourself and think about the questions before beginning to work on them with your partner.
Remember to follow the pledge you read and signed at the beginning of the semester. For this assignment, you may consult any outside resources, including books, papers, web sites and people, you wish except for materials from previous cs1120, cs150, and cs200 courses. You may consult an outside person (e.g., another friend who is a CS major but is not in this class) who is not a member of the course staff, but that person cannot type anything in for you and all work must remain your own. That is, you can ask general questions such as "can you explain recursion to me?" or "how do lists work in Scheme?", but outside sources should never give you specific answers to problem set questions. If you use resources other than the class materials, lectures and course staff, explain what you used in your turn-in.
You are strongly encouraged to take advantage of the scheduled help hours and office hours for this course.
In this problem set, you will develop procedures that can calculate odds for poker. Actually creating a poker bot involves making decisions based on incomplete information about what the other players have and how they behave. This is much harder than just calculating odds, but knowing the odds is important for any poker strategy.
We will consider the game Texas Hold 'Em, a popular version of poker that is used in most major tournaments. Each player is dealt two hole cards. These are kept hidden from the other players and can only be used by the player who was dealt them. Then, five community cards are dealt. Every player may use these cards. There are betting rounds after the hole cards are dealt, and after the third, fourth, and final community cards.
At the end of the hand, each remaining player makes their best five-card hand using as many of their own hole cards as they want and the community cards. So, a player may make a hand using just the five community cards (and none of their hole cards), either of their hole cards and any four of the community cards, or both of their hole cards and any three of the community cards.
To calculate the odds a player will win a hand, we need to know all possible hands that player could get and how many of them beat the other player's hand. For example, when there is one community card left to be dealt, that means we need to consider how many of the remaining cards in the deck will allow the player to make a hand that is better than the other players hand.
For the remainder of this problem set, you should work with your partner. First, compare and discuss your answers on Question 1. Then, download the PS2 code so you can check your answers in the interpreter.
This file contains:
For each fragment that you mispredicted indicate the correct answer and what you misunderstood. If the expression evaluates to a compound data structure, draw a picture showing that structure.
If you address all fragments in Question 1, and for each fragment you either predicted the correct answer (in Question 1) or explained the correct answer (in Question 2) you will receive full credit for Questions 1-2.
(define (make-card rank suit) (cons rank suit)) (define card-rank car) (define card-suit cdr)We use the numbers 2 through 10 to represent the normal card ranks, and 11 (Jack), 12 (Queen), 13 (King), and 14 (Ace) to represent the special cards. The definitions in poker.ss allow us to use the names Ace, King, Queen, and Jack for these ranks.
If your higher-card? procedure is correct, you should get the following interactions:
> (higher-card? (make-card Ace Diamonds) (make-card King Spades))
#t
> (higher-card? (make-card 3 Clubs) (make-card 2 Clubs))
#t
> (higher-card? (make-card Ace Diamonds) (make-card Ace Spades))
#f
sort: List x Procedure → List
sort takes as input a List and a comparison Procedure, and evaluates to a List that contains the elements in the input List reordered according to the comparison Procedure.
For sort to make sense, the input Procedure must evaluate to a transitive comparison procedure. This means if (Procedure x y) evaluates to true and (Procedure y z) evaluates to true, then (Procedure x z) must also evaluate to true. Then, the sorted list will have the least element (according to Procedure) at the front.
If your sort-hand procedure is correct, you should get the following interactions (the display-cards procedure provided in poker.ss makes it easier to see the cards; the sample hands are also defined in poker.ss):
Hint: you should not need more than one line for your definition.> (display-cards (sort-hand royal-flush))
"Ah Kh Qh Jh 10h"
> (display-cards (sort-hand ace-higher))
"Ad 10s 8c 7c 3s"
Since the rankings of poker hands don't just depend on the card values, but on having pairs, triples, and quads of a given card, it will be more useful to sort the cards according to first the number of duplicates of each rank, and then by rank. For example, if the hand is Ac Js Jc 7d 4c the procedure sort-by-ranks should produce ((Js Jc) (Ac) (7d) (4c)) since the pair of Jacks are more important than the single A. Note that instead of being just a list of cards, the result is now a list of lists of cards.
The procedure sort-by-ranks is defined:
(define (sort-by-ranks cards) ;;; sorts cards into lists of cards of each rank, ordered by most ;;; cards and highest cards within group (sort (combine-adjacent-matches ;; combine them into lists of matching rank same-rank? (sort-hand cards)) ;; cards sorted by rank (lambda (r1 r2) (if (= (length r1) (length r2)) (higher-card? (car r1) (car r2)) (> (length r1) (length r2)))))
Category | Description | Example |
---|---|---|
Straight Flush | Five cards in sequence all of the same suit | Ks Qs Js 10s 9s |
Four-of-a-Kind ("Quads") | Four cards of the same rank | 3h 3d 3c 3s Jd |
Full House | Three cards of matching rank and two different cards of matching rank | Ac As Ah 7d 7h |
Flush | Five cards of the same suit | Qh 10h 8h 3h 2h |
Straight | Five cards in sequence | 9d 8h 7c 6h 5s |
Wheel Straight | Ace-2-3-4-5 straight | 5d 4h 3c 2h As |
Three-of-a-Kind ("Trips") | Three cards of matching rank | 5d 5h 5c Kh Js |
Two Pair | Two different pairs of matching rank | Jd Jh 5c 5h As |
One Pair | Two cards of matching rank | 8d 8h Ac 7h 3s |
High Card | Anything else | Kd 9h 7c 5h 2s |
(Note: we've listed wheel straight as a separate hand category, even though it is usually listed just as a straight. It is the only straight that can use A as a low card, and the lowest possible straight.)
We have provided the higher-hand? procedure that defines the poker rules:
(define (higher-hand? hand1 hand2) (cond ((straight-flush? hand1) (or (not (straight-flush? hand2)) (and (straight-flush? hand2) (higher-similar-hand? hand1 hand2)))) ((four-of-a-kind? hand1) (or (and (not (straight-flush? hand2)) (not (four-of-a-kind? hand2))) (and (four-of-a-kind? hand2) (higher-similar-hand? hand1 hand2)))) ((full-house? hand1) (or (and (not (straight-flush? hand2)) (not (four-of-a-kind? hand2)) (not (full-house? hand2))) (and (full-house? hand2) (higher-similar-hand? hand1 hand2)))) ((flush? hand1) (and (not (beats-flush? hand2)) (or (and (flush? hand2) (higher-similar-hand? hand1 hand2)) (not (flush? hand2))))) ((wheel-straight? hand1) (not (or (any-straight? hand2) (beats-straight? hand2)))) ((three-of-a-kind? hand1) (and (not (beats-trips? hand2)) (or (and (three-of-a-kind? hand2) (higher-similar-hand? hand1 hand2)) (not (three-of-a-kind? hand2))))) ((three-of-a-kind? hand1) (and (not (beats-trips? hand2)) (or (and (three-of-a-kind? hand2) (higher-similar-hand? hand1 hand2)) (not (three-of-a-kind? hand2))))) ((two-pair? hand1) (and (not (beats-two-pair? hand2)) (or (and (two-pair? hand2) (higher-similar-hand? hand1 hand2)) (not (two-pair? hand2))))) ((one-pair? hand1) (and (not (beats-pair? hand2)) (or (and (one-pair? hand2) (higher-similar-hand? hand1 hand2)) (not (one-pair? hand2))))) (#t (and (not (beats-high-card? hand2)) (higher-similar-hand? hand1 hand2)))))Your job is to define the higher-similar-hand? procedure it uses to compare two hands in the same category.
The rules for comparing poker hands of the same category specify that the most important part of the hand should be compared first. The most important part is the highest card with the highest number of duplicates. If the most important parts are equal, than the next most important part of the hand determines the higher hand. Note that the sort-by-ranks procedure we defined sorts the cards in a hand according to importance, so you can determine the higher hand by considering each element of the list produced by sort-by-ranks in order until you find one that is unequal.
Here are a few examples:
If your procedure is correct, you should get the following interactions:
> (higher-hand? pair-jacks pair-kings)
#f
> (higher-hand? pair-kings pair-jacks)
#t
> (higher-hand? queens-up queens-up)
#f
> (higher-hand? ace-high ace-higher)
#f
> (higher-hand? ace-higher ace-high)
#t
> (higher-hand? kings-full-of-aces kings-full-of-jacks)
#t
To find possible hands, you will find this procedure (defined in poker.ss) useful:
(define (choose-n n lst) ;; parameters: a number n and a list (of at least n elements) ;; result: evaluates to a list of all possible was of choosing n elements from lst (if (= n 0) (list null) (if (= (length lst) n) (list lst) ; must use all elements (append (choose-n n (cdr lst)) ;; all possibilities not using the first element (map (lambda (clst) (cons (car lst) clst)) (choose-n (- n 1) ;;; all possibilities using the first element (cdr lst)))))))
Note that your possible-hands procedure doesn't depend on the elements of the operands being cards. You may find it easier to test by using scalar values instead. For example, (possible-hands (list 1 2) (list 'a 'b 'c 'd 'e)) should evaluate to a list containing these elements (in any order):
((a b c d e) (1 b c d e) (1 a c d e) (1 a b d e) (1 a b c e) (1 a b c d) (2 b c d e) (2 a c d e) (2 a b d e) (2 a b c e) (2 a b c d) (1 2 c d e) (1 2 b d e) (1 2 b c e) (1 2 b c d) (1 2 a d e) (1 2 a c e) (1 2 a c d) (1 2 a b e) (1 2 a b d) (1 2 a b c))
Now that we have a list of all possible hands, we can find the best hand using the higher-hand? procedure.
If your procedure is correct, you should get the following interactions:
For the first hand, both hole cards are used with the three nines to make a full house. For the second hand, the Ace of clubs hole card is used with the four club community cards to make a flush. For the third hand, no hole cards are used and the five community cards make a straight flush.> (display-cards (find-best-hand aces-in-hole trip-nines))
"9d 9c 9s Ah Ad"
> (display-cards (find-best-hand big-slick community-clubs5))
"Ac Qc Jc 7c 5c"
> (display-cards (find-best-hand big-slick royal-flush))
"Ah Kh Qh Jh 10h"
Hint: as in Question 4, you should be able to define this using only one line. Don't worry about efficiency in your definition (for now).
For simplicity, we will assume the player is playing against only one opponent, and has good enough card-reading skills to know the other player's exact hand. (Of course, no real poker player is that good, but in many cases players do have a reasonable guess what cards the other players are holding.)
To analyze a hand, we determine how many of the possible final cards would allow the player to win or draw. The analyze-turn-situation procedure is defined below (and in poker.ss):
(define (accumulate-outs lst) ; lst is a list of triples representingThe analyze-turn-situation procedure determines the cards left in the deck by removing the known hole cards and community cards as current-deck. Then, it uses map to try each possible final card from the current deck. If the final card would allow player 1 to produce a better hand than player 2, it puts that card as the first element in the list; if the hands would be equal, it puts that card as the second element; if player 2 would win, it puts that card as the third element. The accumulate-outs procedure combines all the sublists to form a list of all the winning and chopping outs.cards (if (null? lst) (list null null null) (let ((rest-outs (accumulate-outs (cdr lst)))) (list (append (car (car lst)) (car rest-outs)) (append (car (cdr (car lst))) (car (cdr rest-outs))) (append (car (cdr (cdr (car lst)))) (car (cdr (cdr rest-outs)))))))) (define (analyze-turn-situation hole1 hole2 community) ;; remove all known cards from the deck (let ((current-deck (remove-cards (append hole1 hole2 community) full-deck))) ;; we want to find out how many of the remaining cards produce each result (accumulate-outs (map (lambda (final-card) (let ((outcome (compare-hands? (find-best-hand hole1 (cons final-card community)) (find-best-hand hole2 (cons final-card community))))) (if (eq? outcome 'higher) (list (list final-card) null null) (if (eq? outcome 'equal) (list null (list final-card) null) ; chop (list null null (list final-card)))))) current-deck))))
Here's an example:
To consider the situation after the flop (the first three community cards have been dealt), we need to look at all possibilities for both the fourth and fifth card. The analyze-flop-situation does this:> (show-analysis (analyze-turn-situation connect67 aces-in-hole straight-draw4))
Winning outs (15): 2c 3c 5h 5d 5c 5s 9c 10h 10d 10c 10s Jc Qc Kc Ac
Chopping outs (0):
Losers (29): 2h 2d 2s 3h 3d 3s 4h 4d 4s 6h 6d 6s 7h 7d 7s 8h 8d 8s 9h 9d
Jd Js Qh Qd Qs Kh Kd Ks As three-clubs))
(define (analyze-flop-situation hole1 hole2 community) ;; operands: hole cards for player 1 and play 2 and community cards ;; there must be 2 cards in each players hole cards and 3 community cards ;; result: a list of three elements (winning-outs, chopping-outs, loser) showing ;; the turn and river cards that will lead for the each outcome for player 1. (let ((current-deck (remove-cards (append hole1 hole2 community) full-deck))) ;; we want to find out how many of the remaining cards produce each result (map (lambda (turn-card) (analyze-turn-situation hole1 hole2 (cons turn-card community))) current-deck)))The show-flop-analysis procedure displays a flop analysis in a (barely) human-readable way.
Hint 1: Call and example display-analysis and display-flop-analysis to get a better idea of what is going on.
Hint 2: Phrase your answer in generic terms such as "If analyze-turn-situation takes X seconds, analyze-flop-sitatuion will take ...".
The Loki poker-playing algorithm is described in Using Probabilistic Knowledge and Simulation to Player Poker by Darse Billings, Lourdes Pena, Jonathan Schaeffer, Duane Szafron in AAAI 1999.