Poker Hand Evaluator in Haskell

Sep 27 2020

Die Idee ist, eine Hand als eine Liste von Karten darzustellen und eine Frequenzzuordnung zu erstellen, die dann verwendet werden kann, um Ihren Handrang zu identifizieren und Ihre Hand so anzuordnen, dass die Ord-Typ-Klasse Hände derselben vergleichen kann Rang.

Meine Lösung fühlt sich etwas umständlich an, aber dies ist viel schöner als alles, was ich unbedingt hätte schreiben können, da die Bewertung der Pokerhand im Allgemeinen etwas umständlich ist.

card.hs

module Card
(Card(..), Suit(..), Rank(..), rankVal) where

data Card = Card Suit Rank

data Suit = 
      Spades 
    | Hearts 
    | Clubs 
    | Diamonds
    deriving (Show, Eq, Enum, Bounded)

data Rank = 
      Two
    | Three 
    | Four 
    | Five 
    | Six 
    | Seven 
    | Eight 
    | Nine 
    | Ten 
    | Jack 
    | Queen 
    | King 
    | Ace
    deriving (Show, Eq, Ord, Enum, Bounded)

instance Eq Card where 
    Card _ rank1 == Card _ rank2 = rank1 == rank2

instance Ord Card where 
    Card _ rank1 `compare` Card _ rank2 = rank1 `compare` rank2

instance Show Card where 
    show (Card suit rank) = "(" ++ (show suit) ++ ", " ++ (show rank) ++ ")"

rankVal :: Rank -> Int
rankVal Two = 2
rankVal Three = 3
rankVal Four = 4
rankVal Five = 5
rankVal Six = 6
rankVal Seven = 7
rankVal Eight = 8
rankVal Nine = 9
rankVal Ten = 10
rankVal Jack = 10
rankVal Queen = 10
rankVal King = 10
rankVal Ace = 11

solver.hs

module Hand
(Card(..), Suit(..), Rank(..), compareHands) where

import Card
import Data.List

--TODO Add tests for every function

type Hand = [Card]

-- Cards arranged such that `compare` will return which hand is better
type RelativeRank = [Card]

-- A mapping between an element in a list and it's frequency
-- For example, [1, 2, 2, 2, 2] is [(1,1),(2,4),(2,4),(2,4),(2,4)]
type FreqMapping a = [(a, Int)]

data HandRank = 
      HighCard 
    | Pair
    | TwoPairs 
    | ThreeOfKind
    | Straight
    | Flush
    | FullHouse 
    | FourOfKind 
    | StraightFlush
    | RoyalFlush 
  
    deriving (Show, Eq, Ord, Enum, Bounded)

compareHands :: Hand -> Hand -> Ordering
compareHands hand1 hand2 = (handRank1, relativeRank1) `compare` (handRank2, relativeRank2)

    where relativeRank1 = computeRelativeRank hand1 handRank1
          relativeRank2 = computeRelativeRank hand2 handRank2
          handRank1 = computeHandRank hand1
          handRank2 = computeHandRank hand2

maxVal :: Hand -> Int
maxVal = foldr (\(Card _ rank) acc -> max acc $ rankVal rank) 0 isStraight :: Hand -> Bool isStraight = isStraightHelper . sort isStraightHelper :: Hand -> Bool isStraightHelper [] = True isStraightHelper [x] = True isStraightHelper (card1:card2:xs) = isValidStep && isStraightHelper (card2:xs) where isValidStep = 1 + rankVal rank1 == rankVal rank2 (Card _ rank1) = card1 (Card _ rank2) = card2 isFlush :: Hand -> Bool isFlush (x:xs) = (replicate len $ suit x) == (map suit (x:xs))
    where suit = (\(Card suit _) -> suit)
          len = length (x:xs)

computeHandRank :: Hand -> HandRank
computeHandRank xs 
    | flush && straight && maxVal xs == 12 = RoyalFlush
    | flush && straight                    = StraightFlush
    | freqList == [1, 4, 4, 4, 4]          = FourOfKind
    | freqList == [2, 2, 3, 3, 3]          = FullHouse
    | flush                                = Flush
    | straight                             = Straight
    | freqList == [1, 1, 3, 3, 3]          = ThreeOfKind
    | freqList == [1, 2, 2, 2, 2]          = TwoPairs
    | freqList == [1, 1, 1, 2, 2]          = Pair
    | otherwise                            = HighCard
   
    where straight = isStraight xs
          flush = isFlush xs
          freqList = sort $ map snd $ computeFreqMapping xs 

