Five-Card Poker Hand Comparison Using C#

Posted on February 23, 2024 by jamesdmccaffrey

A few days ago I put together a C# program that creates and classifies five-card poker hands. For example, the hand “Ac As Kh Kd 7c” is “TwoPair”. See the blog post at https://jamesmccaffreyblog.com/2024/02/02/five-card-poker-hand-classification-using-csharp/.

My classification demo has ten possible hand types: “RoyalFlush”, “StraightFlush”, “FourKind”, “FullHouse”, “Flush” , “Straight”, “ThreeKind”, “TwoPair”, “OnePair”, “HighCard”.

My next challenge was to implement a function that compares two five-card hands. This is far more difficult than you might imagine. I created a Hand.Compare(h1, h2) function that compares hands h1 and h2. The function returns -1 if h1 is less than h2, +1 if h1 is greater than h2, and 0 if h1 is equal to h2 (in terms of poker hand ranking).

If two hands have different classification types then the comparison is easy. For example, if h1 is “FullHouse” and h2 is “TwoPair” then hand h1 is greater than hand h2.

The tricky part is dealing with two hands that have the same classification types. For example, if h1 = “9d Js Jc Qh As” (“OnePair”) and h2 = “4d 5s Kc Kd Ah” (“OnePair”) then you must find what the pair is in each hand, but also the other three cards to compare in case the pairs in the two hands are the same.

Therefore, I had to write nine helper functions with names like BreakTieFlush() and BreakTieTwoPair(). The only hand type that didn’t need a tie-breaker is “RoyalFlush” because two royal flush hands are always equal, poker-wise.

Because the logic of comparing two poker hands is so tricky, I coded up a function to test the Hand.Compare(h1, h2) function. I created a file of test cases that looks like:

. . .
4s5d6d7d8d,4s5d6d7d8d,4,4,0, optional comment
5c6c7c8s9c,4s5d6d7d8d,4,4,1
2s5c5d5hKs,9dTdJsQhKc,3,4,-1
. . .

The comma-separated fields are Hand1, Hand2, type of Hand1 (0 = High Card, . . 9 = Royal Flush), type of Hand2, result of comparison (-1 if h1 less-than h2, +1 if h1 greater-than h2, 0 is h1 equal h2). The test cases are listed below the demo code.

I probably know less about women’s makeup than any human on the planet. Here are three images. Two of them were found by an Internet image search for “poker makeup”. One of the images was made by the DALL-E image generator. Can you spot it? Hint: look at the cards in the center image.

Demo code. Replace “lt” (less-than), “gt”, “lte”, “gte”, “and” with Boolean operator symbols.

using System;
using System.IO;
using System.Collections.Generic;

namespace Poker
{
  internal class PokerProgram
  {
    static void Main(string[] args)
    {
      Console.WriteLine("\nBegin five-card poker" +
        " hand comparison ");

      string hs = "Ac3d7hAs5h";
      Console.Write("\nHand string = ");
      Console.WriteLine(hs);
      Hand h = new Hand(hs);
      Console.Write("Hand object: ");
      Console.WriteLine(h);

      Hand h1 = new Hand("4c7c7s7cAd"); // 3-kind 7s
      Hand h2 = new Hand("TdTcThJhKs"); // 3-kind 10s

      int cmp = Hand.Compare(h1, h2);
      if (cmp == -1)
        Console.WriteLine(h1 + " less than " + h2);
      else if (cmp == +1)
        Console.WriteLine(h1 + " greater than " + h2);
      else if (cmp == 0)
        Console.WriteLine(h1 + " equal to " + h2);

      Console.WriteLine("\nRunning automated tests ");
      string testFileCompare =
        "..\\..\\..\\Data\\poker_compare.txt";
      TestHandCompare(testFileCompare);

      Console.WriteLine("\nEnd ");
      Console.ReadLine();
    } // Main

    // ------------------------------------------------------

    static void TestHandCompare(string fn)
    {
      FileStream ifs = new FileStream(fn, FileMode.Open);
      StreamReader sr = new StreamReader(ifs);
      string line = "";
      while ((line = sr.ReadLine()) != null)
      {
        if (line.StartsWith("#")) continue;
        string hs1 = line.Split(',')[0];
        string hs2 = line.Split(',')[1];
        int expectedClass1 = 
          int.Parse(line.Split(',')[2]);
        int expectedClass2 = 
          int.Parse(line.Split(',')[3]);
        int expectedComparison = 
          int.Parse(line.Split(',')[4]);

        Hand h1 = new Hand(hs1);
        Hand h2 = new Hand(hs2);
        int computedComparison = Hand.Compare(h1, h2);
        int computedClass1 = h1.GetHandTypeInt();
        int computedClass2 = h2.GetHandTypeInt();

        if (expectedClass1 != computedClass1)
        {
          Console.WriteLine(line);
          Console.WriteLine("computed class 1 !=" +
           " expected class 1");
          Console.ReadLine();
        }
        if (expectedClass2 != computedClass2)
        {
          Console.WriteLine(line);
          Console.WriteLine("computed class 2 !=" +
           " expected class 2");
          Console.ReadLine();
        }

        Console.WriteLine("\ninput: " + hs1 + " " + hs2);
        Console.WriteLine("computed: " + 
          computedComparison);
        Console.WriteLine("expected: " + 
          expectedComparison);

        if (computedComparison == expectedComparison)
          Console.WriteLine("pass");
        else
        {
          Console.WriteLine("FAIL");
          Console.ReadLine();
        }
      }
      sr.Close(); ifs.Close();
    } // TestHandCompare()

  } // Program

  public class Card : IComparable"lt"Card"gt"
  {
    // 0,1 not used. 11=J, 12=Q, 13=K, 14=A
    public int rank; 
    // 0=clubs, 1=diamonds, 2=hearts, 3=spades
    public int suit; 

    public Card(int rank, int suit)
    {
      this.rank = rank; this.suit = suit;
    }

    public Card(string c)
    {
      char rnk = c[0]; char sut = c[1];
      if (rnk == 'T') this.rank = 10;
      else if (rnk == 'J') this.rank = 11;
      else if (rnk == 'Q') this.rank = 12;
      else if (rnk == 'K') this.rank = 13;
      else if (rnk == 'A') this.rank = 14;
      else this.rank = int.Parse(rnk.ToString());

      if (sut == 'c') this.suit = 0;
      else if (sut == 'd') this.suit = 1;
      else if (sut == 'h') this.suit = 2;
      else if (sut == 's') this.suit = 3;
    }

