From last article, I demonstrated how to think about program design in functional way.
In this article, I will demonstrate this again using Poker kata. The question is very simple, given two poker hand, determine who is winning.
Start modeling
So at the end, what we need is a function
compare(hand1, hand2) -> Win, Lose, Draw
And we can model a data shape of hand, card as followed:
object Suit extends Enumeration {
type Suit = Value
val Heart = Value("Heart")
val Spade = Value("Spade")
val Club = Value("Club")
val Diamond = Value("Diamond")
}
case class Card(value: Int, suit: Suit.Suit)
type Hand = (Card, Card, Card, Card, Card)
Basically, we just told the compiler that a card is data consists of value as an integer, and a suit which can be either Heart, Spade, Club or Diamond. Then, a hand is a set of 5 cards.
I will represent Jack, Queen, King and Ace with 11, 12, 13 and 14 respectively.
First design
At the end, we want to implement
def comparePokerHand(hand1: Hand, hand2: Hand): CompareResult.CompareResult
Ok. I will be the first to admit that implement comparePokerHand from the get go will be hard and complicated.
So I need to break it down.
Here comes the magic question: What is a data A in such that?
- It is simpler to calculate a hand comparison result from data A.
- It is simpler to calculate data A from each hand.
Creative thinking time.....
...
...
...
Ok, if I have the rank of each hand (Straight, Flush, Two Pairs, etc.) and highs of each hand, then I can simply compare those. I will compare hand power first, and if hand power is the same, then I will compare each highs until the end.
Here is the first breakdown pseudo code.
case class HandPower(rank: HandRank, highs: List[Int])
def comparePokerHand(hand1: Hand, hand2: Hand): CompareResult = {
val handPower1 = handPower(hand1)
val handPower2 = handPower(hand2)
compareHandPower(handPower1, handPower2)
}
Please note that in order to make above statement to be true, the highs must be ordered from the most significant card value to least significant card value.
For example:
Flush(1 3 10 5 4) -> Highs(10 5 4 3 1) // Order from highest value to lowest value
TwoPairs(3 3 5 5 10) -> Highs(5 3 10) // The pairs come first, sorted by higher value, then the non-pair
FullHouse(5 5 5 10 10) -> Highs(5 10) // Three of kind first, then pair
If we have this, then we can easily compare highs by looking at each element one-by-one.
For example:
FullHouse(5 5 5 10 10) lose FullHouse(9 9 9 2 2)
Highs (5 10) lose to Highs(9 2)
5 < 9
Two Pairs(10 10 14 14 4) win TwoPairs(9 9 14 14 5)
Highs(14 10 4) win Highs(14 9 5)
14 == 14
10 > 9
This is how having a data highs with above properties make it easier to determine a winner.
Having this all said, next I need to implement two functions: HandPower and compareHandPower.
I will go through the easier one first: compareHandPower. This function will be implemented according to what I thought
I will compare hand power first, and if hand power is the same, then I will compare each highs until the end.
def compareRank(
handRank1: HandRank.HandRank,
handRank2: HandRank.HandRank
): CompareResult.CompareResult = {
if (handRank1.id < handRank2.id) return CompareResult.Win
if (handRank1.id > handRank2.id) return CompareResult.Lost
CompareResult.Draw
}
def compareHighs(
high1: List[Int],
high2: List[Int]
): CompareResult.CompareResult = {
high1
.zip(high2)
.foldLeft(CompareResult.Draw)((result, pair) => {
if (result != CompareResult.Draw) {
return result
} else if (pair._1 > pair._2) {
return CompareResult.Win
} else if (pair._1 < pair._2) {
return CompareResult.Lost
} else {
return CompareResult.Draw
}
})
}
def compareHandPower(
handPower1: HandPower,
handPower2: HandPower
): CompareResult.CompareResult = {
val rankComparison = compareRank(handPower1.rank, handPower2.rank)
if (rankComparison == CompareResult.Draw) {
return compareHighs(
handPower1.highs,
handPower2.highs
)
}
return rankComparison
}
Easy peasy!! (Hope you find this simple as well). First function done 😄
Then next, the handPower function.
The hand power function must consist of two ability
- Ability to generate rank from hand
- Ability to generate highs from hand
I have to admit that at first, I cannot figure out how to break it down.
So I start with a very simple and naive question: How can I determine if this hand is a four card hand?
The answer is simple: I need to check if any card value occurs four times within a hand. That means I need to determine the frequencies of each card value.
So I start implemented a freqMap like this:
val freqMap =
hand.foldLeft(Map[Int, Int]())((acc, card: Card) => {
acc.get(card.value) match {
case None => acc + (card.value -> 1)
case Some(currentFreq) => acc + (card.value -> (currentFreq + 1))
}
})
Basically, freqMap is a map between card value and card frequency.
With this, I can write the logic for four cards to be
if (freqMap.exists(keyValuePair => {
val cardFrequency = keyValuePair._2
cardFrequency == 4
})) {
return HandPower(HandRank.FourCard, highs)
}
Ok. Now I can check four cards. Let's check for the full house.
if (
freqMap.exists(keyValuePair => {
val cardFrequency = keyValuePair._2
cardFrequency == 3
}) && freqMap.exists(keyValuePair => {
val cardFrequency = keyValuePair._2
cardFrequency == 2
})
) {
return HandPower(HandRank.Fullhouse, highs)
}
Now I realize that things start to get messy and duplicates.
Back to the core question: Is there any data A that will make our life easier?
Answer: Yes. If we have data A that is a list of frequencies of each card value sorted, we can easily determine many card ranks.
How? I think it is easier to show you by this code:
cardFrequenciesPattern match {
case 1 :: 4 :: Nil => return HandPower(HandRank.FourCard, highs)
case 2 :: 3 :: Nil => return HandPower(HandRank.Fullhouse, highs)
case 1 :: 1 :: 3 :: Nil => return HandPower(HandRank.ThreeOfKind, highs)
case 1 :: 2 :: 2 :: Nil => return HandPower(HandRank.TwoPairs, highs)
case 1 :: 1 :: 1 :: 2 :: Nil =>
return HandPower(HandRank.OnePair, highs)
case _ => {
// Something
}
}
You can see that if a cardFrequenciesPattern exists, and it is a frequencies of each card value sorted, we can easily match it to a corresponding pattern.
So the data A for this case is cardFrequenciesPatter.
I wrote a transformation from current freqMap to easier cardFrequenciesPattern as followed:
val cardFrequenciesPattern = freqMap.values.toList.sorted
What's left for me is to write some if-else for straight, flush and nothing in the last case.
Since we were able to determine a rank, let us determine highs.
Definition: highs is a list of card values in hand, ordered from the most significant card value to least significant card value.
I notice that the most significant card values in any hand are also the most frequent card in hand. For example: In full house hand, three kinds of cards are considered to be more significant than a pair of cards.
So the logic could be order card values based on frequency first, then order by the values itself.
And since we already have a map of card frequency and card value, then here it is:
val highs = freqMap.toSeq
.sortWith((pair1, pair2) => {
val cardVal1 = pair1._1
val cardVal2 = pair2._1
val cardFreq1 = pair1._2
val cardFreq2 = pair2._2
if (cardFreq1 == cardFreq2) {
cardVal1 > cardVal2
} else {
cardFreq1 > cardFreq2
}
})
.map(_._1)
.toList
Surprisingly, the intermediate freqMap data make it very easy to determine both highs and rank.
Now we got everything: We have a function to create a hand power from a hand. We have a function to compare two hand power. That's mean we solved Poker Kata.
Done deal! 🎉🎉
Full implementation in Scala: https://github.com/chrisza4/scala-poker-kata
Full implementation in Clojure: https://github.com/chrisza4/clojure-poker-kata
Recap and Lesson
In this article, I demonstrate the thought process and program design that repeatedly ask a simple question: Is there data A?
And by asking ourselves this question, we found that:
- Intermediate data
HandPowermake it way easier to compare poker hand easier. - Intermediate data
freqMapmake it way easier to both create a rank and highs. - Intermediate data
cardFrequenciesPatternmake it way easier to determine a card rank
This is the functional thinking. That is how we breakdown a problem in a functional paradigm. This is what it means to "write more functions".
Again, as I wrote in the previous article, this thinking and thought process line is useful even if you write a program in an imperative or object-oriented paradigm.
So I hope this article is useful for every programmer.
Thanks for reading!!
Top comments (0)