Poker! In order to solve problem 54, we need to basically model a poker hand and compute the strength of it relative to another hand.

I was surprised at how concisely the game of poker could be modeled in Clojure. Most of the work is done in a few `let`

statements, followed by a small amount of branching logic. A more complete implementation of poker would probably require better management of a deck, as well as perhaps a better representation of a the data describing a card. A two-character string is a perhaps a little awkward to use at times.

```
use '[clojure.contrib.duck-streams :only (read-lines)])
(def card-nums (zipmap "23456789TJQKA" (iterate inc 2)))
(def card-suits (set "HDSC"))
(defn card-val [c] (card-nums (first c)))
(def hand-rank (zipmap [:straight-flush
:four-of-a-kind
:full-house
:flush
:straight
:three-of-a-kind
:two-pairs
:pair
:high-card] (range)))
(defn hand
"Returns the type of the hand and a list of the card groups."
[cards]
(let [cs (sort #(> (card-val %1) (card-val %2)) cards)
ns (into (sorted-set) (map #(card-val %) cs))
straight? (and (= 5 (count ns)) (= 4 (- (last ns) (first ns))))
flush? (apply = (map second cards))
groups (sort #(> (count %1) (count %2))
(vals (group-by #(card-val %) cs)))
g1 (count (first groups))
g2 (count (second groups))
hand-type (cond
(and straight? flush?) :straight-flush
(= 4 g1) :four-of-a-kind
(and (= 3 g1) (= 2 g2)) :full-house
flush? :flush
straight? :straight
(= 3 g1) :three-of-a-kind
(and (= 2 g1) (= 2 g2)) :two-pairs
(= 2 g1) :pair
:else :high-card)]
[hand-type groups]))
(defn break-tie
"Assuming that g1 and g2 represent the same type of hand (eg: full house),
returns the outcome for the g1 hand (:win, :lose, or rarely :tie)"
[g1 g2]
(let [a (first (first g1))
b (first (first g2))]
(if (or (nil? a) (nil? b))
:tie
(cond
(> (card-val a) (card-val b)) :win
(< (card-val a) (card-val b)) :lose
:else (recur (next g1) (next g2))))))
(defn i-win? [me you]
(let [[tm gm] (hand me)
[ty gy] (hand you)]
(cond
(< (hand-rank tm) (hand-rank ty)) :win
(> (hand-rank tm) (hand-rank ty)) :lose
:else (break-tie gm gy))))
(defn euler-53 [file]
(count
(for [line (read-lines file)
[me you] [(split-at 5 (re-seq #"\S+" line))]
:when (= (i-win? me you) :win)]
:win)))
(time (euler-53 "/path/to/poker.txt"))
```

That solves the problem, but we can’t stop there! Let’s just use a brute-force approach to compute the probability of a given hand beating n opponents in a random 5-card no-draw game of poker. Let’s start by adding some functionality for a deck of cards. It wouldn’t make much sense if you could get the same cards as your opponent!

```
(def plain-deck (for [n "23456789TJQKA"
suit "DHCS"]
(apply str (str n) (str suit))))
(defn take-n-hands [n deck]
{:pre [(< (* n 5) (count deck))]}
(loop [r []
d (shuffle deck)]
(if (>= (count r) n)
[r d]
(recur (conj r (take 5 d)) (shuffle (drop 5 d))))))
(defn test-2-players [_]
(let [[hs deck] (take-n-hands 2 plain-deck)
[a b] hs]
(i-win? a b)))
(frequencies (map test-2-players (range 100000))) ;; Wins about 50% of the time
```

Now we can define a hand for ourselves, and compute the probability that we will defeat 3 opponents in a no-draw, simplest-poker-possible kind of situation:

```
(def my-hand ["2C" "3S" "8S" "8D" "TD"])
(defn frequencies-i-win [my-cards other-players trials]
(frequencies
(for [d [(remove (into #{} my-hand) plain-deck)]
t (range trials)
[others _] [(take-n-hands other-players d)]]
(if (every? #(= :win %) (map #(i-win? my-cards %) others))
:win
:lose))))
(defn probability-i-win [my-cards other-players trials]
(let [fs (frequencies-i-win my-cards other-players trials)
w (if-let [wins (:win fs)] wins 0 )
l (if-let [losses (:lose fs)] losses 0)]
(str (* 100.0 (/ w trials)) "% chance of win")))
(probability-i-win my-hand 1 100000) ;; "69.878% chance of win"
```

I imagine that a human-machine combination such as this – one in which a computer could help you evaluate the mathematical strength of your hand – would be very useful for improving your understanding of the strength of a particular hand.

Of course, the real magic of poker is in the betting strategy, and any simple computer algorithm I could implement here would doubtlessly do poorly against all but the most inexperienced of beginners.

Still, it might be fun to expand on this later, add a GUI, and some logic for Texas Hold ‘em.