    public override string ToString()
    {
      string rnk = ""; string sut = "";
      if (this.rank == 10) rnk = "T";
      else if (this.rank == 11) rnk = "J";
      else if (this.rank == 12) rnk = "Q";
      else if (this.rank == 13) rnk = "K";
      else if (this.rank == 14) rnk = "A";
      else rnk = this.rank.ToString();

      if (this.suit == 0) sut = "c";
      else if (this.suit == 1) sut = "d";
      else if (this.suit == 2) sut = "h";
      else if (this.suit == 3) sut = "s";

      return rnk + sut;
    }

    public int CompareTo(Card other)
    {
      // sort cards in a hand from low (Two) to high (Ace)
      if (this.rank.CompareTo(other.rank) == 0)
      {
        return this.suit.CompareTo(other.suit);
      }
      return this.rank.CompareTo(other.rank);
    }

  } // class Card

  // --------------------------------------------------------

  public class Hand
  {
    // 5-card poker hand
    // Hand types: "RoyalFlush", "StraightFlush",
    // "FourKind", "FullHouse", "Flush" , "Straight",
    // "ThreeKind", "TwoPair", "OnePair", "HighCard"

    public List"lt"Card"gt" cards;

    public Hand(List"lt"Card"gt" lst)
    {
      this.cards = new List"lt"Card"gt"();
      for (int i = 0; i "lt" 5; ++i)
        this.cards.Add(lst[i]);
      this.cards.Sort();
    }
    
    public Hand(Card c1, Card c2, Card c3,
      Card c4, Card c5)
    {
      this.cards = new List"lt"Card"gt"();
      this.cards.Add(c1); this.cards.Add(c2);
      this.cards.Add(c3); this.cards.Add(c4);
      this.cards.Add(c5);
      this.cards.Sort();
    }

    public Hand(string s) // s like "Js3h7d7cAd"
    {
      this.cards = new List"lt"Card"gt"();
      this.cards.Add(new Card(s.Substring(0, 2)));
      this.cards.Add(new Card(s.Substring(2, 2)));
      this.cards.Add(new Card(s.Substring(4, 2)));
      this.cards.Add(new Card(s.Substring(6, 2)));
      this.cards.Add(new Card(s.Substring(8, 2)));
      this.cards.Sort();
    }

    public override string ToString()
    {
      string h = "";
      for (int i = 0; i "lt" 4; ++i)
        h += this.cards[i].ToString() + "-";
      h += this.cards[4];
      return h;
    }

    public string ToTerseString()
    {
      string h = "";
      for (int i = 0; i "lt" 4; ++i)
        h += this.cards[i].ToString();
      h += this.cards[4];
      return h;
    }

    // ------------------------------------------------------

    // Hand Type methods:
    // GetHandTypeStr(), GetHandTypeInt(),
    //
    // IsRoyalFlush(), IsStraightFlush(), 
    // IsFourKind(), IsFullHouse(), IsFlush(),
    // IsStraight(), IsThreeKind(), IsTwoPair(),
    // IsOnePair(), IsHighCard()
    //
    // helpers: HasFlush(), HasStraight(),


    // ------------------------------------------------------

    public string GetHandTypeStr()
    {
      if (IsRoyalFlush(this) == true)
        return "RoyalFlush";
      else if (IsStraightFlush(this) == true)
        return "StraightFlush";
      else if (IsFourKind(this) == true)
        return "FourKind";
      else if (IsFullHouse(this) == true)
        return "FullHouse";
      else if (IsFlush(this) == true)
        return "Flush";
      else if (IsStraight(this) == true)
        return "Straight";
      else if (IsThreeKind(this) == true)
        return "ThreeKind";
      else if (IsTwoPair(this) == true)
        return "TwoPair";
      else if (IsOnePair(this) == true)
        return "OnePair";
      else if (IsHighCard(this) == true)
        return "HighCard";
      else
        return "Unknown";
    }

    // ------------------------------------------------------

    public int GetHandTypeInt()
    {
      if (IsRoyalFlush(this) == true)
        return 9;
      else if (IsStraightFlush(this) == true)
        return 8;
      else if (IsFourKind(this) == true)
        return 7;
      else if (IsFullHouse(this) == true)
        return 6;
      else if (IsFlush(this) == true)
        return 5;
      else if (IsStraight(this) == true)
        return 4;
      else if (IsThreeKind(this) == true)
        return 3;
      else if (IsTwoPair(this) == true)
        return 2;
      else if (IsOnePair(this) == true)
        return 1;
      else if (IsHighCard(this) == true)
        return 0;
      else
        return -1;
    }

    // ------------------------------------------------------

    private static bool HasFlush(Hand h)
    {
      if ((h.cards[0].suit == h.cards[1].suit) "and"
          (h.cards[1].suit == h.cards[2].suit) "and"
          (h.cards[2].suit == h.cards[3].suit) "and"
          (h.cards[3].suit == h.cards[4].suit))
        return true;

      return false;
    }

    // ------------------------------------------------------

    private static bool HasStraight(Hand h)
    {
      // check special case of Ace-low straight
      // 2, 3, 4, 5, A when sorted
      if (h.cards[0].rank == 2 "and"
        h.cards[1].rank == 3 "and"
        h.cards[2].rank == 4 "and"
        h.cards[3].rank == 5 "and"
        h.cards[4].rank == 14)
        return true;

      // otherwise, check for 5 consecutive
      if ((h.cards[0].rank == h.cards[1].rank - 1) "and"
        (h.cards[1].rank == h.cards[2].rank - 1) "and"
        (h.cards[2].rank == h.cards[3].rank - 1) "and"
        (h.cards[3].rank == h.cards[4].rank - 1))
        return true;

      return false;
    }

    // ------------------------------------------------------

    private static bool IsRoyalFlush(Hand h)
    {
      if (HasStraight(h) == true "and" HasFlush(h) == true
        "and" h.cards[0].rank == 10)
        return true;
      else
        return false;
    }

    // ------------------------------------------------------

    private static bool IsStraightFlush(Hand h)
    {
      if (HasStraight(h) == true "and" HasFlush(h) == true
        "and" h.cards[0].rank != 10)
        return true;
      else
        return false;
    }

    // ------------------------------------------------------

