Scala: Detecting a Straight in a 5-card Poker hand using pattern matching

For those who don't know what a 5-card Poker Straight开发者_C百科 is: http://en.wikipedia.org/wiki/List_of_poker_hands#Straight

I'm writing a small Poker simulator in Scala to help me learn the language, and I've created a Hand class with 5 ordered Cards in it. Each Card has a Rank and Suit, both defined as Enumerations. The Hand class has methods to evaluate the hand rank, and one of them checks whether the hand contains a Straight (we can ignore Straight Flushes for the moment). I know there are a few nice algorithms for determining a Straight, but I wanted to see whether I could design something with Scala's pattern matching, so I came up with the following:

def isStraight() = {
  def matchesStraight(ranks: List[Rank.Value]): Boolean = ranks match {
    case head :: Nil  => true
    case head :: tail if (Rank(head.id + 1) == tail.head) => matchesStraight(tail)
    case _ => false
  }

  matchesStraight(cards.map(_.rank).toList)
}

That works fine and is fairly readable, but I was wondering if there is any way to get rid of that if. I'd imagine something like the following, though I can't get it to work:

private def isStraight() = {
  def matchesStraight(ranks: List[Rank.Value]): Boolean = ranks match {
    case head :: Nil  => true
    case head :: next(head.id + 1) :: tail => matchesStraight(next :: tail)
    case _ => false
  }

  matchesStraight(cards.map(_.rank).toList)
}

Any ideas? Also, as a side question, what is the general opinion on the inner matchesStraight definition? Should this rather be private or perhaps done in a different way?

You can't pass information to an extractor, and you can't use information from one value returned in another, except on the if statement -- which is there to cover all these cases.

What you can do is create your own extractors to test these things, but it won't gain you much if there isn't any reuse.

For example:

class SeqExtractor[A, B](f: A => B) {
  def unapplySeq(s: Seq[A]): Option[Seq[A]] =
    if (s map f sliding 2 forall { case Seq(a, b) => a == b  } ) Some(s)
    else None
}

val Straight = new SeqExtractor((_: Card).rank)

Then you can use it like this:

listOfCards match {
    case Straight(cards) => true
    case _ => false
}

But, of course, all that you really want is that if statement in SeqExtractor. So, don't get too much in love with a solution, as you may miss simpler ways of doing stuff.

You could do something like:

val ids = ranks.map(_.id)
ids.max - ids.min == 4 && ids.distinct.length == 5

Handling aces correctly requires a bit of work, though.

Update: Here's a much better solution:

(ids zip ids.tail).forall{case (p,q) => q%13==(p+1)%13}

The % 13 in the comparison handles aces being both rank 1 and rank 14.

How about something like:

def isStraight(cards:List[Card]) = (cards zip cards.tail) forall { case (c1,c2) => c1.rank+1 == c2.rank}

val cards = List(Card(1),Card(2),Card(3),Card(4))

scala> isStraight(cards)
res2: Boolean = true

This is a completely different approache, but it does use pattern matching. It produces warnings in the match clause which seem to indicate that it shouldn't work. But it actually produces the correct results:

Straight !!! 34567
Straight !!! 34567
Sorry no straight this time

I ignored the Suites for now and I also ignored the possibility of an ace under a 2.

abstract class Rank {
    def value : Int
}
case class Next[A <: Rank](a : A) extends Rank {
    def value = a.value + 1
}
case class Two() extends Rank {
    def value = 2
}

class Hand(a : Rank, b : Rank, c : Rank, d : Rank, e : Rank) {
    val cards = List(a, b, c, d, e).sortWith(_.value < _.value)
}

object Hand{
    def unapply(h : Hand) : Option[(Rank, Rank, Rank, Rank, Rank)] = Some((h.cards(0), h.cards(1), h.cards(2), h.cards(3), h.cards(4)))
}

object Poker {

    val two = Two()
    val three = Next(two)
    val four = Next(three)
    val five = Next(four)
    val six = Next(five)
    val seven = Next(six)
    val eight = Next(seven)
    val nine = Next(eight)
    val ten = Next(nine)
    val jack = Next(ten)
    val queen = Next(jack)
    val king = Next(queen)
    val ace = Next(king)

    def main(args : Array[String]) {
        val simpleStraight = new Hand(three, four, five, six, seven)
        val unsortedStraight = new Hand(four, seven, three, six, five)
        val notStraight = new Hand (two, two, five, five, ace)

        printIfStraight(simpleStraight)
        printIfStraight(unsortedStraight)
        printIfStraight(notStraight)
    }