-- Used to compare hands of the same rank 
computeRelativeRank :: Hand -> HandRank -> RelativeRank
computeRelativeRank xs handRank 
    | handRank == RoyalFlush    = []
    | handRank == StraightFlush = revSort xs
    | handRank == FourOfKind    = valsAtFreq 4 freqs ++ valsAtFreq 1 freqs
    | handRank == FullHouse     = valsAtFreq 3 freqs ++ valsAtFreq 2 freqs
    | handRank == Flush         = revSort xs
    | handRank == Straight      = revSort xs
    | handRank == ThreeOfKind   = valsAtFreq 3 freqs ++ (revSort $ valsAtFreq 1 freqs) | handRank == TwoPairs = (maximum $ valsAtFreq 2 freqs) : (minimum $ valsAtFreq 2 freqs) : (valsAtFreq 1 freqs) | handRank == Pair = valsAtFreq 2 freqs ++ (revSort $ valsAtFreq 1 freqs)
    | handRank == HighCard      = revSort xs

    where freqs = computeFreqMapping xs 

computeFreqMapping :: (Eq a) => [a] -> FreqMapping a
computeFreqMapping xs = map (\elem -> (elem, elemCount elem xs)) xs

-- Return number of times an element appears in a list
elemCount :: (Eq a) => a -> [a] -> Int
elemCount elem = length . filter (elem==)

--Return set of all values that appear at a given frequency in the freqency mapping
valsAtFreq :: (Ord a) => Int -> FreqMapping a -> [a]
valsAtFreq freq xs = [fst x | x <- xs, snd x == freq]

revSort :: (Ord a) => [a] -> [a]
revSort = reverse . sort
```

Antworten

3 Andrew Sep 27 2020 at 20:54

Nur ein paar Ideen - erfolgreich zusammengestellt, nicht weiter getestet.

Rekord - Syntax liefert die Funktionen suit, rankfür „frei“, dh

data Card = Card { suit :: Suit
                 , rank :: Rank }

ermöglicht kürzere Definitionen:

instance Eq Card where 
    c1 == c2 = rank c1 == rank c2

instance Ord Card where 
    c1 `compare` c2 = rank c1 `compare` rank c2

In ähnlicher Weise werden die folgenden drei Funktionen klarer.

maxVal :: Hand -> Int
maxVal = maximum . map (rankVal . rank)

isStraight :: Hand -> Bool
isStraight hand = [head sortedRanks .. last sortedRanks] == sortedRanks
    where sortedRanks = sort . map rank $ hand

isFlush :: Hand -> Bool
isFlush = (1==) . length . nub . map suit

Für mich computeRelativeRankfordert ein case expression.

computeRelativeRank :: Hand -> HandRank -> RelativeRank
computeRelativeRank xs handRank = case handRank of
     RoyalFlush    -> []
     StraightFlush -> revSort xs
     FourOfKind    -> valsAtFreq 4 freqs ++ valsAtFreq 1 freqs
     FullHouse     -> valsAtFreq 3 freqs ++ valsAtFreq 2 freqs
     Flush         -> revSort xs
     Straight      -> revSort xs
     ThreeOfKind   -> valsAtFreq 3 freqs ++ (revSort $ valsAtFreq 1 freqs)
     TwoPairs      -> (maximum $ valsAtFreq 2 freqs) : (minimum $ valsAtFreq 2 freqs) : (valsAtFreq 1 freqs)
     Pair          -> valsAtFreq 2 freqs ++ (revSort $ valsAtFreq 1 freqs)
     HighCard      -> revSort xs
    where freqs = computeFreqMapping xs 

Ich würde die Anzahl der Elemente mit a zählen Map.

import qualified Data.Map.Strict as M

computeFreqMapping :: (Ord a) => [a] -> FreqMapping a
computeFreqMapping = M.toList . foldl incrementCounter M.empty
    where incrementCounter m k = M.insertWith (+) k 1 m

Tatsächlich könnte die gesamte Frequenzabbildung mit solchen Abbildungen durchgeführt werden - die Sortierung erfolgt auf diese Weise automatisch. Wenn Sie so geneigt sind, werfen Sie einen Blick auf die Dokumentation - vor allem die Funktionen keys, elems.