    private static bool IsFourKind(Hand h)
    {
      // AAAA B or B AAAA if sorted
      if ((h.cards[0].rank == h.cards[1].rank) "and"
        (h.cards[1].rank == h.cards[2].rank) "and"
        (h.cards[2].rank == h.cards[3].rank) "and"
        (h.cards[3].rank != h.cards[4].rank))
        return true;

      if ((h.cards[1].rank == h.cards[2].rank) "and"
        (h.cards[2].rank == h.cards[3].rank) "and"
        (h.cards[3].rank == h.cards[4].rank) "and"
        (h.cards[0].rank != h.cards[1].rank))
        return true;

      return false;
    }

    // ------------------------------------------------------

    private static bool IsFullHouse(Hand h)
    {
      // AAA BB or BB AAA if sorted
      if ((h.cards[0].rank == h.cards[1].rank) "and"
        (h.cards[1].rank == h.cards[2].rank) "and"
        (h.cards[3].rank == h.cards[4].rank) "and"
        (h.cards[2].rank != h.cards[3].rank))
        return true;

      // BB AAA
      if ((h.cards[0].rank == h.cards[1].rank) "and"
        (h.cards[2].rank == h.cards[3].rank) "and"
        (h.cards[3].rank == h.cards[4].rank) "and"
        (h.cards[1].rank != h.cards[2].rank))
        return true;

      return false;
    }

    // ------------------------------------------------------

    private static bool IsFlush(Hand h)
    {
      if (HasFlush(h) == true "and" 
        HasStraight(h) == false)
        return true; // no StraightFlush or RoyalFlush
      else
        return false;
    }

    // ------------------------------------------------------

    private static bool IsStraight(Hand h)
    {
      if (HasStraight(h) == true "and" 
        HasFlush(h) == false) // no SF or RF
        return true;
      else
        return false;
    }

    // ------------------------------------------------------

    private static bool IsThreeKind(Hand h)
    {
      // AAA B C or B AAA C or B C AAA if sorted
      if ((h.cards[0].rank == h.cards[1].rank) "and"
        (h.cards[1].rank == h.cards[2].rank) "and"
        (h.cards[2].rank != h.cards[3].rank) "and"
        (h.cards[3].rank != h.cards[4].rank))
        return true;

      if ((h.cards[1].rank == h.cards[2].rank) "and"
        (h.cards[2].rank == h.cards[3].rank) "and"
        (h.cards[0].rank != h.cards[1].rank) "and"
        (h.cards[3].rank != h.cards[4].rank))
        return true;

      if ((h.cards[2].rank == h.cards[3].rank) "and"
        (h.cards[3].rank == h.cards[4].rank) "and"
        (h.cards[0].rank != h.cards[1].rank) "and"
        (h.cards[1].rank != h.cards[2].rank))
        return true;

      return false;
    }

    // ------------------------------------------------------

    private static bool IsTwoPair(Hand h)
    {
      // AA BB C or AA C BB or C AA BB if sorted
      if ((h.cards[0].rank == h.cards[1].rank) "and"
        (h.cards[2].rank == h.cards[3].rank) "and"
        (h.cards[1].rank != h.cards[2].rank) "and"
        (h.cards[3].rank != h.cards[4].rank))
        return true;  // AA BB C

      if ((h.cards[0].rank == h.cards[1].rank) "and"
        (h.cards[3].rank == h.cards[4].rank) "and"
        (h.cards[1].rank != h.cards[2].rank) "and"
        (h.cards[2].rank != h.cards[3].rank))
        return true;  // AA C BB

      if ((h.cards[1].rank == h.cards[2].rank) "and"
        (h.cards[3].rank == h.cards[4].rank) "and"
        (h.cards[0].rank != h.cards[1].rank) "and"
        (h.cards[2].rank != h.cards[3].rank))
        return true;  // C AA BB

      return false;
    }

    // ------------------------------------------------------

    private static bool IsOnePair(Hand h)
    {
      // AA B C D or B AA C D or B C AA D or B C D AA
      if ((h.cards[0].rank == h.cards[1].rank) "and"
        (h.cards[1].rank != h.cards[2].rank) "and"
        (h.cards[2].rank != h.cards[3].rank) "and"
        (h.cards[3].rank != h.cards[4].rank))
        return true;  // AA B C D

      if ((h.cards[1].rank == h.cards[2].rank) "and"
        (h.cards[0].rank != h.cards[1].rank) "and"
        (h.cards[2].rank != h.cards[3].rank) "and"
        (h.cards[3].rank != h.cards[4].rank))
        return true;  // B AA C D

      if ((h.cards[2].rank == h.cards[3].rank) "and"
        (h.cards[0].rank != h.cards[1].rank) "and"
        (h.cards[1].rank != h.cards[2].rank) "and"
        (h.cards[3].rank != h.cards[4].rank))
        return true;  // B C AA D

      if ((h.cards[3].rank == h.cards[4].rank) "and"
        (h.cards[0].rank != h.cards[1].rank) "and"
        (h.cards[1].rank != h.cards[2].rank) "and"
        (h.cards[2].rank != h.cards[3].rank))
        return true;  // B C D AA

      return false;
    }

    // ------------------------------------------------------

    private static bool IsHighCard(Hand h)
    {
      if (HasFlush(h) == true)
        return false;
      else if (HasStraight(h) == true)
        return false;
      else
      {
        // all remaining have at least one pair
        if ((h.cards[0].rank == h.cards[1].rank) ||
            (h.cards[1].rank == h.cards[2].rank) ||
            (h.cards[2].rank == h.cards[3].rank) ||
            (h.cards[3].rank == h.cards[4].rank))
          return false;
      }

      return true;
    }

    // ------------------------------------------------------

    // Hand comparison methods
    // Hand.Compare() calls:
    // BreakTieStraightFlush(), BreakTieFourKind(),
    // BreakTieFullHouse(), BreakTieFlush(),
    // BreakTieStraight(), BreakTieThreeKind(),
    // BreakTieTwoPair(), BreakTieOnePair(),
    // BreakTieHighCard()

    // ------------------------------------------------------

