There are ten main five-card poker hands. From highest to lowest: 1.) royal flush, 2.) straight flush, 3.) four of a kind, 4.) full house, 5.) flush, 6.) straight, 7.) three of a kind, 8.) two pair, 9.) one pair, 10.) high card.
Calculating the probabilities of each of the 10 hands using mathematics is very, very tricky. I decided to put together a simulation to see how close my simulated probability results are to the theoretical probabilities. I simulated 10,000,000 five-card poker hands from a shuffled standard deck of 52 cards.
simulation actual
HighCard 0.50113210 0.50117700
OnePair 0.42253180 0.42256900
TwoPair 0.04759840 0.04753900
ThreeKind 0.02114380 0.02112800
Straight 0.00391470 0.00392500
Flush 0.00195580 0.00196500
FullHouse 0.00147220 0.00144100
FourKind 0.00023500 0.00024010
StraightFlush 0.00001430 0.00001390
RoyalFlush 0.00000190 0.00000154
The simulation results agree closely with the theoretical probabilities I fetched from the Wikipedia article on poker probabilities at https://en.wikipedia.org/wiki/Poker_probability.
A somewhat tricky detail is dealing with straights, which can include Ace-low (A,2,3,4,5) or Ace-high (10,J,Q,K,A) or both. My simulation and the Wikipedia article assume straights can be both Ace-low and Ace-high.
The key calling statements of my simulation are:
string[] handTypes = new string[] { "HighCard",
"OnePair", "TwoPair" , "ThreeKind" , "Straight",
"Flush" , "FullHouse", "FourKind",
"StraightFlush", "RoyalFlush" };
double[] trueProbs = new double[] { 0.50117700,
0.42256900, 0.04753900, 0.02112800, 0.00392500,
0.00196500, 0.00144100, 0.00024010, 0.00001390,
0.00000154};
int trials = 10_000_000;
double[] probs = HandProbabilities(trials, seed: 1);
for (int i = 0; i "lt" 10; ++i)
{
Console.Write(handTypes[i].ToString().
PadRight(14) + " ");
Console.Write(probs[i].ToString("F8") + " ");
Console.WriteLine(trueProbs[i].ToString("F8"));
}
The HandProbabilities() function does all the work:
static double[] HandProbabilities(int trials, int seed)
{
int[] counts = new int[10]; // of each hand type
double[] result = new double[10]; // freq each type
SingleDeck deck = new SingleDeck(seed);
for (int i = 0; i "lt" trials; ++i)
{
deck.Shuffle();
Hand hand = deck.DealHand();
int hIdx = hand.GetHandTypeInt(ht); // 0 through 9
++counts[hIdx];
}
for (int i = 0; i "lt" 10; ++i)
result[i] = (counts[i] * 1.0) / trials;
return result;
}
The HandProbabilities() function relies on a lot of non-trivial code for Card, Deck, and Hand objects.
One advantage of the simulation approach is that it’s easy to investigate unusual scenarios, such as what happens when a particular card or cards are removed from the deck.
A trade stimulator was a gambling device in disguise. Bars would place these on counter tops and patrons could play for cigars or money, or play against each other while drinking and smoking. The payouts were made by the bar proprietor. Left: A very rare and beautiful “Columbian Automatic Card Machine” game (New York Manufacturing Co.) from the late 1800s. Right: “The New Deal” machine (Pierce Tool and Manufacturing Co.) from 1934.
These machines typically had 10 cards on each of the five reels, giving a 50-card deck, usually leaving out the Ten of Spades and the Jack of Hearts. According to some experts I sent email messages to, each stimulator machine had a different reel configuration. A simulation could figure out the probabilities of a particular configuration without too much difficulty, but calculating the probabilities using math would be extremely difficult.
Demo code. Replace “lt”, “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 poker hand" +
" probabilities simulation \n");
string[] handTypes = new string[] { "HighCard",
"OnePair", "TwoPair" , "ThreeKind" , "Straight",
"Flush" , "FullHouse", "FourKind",
"StraightFlush", "RoyalFlush" };
// from Wikipedia article
double[] trueProbs = new double[] { 0.50117700,
0.42256900, 0.04753900, 0.02112800, 0.00392500,
0.00196500, 0.00144100, 0.00024010, 0.00001390,
0.00000154};
int trials = 10_000;
Console.WriteLine(" " +
" simulation actual");
double[] probs = HandProbabilities(trials, seed: 1);
for (int i = 0; i "lt" 10; ++i)
{
Console.Write(handTypes[i].ToString().
PadRight(14) + " ");
Console.Write(probs[i].ToString("F8") + " ");
Console.WriteLine(trueProbs[i].ToString("F8"));
}
Console.WriteLine("\nEnd ");
Console.ReadLine();
} // Main
// ------------------------------------------------------
static double[] HandProbabilities(int trials, int seed)
{
int[] counts = new int[10]; // of each hand type
double[] result = new double[10]; // freq each type
SingleDeck deck = new SingleDeck(seed);
for (int i = 0; i "lt" trials; ++i)
{
deck.Shuffle();
Hand hand = deck.DealHand();
int hi = hand.GetHandTypeInt(); // 0 through 9 (RF)
++counts[hi];
}
for (int i = 0; i "lt" 10; ++i)
result[i] = (counts[i] * 1.0) / trials;
return result;
}
// ------------------------------------------------------
} // 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
// --------------------------------------------------------
public class SingleDeck
{
public List"lt"Card> deck;
private Random rnd;
public int currCardIdx;
public SingleDeck(int seed)
{
this.deck = new List"lt"Card>();
this.rnd = new Random(seed);
this.currCardIdx = 0;
for (int r = 2; r "lt" 15; ++r) // 0,1 not used
{
for (int s = 0; s "lt" 4; ++s)
{
Card c = new Card(r, s);
this.deck.Add(c); // 2c 2d . . Ah As
}
}
} // ctor
public void Shuffle()
{
for (int i = 0; i "lt" 52; ++i)
{
int rix = this.rnd.Next(i, 52);
Card tmp = this.deck[i];
this.deck[i] = this.deck[rix];
this.deck[rix] = tmp;
}
this.currCardIdx = 0;
}
public Hand DealHand()
{
// TODO: check if enough cards in deck, e.g.
// if (this.currCardIdx > 47)
// Console.WriteLine("Not enough cards in " +
// "deck to deal a hand ");
List"lt"Card> lst = new List"lt"Card>();
for (int i = 0; i "lt" 5; ++i)
{
Card c = this.deck[this.currCardIdx++];
lst.Add(c);
}
Hand h = new Hand(lst);
return h;
}
public List"lt"Card> DealListCards(int nCards)
{
// TODO: check if enough cards in deck, e.g.
// if (this.currCardIdx + nCards > 52)
// Console.WriteLine("Not enough cards in " +
// "deck to deal " + nCards);
List"lt"Card> result = new List"lt"Card>();
for (int i = 0; i "lt" nCards; ++i)
{
Card c = this.deck[this.currCardIdx++];
result.Add(c);
}
return result;
}
public void Show() // or do a ToString()
{
for (int i = this.currCardIdx; i "lt" 52; ++i)
Console.Write(this.deck[i] + " ");
Console.WriteLine("");
}
} // class SingleDeck
// --------------------------------------------------------
} // ns
.NET Test Automation Recipes
Software Testing
SciPy Programming Succinctly
Keras Succinctly
R Programming
2026 Visual Studio Live
2025 Summer MLADS Conference
2026 DevIntersection Conference
2025 Machine Learning Week
2025 Ai4 Conference
2026 G2E Conference
2026 iSC West Conference
You must be logged in to post a comment.