    def printIfStraight[A](h : Hand) {

        h match  {
            case  Hand(a: A , b : Next[A], c : Next[Next[A]], d : Next[Next[Next[A]]], e : Next[Next[Next[Next[A]]]]) => println("Straight !!! " + a.value + b.value + c.value + d.value + e.value)
            case Hand(a,b,c,d,e)  => println("Sorry no straight this time")
        }
    }
}

If you are interested in more stuff like this google 'church numerals scala type system'

How about something like this?

def isStraight = {
  cards.map(_.rank).toList match {
    case first :: second :: third :: fourth :: fifth :: Nil if 
      first.id == second.id - 1 &&
      second.id == third.id - 1 &&
      third.id == fourth.id - 1 &&
      fourth.id == fifth.id - 1 => true
    case _ => false
  }
}

You're still stuck with the if (which is in fact larger) but there's no recursion or custom extractors (which I believe you're using incorrectly with next and so is why your second attempt doesn't work).

If you're writing a poker program, you are already check for n-of-a-kind. A hand is a straight when it has no n-of-a-kinds (n > 1) and the different between the minimum denomination and the maximum is exactly four.

I was doing something like this a few days ago, for Project Euler problem 54. Like you, I had Rank and Suit as enumerations.

My Card class looks like this:

  case class Card(rank: Rank.Value, suit: Suit.Value) extends Ordered[Card] {
    def compare(that: Card) = that.rank compare this.rank
  }

Note I gave it the Ordered trait so that we can easily compare cards later. Also, when parsing the hands, I sorted them from high to low using sorted, which makes assessing values much easier.

Here is my straight test which returns an Option value depending on whether it's a straight or not. The actual return value (a list of Ints) is used to determine the strength of the hand, the first representing the hand type from 0 (no pair) to 9 (straight flush), and the others being the ranks of any other cards in the hand that count towards its value. For straights, we're only worried about the highest ranking card.

Also, note that you can make a straight with Ace as low, the "wheel", or A2345.

  case class Hand(cards: Array[Card]) {
    ...
    def straight: Option[List[Int]] = {

      if( cards.sliding(2).forall { case Array(x, y) => (y compare x) == 1 } )
        Some(5 :: cards(0).rank.id :: 0 :: 0 :: 0 :: 0 :: Nil)

      else if ( cards.map(_.rank.id).toList == List(12, 3, 2, 1, 0) )
        Some(5 :: cards(1).rank.id :: 0 :: 0 :: 0 :: 0 :: Nil) 

      else None
    }
  }

Here is a complete idiomatic Scala hand classifier for all hands (handles 5-high straights):

case class Card(rank: Int, suit: Int) { override def toString = s"${"23456789TJQKA" rank}${"♣♠♦♥" suit}" }

object HandType extends Enumeration {
  val HighCard, OnePair, TwoPair, ThreeOfAKind, Straight, Flush, FullHouse, FourOfAKind, StraightFlush = Value
}

case class Hand(hand: Set[Card]) {
  val (handType, sorted) = {
    def rankMatches(card: Card) = hand count (_.rank == card.rank)
    val groups = hand groupBy rankMatches mapValues {_.toList.sorted}

    val isFlush = (hand groupBy {_.suit}).size == 1
    val isWheel = "A2345" forall {r => hand exists (_.rank == Card.ranks.indexOf(r))}   // A,2,3,4,5 straight
    val isStraight = groups.size == 1 && (hand.max.rank - hand.min.rank) == 4 || isWheel
    val (isThreeOfAKind, isOnePair) = (groups contains 3, groups contains 2)

    val handType = if (isStraight && isFlush)     HandType.StraightFlush
      else if (groups contains 4)                 HandType.FourOfAKind
      else if (isThreeOfAKind && isOnePair)       HandType.FullHouse
      else if (isFlush)                           HandType.Flush
      else if (isStraight)                        HandType.Straight
      else if (isThreeOfAKind)                    HandType.ThreeOfAKind
      else if (isOnePair && groups(2).size == 4)  HandType.TwoPair
      else if (isOnePair)                         HandType.OnePair
      else                                        HandType.HighCard

    val kickers = ((1 until 5) flatMap groups.get).flatten.reverse
    require(hand.size == 5 && kickers.size == 5)
    (handType, if (isWheel) (kickers takeRight 4) :+ kickers.head else kickers)
  }
}

object Hand {
  import scala.math.Ordering.Implicits._
  implicit val rankOrdering = Ordering by {hand: Hand => (hand.handType, hand.sorted)}
}