    public static int Compare(Hand h1, Hand h2)
    {
      // -1 if h1 "lt" h2, +1 if h1 "gt" h2, 0 if h1 == h2

      int h1Idx = h1.GetHandTypeInt();  // like 6
      int h2Idx = h2.GetHandTypeInt();

      // different hand types - easy
      if (h1Idx "lt" h2Idx)
        return -1;
      else if (h1Idx "gt" h2Idx)
        return +1;
      else // same hand types so break tie
      {
        string h1HandType = h1.GetHandTypeStr();
        string h2HandType = h2.GetHandTypeStr();

        if (h1HandType != h2HandType)
          Console.WriteLine("Logic error ");

        if (h1HandType == "RoyalFlush")
          return 0; // two Royal Flush always tie
        else if (h1HandType == "StraightFlush")
          return BreakTieStraightFlush(h1, h2);
        else if (h1HandType == "FourKind")
          return BreakTieFourKind(h1, h2);
        else if (h1HandType == "FullHouse")
          return BreakTieFullHouse(h1, h2);
        else if (h1HandType == "Flush")
          return BreakTieFlush(h1, h2);
        else if (h1HandType == "Straight")
          return BreakTieStraight(h1, h2);
        else if (h1HandType == "ThreeKind")
          return BreakTieThreeKind(h1, h2);
        else if (h1HandType == "TwoPair")
          return BreakTieTwoPair(h1, h2);
        else if (h1HandType == "OnePair")
          return BreakTieOnePair(h1, h2);
        else if (h1HandType == "HighCard")
          return BreakTieHighCard(h1, h2);
      }
      return -2;  // error
    }

    // ------------------------------------------------------

    private static int BreakTieStraightFlush(Hand h1,
      Hand h2)
    {
      // check special case of Ace-low straight flush
      // check one or two Ace-low hands
      // h1 is Ace - low, h2 not Ace - low.h1 is less
      if ((h1.cards[0].rank == 2 "and"
        h1.cards[4].rank == 14) "and"  // because sorted!
        !(h2.cards[0].rank == 2 "and"
        h2.cards[4].rank == 14))
        return -1;
 
      //  h1 not Ace - low, h2 is Ace - low, h1 is better
      else if (!(h1.cards[0].rank == 2 "and"
        h1.cards[4].rank == 14) "and"
        (h2.cards[0].rank == 2 "and"
        h2.cards[4].rank == 14))
        return +1;
      //  two Ace-low hands
      else if ((h1.cards[0].rank == 2 "and"
        h1.cards[4].rank == 14) "and"  // Ace-low
        (h2.cards[0].rank == 2 "and"
        h2.cards[4].rank == 14))  // Ace-low
        return 0;

      //  no Ace-low straight flush so check high cards
      if (h1.cards[4].rank "lt" h2.cards[4].rank)
        return -1;
      else if (h1.cards[4].rank "gt" h2.cards[4].rank)
        return 1;
      else
        return 0;
    }

    private static int BreakTieFourKind(Hand h1,
        Hand h2)
    {
      // the off-card is at [0] or at [4]
      // find h1 four-card and off-card ranks
      int h1FourRank; int h1OffRank;
      if (h1.cards[0].rank == h1.cards[1].rank)
      {
        // 1st two cards same so off-rank at [4]
        h1FourRank = h1.cards[0].rank;
        h1OffRank = h1.cards[4].rank;
      }
      else
      {
        // 1st two cards diff so off-rank at [0]
        h1FourRank = h1.cards[4].rank;
        h1OffRank = h1.cards[0].rank;
      }

      int h2FourRank; int h2OffRank;
      if (h2.cards[0].rank == h2.cards[1].rank)
      {
        h2FourRank = h2.cards[0].rank;
        h2OffRank = h2.cards[4].rank;
      }
      else
      {
        h2FourRank = h2.cards[4].rank;
        h2OffRank = h2.cards[0].rank;
      }

      if (h1FourRank "lt" h2FourRank) // like 4K, 4A
        return -1;
      else if (h1FourRank "gt" h2FourRank)
        return +1;
      else // both hands have same four-kind (mult. decks)
      {
        if (h1OffRank "lt" h2OffRank)
          return -1;  // like 3c 9c9d9h9s "lt" Qd 9c9d9h9s
        else if (h1OffRank "gt" h2OffRank)
          return +1;  // like Jc 4c4d4h4s "gt" 9s 4c4d4h4s
        else if (h1OffRank == h2OffRank)
          return 0;
      }
      throw new Exception("Fatal logic BreakTieFourKind");
    }

    private static int BreakTieFullHouse(Hand h1, Hand h2)
    {
      // determine high rank (3 kind) and low rank (2 kind)
      // JJJ 55 or 33 KKK
      // if [1] == [2] 3 kind at [0][1][2]
      // if [1] != [2] 3 kind at [2][3][4]
      int h1ThreeRank; int h1TwoRank;
      if (h1.cards[1].rank == h1.cards[2].rank)
      {
        // if [1] == [2] 3 kind at [0][1][2]
        h1ThreeRank = h1.cards[0].rank;
        h1TwoRank = h1.cards[4].rank;
      }
      else
      {
        // if [1] != [2] 3 kind at [2][3][4]
        h1ThreeRank = h1.cards[4].rank;
        h1TwoRank = h1.cards[0].rank;
      }

      int h2ThreeRank; int h2TwoRank;
      if (h2.cards[1].rank == h2.cards[2].rank)
      {
        // if [1] == [2] 3 kind at [0][1][2]
        h2ThreeRank = h2.cards[0].rank;
        h2TwoRank = h2.cards[4].rank;
      }
      else
      {
        // if [1] != [2] 3 kind at [2][3][4]
        h2ThreeRank = h2.cards[4].rank;
        h2TwoRank = h2.cards[0].rank;
      }

      if (h1ThreeRank "lt" h2ThreeRank)
        return -1;
      else if (h1ThreeRank "gt" h2ThreeRank)
        return +1;
      else // both hands same three-kind (mult. decks)
      {
        if (h1TwoRank "lt" h2TwoRank)
          return -1;  // like 3c3d 9c9d9h "lt" QdQs 9c9d9h
        else if (h1TwoRank "gt" h2TwoRank)
          return +1;  // like 3c3d 9c9d9h "gt" 2d2s 9c9d9h
        else if (h1TwoRank == h2TwoRank)
          return 0;
      }
      throw new Exception("Fatal logic BreakTieFullHouse");
    }

    private static int BreakTieFlush(Hand h1, Hand h2)
    {
      // compare rank of high cards
      if (h1.cards[4].rank "lt" h2.cards[4].rank)
        return -1;
      else if (h1.cards[4].rank "gt" h2.cards[4].rank)
        return +1;
      // high cards equal so check at [3]
      else if (h1.cards[3].rank "lt" h2.cards[3].rank)
        return -1;
      else if (h1.cards[3].rank "gt" h2.cards[3].rank)
        return +1;
      // and so on
      else if (h1.cards[2].rank "lt" h2.cards[2].rank)
        return -1;
      else if (h1.cards[2].rank "gt" h2.cards[2].rank)
        return +1;
      //
      else if (h1.cards[1].rank "lt" h2.cards[1].rank)
        return -1;
      else if (h1.cards[1].rank "gt" h2.cards[1].rank)
        return +1;
      //
      else if (h1.cards[0].rank "lt" h2.cards[0].rank)
        return -1;
      else if (h1.cards[0].rank "gt" h2.cards[0].rank)
        return +1;
      //
      else
        return 0; // all ranks the same!
    }

