For this problem set, you are required to work with an assigned partner. You will receive an email before Wednesday's class containing the partner assignments.

Before starting to work with your partner, you should go through questions 1 and 2 yourself on paper. When you meet with your partner, check if you made the same predicitions. 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 and turn in a single staped document containing both your answers to the questions 1 and 2, and one answer to the rest of the questions with both of your names on it. You should read the whole problem set yourself and think about the questions before beginning to work on them with your partner.

In addition to your partner, you may discuss this assignment with other students in the class and ask and provide help in useful ways. You may consult any outside resources you wish including books, papers, web sites and people except for materials from previous cs150 courses. If you use resources other than the class materials, indicate what you used along with your answer.

You are strongly encouraged to take advantage of the lab hours posted on the cs150 website.

• Practice programming with procedures.
• Become familiar with cons cells and how they can be used to manage complex data.
• Understand recursive procedures.
• Create the beginnings of a poker bot that might win the 2007 World Poker Robot Championships

These robots are much better than the average player ... It would for sure make money online.
Phil Laak, Los Angeles Times, July 18, 2005.

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.

In the game we will consider, Texas Hold 'Em (this is the poker variant 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 hold cards are dealt, and after the third, fourth, and final community cards.

At the end of the hand, each player makes their best five-card hand using as many of their own hole cards as they want and the remaining cards from 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 hold 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.

Becoming Pros at Cons

car element

cdr element

cons cell

Nullifying Null

Scheme provides many useful procedures for manipulating lists. The ones we use in this assignment include:

• (list Expression^*) — evaluates to a list containing the values of all the operand expressions. Evaluating (list 1 2 3) is equivalent to (cons 1 (cons 2 (cons 3 (cons 4 null)))).
• (null? Expression) — evaluates to #t if and only if the operand evaluates to null
• (list? Expression) — evaluates to #t if and only if the operand evaluates to a list.
• (length Expression) — evaluates to the number of elements in the value the operand evaluates to. Produces an error if the operand does not evaluate to a list. Note that null is a list of length 0.
• (append Expression₁ Expression₂) — evaluates to a list containing the elements of the list Expression₁ evaluates to followed by the elements of the list Expression₂ evaluates to. Produces an error if either operand does not evaluate to a list.
• (map Expression₁ Expression₂) — evaluates to a list that contains elements that result from applying the procedure Expression₁ evalutes to, to each elements in the list Expression₂ evaluates to. Produces an error if Expression₁ does not evaluate to a procedure or Expression₂ does not evaluate to a list.
• (sort Expression₁ Expression₂) — evaluates to a list that contains the elements that the list Expression₁ evaluates to, but reordered according to the comparison procedure Expression₂ evaluates to. For sort to make sense, Expression₂ must evaluate to a transitive comparison procedure. That is, if (Expression₂ x y) evaluates to true and (Expression₂ y z) evaluates to true, then (Expression₂ x z) must also evaluate to true. Then, the sorted list will have the least element (according to Expression₂) at the front. (Note that sort takes its parameters in the opposite order of map: the first parameter to map is the procedure, the first parameter to sort is the list.)

After you have predicted how each expression evaluates, remember to meet with your partner and discuss your results. After you have done this, try evaluating them in DrScheme to check your predictions. If any evaluate differently than you expected, explain why DrScheme evaluates the express the way it does.

Representing Cards

   (define (make-card rank suit) (cons rank suit))
   (define card-rank car)
   (define card-suit cdr)

Sorting Hands

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)))))

Ranking Hands

1. It is in a better category of hands (e.g., a flush beats a straight)
2. It is in the same category of hands, but with higher cards

(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)))))
    ((pair? hand1)               (and (not (beats-pair? hand2))
                                      (or (and (pair? hand2) 
					       (higher-similar-hand? hand1 hand2))
                                          (not (pair? hand2)))))
    (#t                          (and (not (beats-high-card? hand2))
                                      (higher-similar-hand? hand1 hand2)))))

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:

• Jenny has Ad Js Jc 3h 3d. Mark has Ks Js Jc 4h 4d. Mark has the higher hand. Both hands are in the category two pair. The most important part of the hand is the higher of the two pairs. Both Jenny and Mark have Jacks. The next most important part of the hand is the lower of the two pairs. Mark has fours, which beat Jenny's threes. The unpaired card doesn't matter, since the lower pair is more important than a single card.
• Anne has Ac Ad As 4s 4c. Dave has Ac Ad 4d 4s 4c. Anne has the higher hand. Both hands are in the category full house. The most important part of the hand is the three-of-a-kind. Anne's Aces beat Dave's fours.
• Greg has Ac Ks 5d 3s 2h. Erin has Ad Ks 5d 4c 2h. Erin has the higher hand. Both players have no pairs or special hands, so the high card wins. The highest card is most important. Both have Aces. The next highest card is next most important, but again they both have Kings. Next, we compare the fives, which again match. The fourth highest card is next most important. Erin's four beats Greg's three, so Erin has the higher hand.
• Alyssa has Ac Kc Qc Jc 10c. Ben has Ad Kd Qd Jd 10d. Neither player has a higher hand. Both players have straight flushes with the highest card an Ace. The hands are equal.

Finding the Monster

To find possible hands, you will find this procedure (defined in poker.scm) 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))))))) 

((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.

After the Turn

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 river cards would allow the player to win or draw. The analyze-turn-situation procedure is defined below (and in poker.scm):

(define (accumulate-outs lst)
  ; lst is a list of triples representing  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 (river-card) 
            (let ((outcome 
		   (compare-hands?
		    (find-best-hand hole1 
				    (cons river-card community))
		    (find-best-hand hole2 
				    (cons river-card community)))))
              (if (eq? outcome 'higher)
                  (list (list river-card) null null)
                  (if (eq? outcome 'equal)
                      (list null (list river-card) null) ; chop
                      (list null null (list river-card))))))
          current-deck))))

Here's an example:

> (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)))