    private static int BreakTieStraight(Hand h1, Hand h2)
    {
      // both hands are straights but one could be Ace-low
      // check special case of one or two Ace-low hands
      // h1 is Ace-low, h2 not Ace-low. h1 is less
      if ((h1.cards[0].rank == 2 "and"  // Ace-low (sorted!)
        h1.cards[4].rank == 14) "and"
        !(h2.cards[0].rank == 2 "and"
        h2.cards[4].rank == 14))
        return -1;
      // h1 not Ace-low, h2 is Ace-low, h1 is better
      else if (!(h1.cards[0].rank == 2 "and"
        h1.cards[4].rank == 14) "and"
        (h2.cards[0].rank == 2 "and"
        h2.cards[4].rank == 14))
        return +1;
      // two Ace-low hands
      else if ((h1.cards[0].rank == 2 "and"
        h1.cards[4].rank == 14) "and"
        (h2.cards[0].rank == 2 "and"
        h2.cards[4].rank == 14))
        return 0;

      // no Ace-low hands so just check high card
      if (h1.cards[4].rank "lt" h2.cards[4].rank)
        return -1;
      else if (h1.cards[4].rank "gt" h2.cards[4].rank)
        return +1;
      else if (h1.cards[4].rank == h2.cards[4].rank)
        return 0;
      else
        throw new
          Exception("Fatal logic BreakTieStraight");
    }

    private static int BreakTieThreeKind(Hand h1, Hand h2)
    {
      // assumes multiple decks possible
      // (TTT L H) or (L TTT H) or (L H TTT)
      int h1ThreeRank = 0; int h1LowRank = 0;
      int h1HighRank = 0;
      if (h1.cards[0].rank == h1.cards[1].rank "and"
        h1.cards[1].rank == h1.cards[2].rank)
      {
        h1ThreeRank = h1.cards[0].rank;
        h1LowRank = h1.cards[3].rank;
        h1HighRank = h1.cards[4].rank;
      }
      else if (h1.cards[1].rank == h1.cards[2].rank "and"
        h1.cards[2].rank == h1.cards[3].rank)
      {
        h1LowRank = h1.cards[0].rank;
        h1ThreeRank = h1.cards[1].rank;
        h1HighRank = h1.cards[4].rank;
      }
      else if (h1.cards[2].rank == h1.cards[3].rank "and"
        h1.cards[3].rank == h1.cards[4].rank)
      {
        h1LowRank = h1.cards[0].rank;
        h1HighRank = h1.cards[1].rank;
        h1ThreeRank = h1.cards[4].rank;
      }

      int h2ThreeRank = 0; int h2LowRank = 0;
      int h2HighRank = 0;
      if (h2.cards[0].rank == h2.cards[1].rank "and"
        h2.cards[1].rank == h2.cards[2].rank)
      {
        h2ThreeRank = h2.cards[0].rank;
        h2LowRank = h2.cards[3].rank;
        h2HighRank = h2.cards[4].rank;
      }
      else if (h2.cards[1].rank == h2.cards[2].rank "and"
        h2.cards[2].rank == h2.cards[3].rank)
      {
        h2LowRank = h2.cards[0].rank;
        h2ThreeRank = h2.cards[1].rank;
        h2HighRank = h2.cards[4].rank;
      }
      else if (h2.cards[2].rank == h2.cards[3].rank "and"
        h2.cards[3].rank == h2.cards[4].rank)
      {
        h2LowRank = h2.cards[0].rank;
        h2HighRank = h2.cards[1].rank;
        h2ThreeRank = h2.cards[4].rank;
      }

      if (h1ThreeRank "lt" h2ThreeRank)
        return -1;
      else if (h1ThreeRank "gt" h2ThreeRank)
        return +1;
      // both hands three-kind same (mult. decks)
      else if (h1HighRank "lt" h2HighRank)
        return -1;
      else if (h1HighRank "gt" h2HighRank)
        return +1;
      //
      else if (h1LowRank "lt" h2LowRank)
        return -1;
      else if (h1LowRank "gt" h2LowRank)
        return +1;
      //
      else // wow!
        return 0;
    }

    private static int BreakTieTwoPair(Hand h1, Hand h2)
    {
      // (LL X HH) or (LL HH X) or (X LL HH)
      int h1LowRank = 0; int h1HighRank = 0;
      int h1OffRank = 0;
      if (h1.cards[0].rank == h1.cards[1].rank "and"
        h1.cards[3].rank == h1.cards[4].rank)
      {
        // (LL X HH)
        h1LowRank = h1.cards[0].rank;
        h1HighRank = h1.cards[4].rank;
        h1OffRank = h1.cards[2].rank;
      }
      else if (h1.cards[0].rank == h1.cards[1].rank "and"
        h1.cards[2].rank == h1.cards[3].rank)
      {
        // (LL HH X)
        h1LowRank = h1.cards[0].rank;
        h1HighRank = h1.cards[2].rank;
        h1OffRank = h1.cards[4].rank;
      }
      else if (h1.cards[1].rank == h1.cards[2].rank "and"
        h1.cards[3].rank == h1.cards[4].rank)
      {
        // (X LL HH)
        h1LowRank = h1.cards[1].rank;
        h1HighRank = h1.cards[3].rank;
        h1OffRank = h1.cards[0].rank;
      }

      int h2LowRank = 0; int h2HighRank = 0;
      int h2OffRank = 0;
      if (h2.cards[0].rank == h2.cards[1].rank "and"
        h2.cards[3].rank == h2.cards[4].rank)
      {
        // (LL X HH)
        h2LowRank = h2.cards[0].rank;
        h2HighRank = h2.cards[4].rank;
        h2OffRank = h2.cards[2].rank;
      }
      else if (h2.cards[0].rank == h2.cards[1].rank "and"
        h2.cards[2].rank == h2.cards[3].rank)
      {
        // (LL HH X)
        h2LowRank = h2.cards[0].rank;
        h2HighRank = h2.cards[2].rank;
        h2OffRank = h2.cards[4].rank;
      }
      else if (h2.cards[1].rank == h2.cards[2].rank "and"
        h2.cards[3].rank == h2.cards[4].rank)
      {
        // (X LL HH)
        h2LowRank = h2.cards[1].rank;
        h2HighRank = h2.cards[3].rank;
        h2OffRank = h2.cards[0].rank;
      }

      if (h1HighRank "lt" h2HighRank)
        return -1;
      else if (h1HighRank "gt" h2HighRank)
        return +1;
      else if (h1LowRank "lt" h2LowRank)
        return -1;
      else if (h1LowRank "gt" h2LowRank)
        return +1;
      else if (h1OffRank "lt" h2OffRank)
        return -1;
      else if (h1OffRank "gt" h2OffRank)
        return +1;
      else
        return 0;
    }

    private static int BreakTieOnePair(Hand h1, Hand h2)
    {
      // (PP L M H) or (L PP M H)
      // or (L M PP H) or (L M H PP)
      int h1PairRank = 0; int h1LowRank = 0;
      int h1MediumRank = 0; int h1HighRank = 0;
      if (h1.cards[0].rank == h1.cards[1].rank)
      {
        // (PP L M H)
        h1PairRank = h1.cards[0].rank;
        h1LowRank = h1.cards[2].rank;
        h1MediumRank = h1.cards[3].rank;
        h1HighRank = h1.cards[4].rank;
      }
      else if (h1.cards[1].rank == h1.cards[2].rank)
      {
        // (L PP M H)
        h1PairRank = h1.cards[1].rank;
        h1LowRank = h1.cards[0].rank;
        h1MediumRank = h1.cards[3].rank;
        h1HighRank = h1.cards[4].rank;
      }
      else if (h1.cards[2].rank == h1.cards[3].rank)
      {
        // (L M PP H)
        h1PairRank = h1.cards[2].rank;
        h1LowRank = h1.cards[0].rank;
        h1MediumRank = h1.cards[1].rank;
        h1HighRank = h1.cards[4].rank;
      }
      else if (h1.cards[3].rank == h1.cards[4].rank)
      {
        // (L M H PP)
        h1PairRank = h1.cards[4].rank;
        h1LowRank = h1.cards[0].rank;
        h1MediumRank = h1.cards[1].rank;
        h1HighRank = h1.cards[2].rank;
      }

      int h2PairRank = 0; int h2LowRank = 0;
      int h2MediumRank = 0; int h2HighRank = 0;
      if (h2.cards[0].rank == h2.cards[1].rank)
      {
        // (PP L M H)
        h2PairRank = h2.cards[0].rank;
        h2LowRank = h2.cards[2].rank;
        h2MediumRank = h2.cards[3].rank;
        h2HighRank = h2.cards[4].rank;
      }
      else if (h2.cards[1].rank == h2.cards[2].rank)
      {
        // (L PP M H)
        h2PairRank = h2.cards[1].rank;
        h2LowRank = h2.cards[0].rank;
        h2MediumRank = h2.cards[3].rank;
        h2HighRank = h2.cards[4].rank;
      }
      else if (h2.cards[2].rank == h2.cards[3].rank)
      {
        // (L M PP H)
        h2PairRank = h2.cards[2].rank;
        h2LowRank = h2.cards[0].rank;
        h2MediumRank = h2.cards[1].rank;
        h2HighRank = h2.cards[4].rank;
      }
      else if (h2.cards[3].rank == h2.cards[4].rank)
      {
        // (L M H PP)
        h2PairRank = h2.cards[4].rank;
        h2LowRank = h2.cards[0].rank;
        h2MediumRank = h2.cards[1].rank;
        h2HighRank = h2.cards[2].rank;
      }

      if (h1PairRank "lt" h2PairRank)
        return -1;
      else if (h1PairRank "gt" h2PairRank)
        return +1;
      //
      else if (h1HighRank "lt" h2HighRank)
        return -1;
      else if (h1HighRank "gt" h2HighRank)
        return +1;
      //
      else if (h1MediumRank "lt" h2MediumRank)
        return -1;
      else if (h1MediumRank "gt" h2MediumRank)
        return +1;
      //
      else if (h1LowRank "lt" h2LowRank)
        return -1;
      else if (h1LowRank "gt" h2LowRank)
        return +1;
      //
      else
        return 0;
    }

    private static int BreakTieHighCard(Hand h1, Hand h2)
    {
      if (h1.cards[4].rank "lt" h2.cards[4].rank)
        return -1;
      else if (h1.cards[4].rank "gt" h2.cards[4].rank)
        return +1;
      //
      else if (h1.cards[3].rank "lt" h2.cards[3].rank)
        return -1;
      else if (h1.cards[3].rank "gt" h2.cards[3].rank)
        return +1;
      //
      else if (h1.cards[2].rank "lt" h2.cards[2].rank)
        return -1;
      else if (h1.cards[2].rank "gt" h2.cards[2].rank)
        return +1;
      //
      else if (h1.cards[1].rank "lt" h2.cards[1].rank)
        return -1;
      else if (h1.cards[1].rank "gt" h2.cards[1].rank)
        return +1;
      //
      else if (h1.cards[0].rank "lt" h2.cards[0].rank)
        return -1;
      else if (h1.cards[0].rank "gt" h2.cards[0].rank)
        return +1;
      //
      else
        return 0;
    }

    // ------------------------------------------------------

  } // class Hand


} // ns

Test data.

# poker_compare_test.txt
#
# 0 = High Card, 1 = One Pair, 2 = Two Pair
# 3 = Three Kind, 4 = Straight, 5 = Flush
# 6 = Full House, 7 = Four Kind
# 8 = Straight Flush, 9 = Royal Flush
#
# Break Tie test cases
#
# Royal Flush
#
TsJsQsKsAs,TcJcQcKcAc,9,9,0
AdKdQdJdTd,TsAsQsJsKs,9,9,0
#
# Straight Flush
#
4c5c6c7c8c,7d8d9dTdJd,8,8,-1
8s7s6s5s4s,8s7s6s5s4s,8,8,0
7d8d9dTdJd,3s4s5s6s7s,8,8,1
#
# Four Kind
#
JcJdJhJs3c,2c2d2h2s3d,7,7,1
6c6d7d6h6s,8cAc8d8h8s,7,7,-1
JcJsJhJd5c,JcJsJhJd5s,7,7,0, mult decks
JcJsJhJd5c,JcJsJhJd7c,7,7,-1, mult decks
JcJsJhJd7c,JcJsJhJd5c,7,7,1, mult decks
#
# Full House
#
2c2d2hAcAs,KcKd3c3s3h,6,6,-1
TdTsTc2h2s,9c9s9dAhAs,6,6,1
#
# Flush
#
3c5c7c9cJc,3d5d7dTdJd,5,5,-1
2s3s4s5s7s,6c8cAc9cTc,5,5,-1
#
3h5h7h9hJh,3d5d7d9dJd,5,5,0
3h5h7h9hJh,3d5d7d9dQd,5,5,-1
3h5h7h9hJh,3d5d7dTdJd,5,5,-1, kicker1
3h5h7h9hJh,3d5d8d9dJd,5,5,-1, kicker2
3h5h7h9hJh,3d6d7d9dJd,5,5,-1, kicker3
3h5h7h9hJh,4d5d7d9dJd,5,5,-1, kicker4
3d5d7d9dQd,3h5h7h9hJh,5,5,1
3d5d7dTdJd,3h5h7h9hJh,5,5,1, kicker1
3d5d8d9dJd,3h5h7h9hJh,5,5,1, kicker2
3d6d7d9dJd,3h5h7h9hJh,5,5,1, kicker3
4d5d7d9dJd,3h5h7h9hJh,5,5,1, kicker4
#
# Straight
#
5c6d7h8s9s,2c3d4h5s6s,4,4,1
8c7d6h5c4c,Ts9c8h7s6c,4,4,-1
Ad2d3s4d5s,3s4h5s6s7h,4,4,-1
TcJdQhKsAc,TdJhQsKcAd,4,4,0
#
4s5d6d7d8d,4s5d6d7d8d,4,4,0
4s5d6d7d8d,5c6c7c8s9c,4,4,-1
4s5d6d7d8d,6c7c8s9cTc,4,4,-1, kicker1
4s5d6d7d8d,7c8s9cTcJc,4,4,-1, kicker2
4s5d6d7d8d,8c9hTcJcQc,4,4,-1, kicker3
4s5d6d7d8d,9sTcJcQcKc,4,4,-1, kicker4
5c6c7c8s9c,4s5d6d7d8d,4,4,1
6c7c8s9cTc,4s5d6d7d8d,4,4,1, kicker1
7c8s9cTcJc,4s5d6d7d8d,4,4,1, kicker2
8c9hTcJcQc,4s5d6d7d8d,4,4,1, kicker3
9sTcJcQcKc,4s5d6d7d8d,4,4,1, kicker4
#
# Three Kind
#
Ac2sAh5dAs,3d5sKcKsKd,3,3,1
4c4s4dKhAs,KcAd4h4s4c,3,3,0
2c2d2hAsKd,3c3d3h5s6c,3,3,-1
#
# assumes multiple decks
JcJdJh4s6d,JcJdJh4s6d,3,3,0
JcJdJh4s6d,JcJdJh4s7d,3,3,-1, TTT L H
JcJdJh4s6d,JcJdJh5s6d,3,3,-1, TTT L H
4sJcJdJh6d,4sJcJdJh7d,3,3,-1, L TTT H
4sJcJdJh6d,5sJcJdJh6d,3,3,-1, L TTT H
4s6dJcJdJh,4s7dJcJdJh,3,3,-1, L H TTT
4s6dJcJdJh,5s6dJcJdJh,3,3,-1, L H TTT
JcJdJh4s7d,JcJdJh4s6d,3,3,1, TTT L H
JcJdJh5s6d,JcJdJh4s6d,3,3,1, TTT L H
4sJcJdJh7d,4sJcJdJh6d,3,3,1, L TTT H
5sJcJdJh6d,4sJcJdJh6d,3,3,1, L TTT H
4s7dJcJdJh,4s6dJcJdJh,3,3,1, L H TTT
5s6dJcJdJh,4s6dJcJdJh,3,3,1, L H TTT
#
# Two Pair
#
KdKc5d7h7s,QcQd8c8sAc,2,2,1
QcQd8c8sAc,KdKc5d7h7s,2,2,-1
5c5dAc6c6d,6h6sAd5h5s,2,2,0
#
# One Pair
#
7cTcTd3c4d,9c9s2c3d4h,1,1,1
AcAs9c8h7d,AdAh9d3c2d,1,1,1
KcKd2c3c4c,KhKs2d3d4d,1,1,0
5s5hAcQdTd,7c8c9cJcJs,1,1,-1
#
7c7d2c4d6h,7h7s2d4h6s,1,1,0
7c7d2c4d6h,7h7s2d4h8s,1,1,-1
7c7d2c4d6h,7h7s2d5h6s,1,1,-1
7c7d2c4d6h,7h7s3d4h6s,1,1,-1
7h7s2d4h8s,7c7d2c4d6h,1,1,1
7h7s2d5h6s,7c7d2c4d6h,1,1,1
7h7s3d4h6s,7c7d2c4d6h,1,1,1
#
# High Card
#
2c3d5c6d7s,2d3h4c6h7c,0,0,1
2d3h4c6h7c,2c3d5c6d7s,0,0,-1
AcKdQhJs9c,AdKhQsJc9h,0,0,0
#
Qd3c5d7h9s,Qd3c5d7h9s,0,0,0
Qd3c5d7h9s,Qd3c5d7hTs,0,0,-1
Qd3c5d7h9s,Qd3c5d8h9s,0,0,-1
Qd3c5d7h9s,Qd3c6d7h9s,0,0,-1
Qd3c5d7h9s,Qd4c5d7h9s,0,0,-1
Qd3c5d7h9s,Qd3c5d7h9s,0,0,0
Qd3c5d7hTs,Qd3c5d7h9s,0,0,1
Qd3c5d8h9s,Qd3c5d7h9s,0,0,1
Qd3c6d7h9s,Qd3c5d7h9s,0,0,1
Qd4c5d7h9s,Qd3c5d7h9s,0,0,1
#
# different hand types
#
# 0 = High Card, 1 = One Pair, 2 = Two Pair
# 3 = Three Kind, 4 = Straight, 5 = Flush
# 6 = Full House, 7 = Four Kind
# 8 = Straight Flush, 9 = Royal Flush
#
3c5d7h9sJc,2c2s4d6s8d,0,1,-1
3c5d7h9sJc,4c4d6c6dAh,0,2,-1
3c5d7h9sJc,4c4d4sTsQh,0,3,-1
3c5d7h9sJc,6d7d8d9dTs,0,4,-1
3c5d7h9sJc,2s4s6s8sTs,0,5,-1
3c5d7h9sJc,8c8s8hKhKs,0,6,-1
3c5d7h9sJc,6s6h6d6c2s,0,7,-1
3c5d7h9sJc,4c5c6c7c8c,0,8,-1
3c5d7h9sJc,TsJsQsKsAs,0,9,-1
2c2s4d6s8d,3c5d7h9sJc,1,0,1
4c4d6c6dAh,3c5d7h9sJc,2,0,1
4c4d4sTsQh,3c5d7h9sJc,3,0,1
6d7d8d9dTs,3c5d7h9sJc,4,0,1
2s4s6s8sTs,3c5d7h9sJc,5,0,1
8c8s8hKhKs,3c5d7h9sJc,6,0,1
6s6h6d6c2s,3c5d7h9sJc,7,0,1
4c5c6c7c8c,3c5d7h9sJc,8,0,1
TsJsQsKsAs,3c5d7h9sJc,9,0,1
#
5c5d7c9dJs,AcAs4d4s8d,1,2,-1
5c5d7c9dJs,6c6d6sTsQh,1,3,-1
5c5d7c9dJs,7d8d9sThJd,1,4,-1
5c5d7c9dJs,2h4h6h8hTh,1,5,-1
5c5d7c9dJs,3c3s3h2h2s,1,6,-1
5c5d7c9dJs,4s4h4d4cTs,1,7,-1
5c5d7c9dJs,5d6d7d8d9d,1,8,-1
5c5d7c9dJs,ThJhQhKhAh,1,9,-1
AcAs4d4s8d,5c5d7c9dJs,2,1,1
6c6d6sTsQh,5c5d7c9dJs,3,1,1
7d8d9sThJd,5c5d7c9dJs,4,1,1
2h4h6h8hTh,5c5d7c9dJs,5,1,1
3c3s3h2h2s,5c5d7c9dJs,6,1,1
4s4h4d4cTs,5c5d7c9dJs,7,1,1
5d6d7d8d9d,5c5d7c9dJs,8,1,1
ThJhQhKhAh,5c5d7c9dJs,9,1,1
#
6c6dAcAd8s,5c5d5sTsKh,2,3,-1
6c6dAcAd8s,8d9dTdJsQh,2,4,-1
6c6dAcAd8s,Ah2h4h6h8h,2,5,-1
6c6dAcAd8s,TsTh3c3s3h,2,6,-1
6c6dAcAd8s,As9s9h9d9c,2,7,-1
6c6dAcAd8s,7c8c9cTcJc,2,8,-1
6c6dAcAd8s,AdTdKdJdQd,2,9,-1
5c5d5sTsKh,6c6dAcAd8s,3,2,1
8d9dTdJsQh,6c6dAcAd8s,4,2,1
Ah2h4h6h8h,6c6dAcAd8s,5,2,1
TsTh3c3s3h,6c6dAcAd8s,6,2,1
As9s9h9d9c,6c6dAcAd8s,7,2,1
7c8c9cTcJc,6c6dAcAd8s,8,2,1
AdTdKdJdQd,6c6dAcAd8s,9,2,1
#
2s5c5d5hKs,9dTdJsQhKc,3,4,-1
2s5c5d5hKs,Kh2h4h6h9h,3,5,-1
2s5c5d5hKs,JsJh4c4s4h,3,6,-1
2s5c5d5hKs,TsThTdTc6c,3,7,-1
2s5c5d5hKs,6c7c8c9cTc,3,8,-1
2s5c5d5hKs,TdKdAdJdQd,3,9,-1
9dTdJsQhKc,2s5c5d5hKs,4,3,1
Kh2h4h6h9h,2s5c5d5hKs,5,3,1
JsJh4c4s4h,2s5c5d5hKs,6,3,1
TsThTdTc6c,2s5c5d5hKs,7,3,1
6c7c8c9cTc,2s5c5d5hKs,8,3,1
TdKdAdJdQd,2s5c5d5hKs,9,3,1
#
9s8d7h6s5c,Qh3h5h6h8h,4,5,-1
9s8d7h6s5c,3s3h3dJsJh,4,6,-1
9s8d7h6s5c,6cJcJsJdJh,4,7,-1
9s8d7h6s5c,7c8c9cTcJc,4,8,-1
9s8d7h6s5c,TdKdAdJdQd,4,9,-1
Qh3h5h6h8h,9s8d7h6s5c,5,4,1
3s3h3dJsJh,9s8d7h6s5c,6,4,1
6cJcJsJdJh,9s8d7h6s5c,7,4,1
7c8c9cTcJc,9s8d7h6s5c,8,4,1
TdKdAdJdQd,9s8d7h6s5c,9,4,1
#
3d5d7d9dJd,4s4h4dQsQh,5,6,-1
3d5d7d9dJd,2cAcAsAdAh,5,7,-1
3d5d7d9dJd,6c7c8c9cTc,5,8,-1
3d5d7d9dJd,TsAsKsJsQs,5,9,-1
4s4h4dQsQh,3d5d7d9dJd,6,5,1
2cAcAsAdAh,3d5d7d9dJd,7,5,1
6c7c8c9cTc,3d5d7d9dJd,8,5,1
TsAsKsJsQs,3d5d7d9dJd,9,5,1
#
6c7s6h7d6d,JcJsJdJh3s,6,7,-1
6c7s6h7d6d,2s3s4s5s6s,6,8,-1
6c7s6h7d6d,QcTcAcKcJc,6,9,-1
JcJsJdJh3s,6c7s6h7d6d,7,6,1
2s3s4s5s6s,6c7s6h7d6d,8,6,1
QcTcAcKcJc,6c7s6h7d6d,9,6,1
#
5c5dAs5h5s,6s7s8s9sTs,7,8,-1
5c5dAs5h5s,JcQcTcAcKc,7,9,-1
6s7s8s9sTs,5c5dAs5h5s,8,7,1
JcQcTcAcKc,5c5dAs5h5s,9,7,1
#
3h4h5h6h7h,TsAsJsKsQs,8,9,-1
TsAsJsKsQs,3h4h5h6h7h,9,8,1
#
# end test cases
#
This entry was posted in Poker. Bookmark the permalink.

1 Response to Five-Card Poker Hand Comparison Using C#

  1. Thorsten Kleppe's avatar Thorsten Kleppe says:
    February 23, 2024 at 5:05 am

    Reminds me somehow of tokenization with Andrej Karpathy:
    https://www.youtube.com/watch?v=zduSFxRajkE

    Have a great weekend 🙂

Comments are closed.