【算法】用c#实现德州扑克卡牌游戏规则

德州扑克是一种牌类游戏，可多人参与，它的玩法是，玩家每人发两张底牌，桌面依次发5张公共牌，玩家用自己的两张底牌和5张公共牌自由组合，按大小决定胜负。

使用c#完成功能Hand()以返回手牌类型和按重要性递减顺序排列的等级列表，用于与同类型的其他手牌进行比较，即最佳手牌。

可能的手牌按价值降序排列：

同花顺（同一套衣服的连续五个等级）。级别越高越好。

四张（四张等级相同的牌）。平局决胜先是等级，然后是剩余牌的等级。

满座（三张等级相同的牌，两张等级相同）。决胜局首先是三张牌的等级，然后是一对牌的等级。

同花顺（五张同花色的牌）。从高到低，级别越高越好。

直（连续五个等级）。级别越高越好。

三张牌（三张等级相同的牌）。决胜局是三张牌中排名第一的，然后是其他排名最高的，然后才是其他排名第二的。

两对（两张相同等级的牌，两张不同等级的牌）。决胜局首先是高牌对的等级，然后是低牌对的级别，然后是剩余牌的等级。

配对（两张等级相同的牌）。平局决胜是先是两张牌的等级，然后是其他三张牌的级别。

---

算法实现：

  1 using System;
  2 using System.Collections.Generic;
  3 using System.Linq;
  4 using System.Text;
  5
  6 public static class Edm
  7     {
  8         public static (string type, string[] ranks) Hand(string[] holeCards, string[] communityCards)
  9         {
 10             Card[] allCards = holeCards.Concat(communityCards).Select( x=> new Card(x)).OrderByDescending(card =>card.value).ToArray();
 11
 12             var rulesChain = createChainOfCommand();
 13             var powerhands = rulesChain.Execute(allCards);
 14             return (powerhands.Item1, getReturnlist(allCards, powerhands.Item2));
 15
 16         }
 17         public static string[] getReturnlist(Card[] cards, Card[] powerhand)
 18         {
 19             var remainderHand = cards.Where(x => !powerhand.Any(y => y.Equals(x))).Take(5-powerhand.Length);
 20             var result = powerhand.Select(x =>x.number).Distinct().Concat(remainderHand.Select(x=>x.number)).Take(5).Select(x => x.ToString()).ToArray();
 21             return result;
 22         }
 23
 24         public static Rule createChainOfCommand()
 25         {
 26             Rule straightFlush = new StraightFlushRule();
 27             Rule fourOfAKind = new FourOfAKindRule();
 28             Rule fullHouse = new FullHouseRule();
 29             Rule flush = new FlushRule();
 30             Rule straight = new StraightRule();
 31             Rule threeOfAKind = new ThreeOfAKindRule();
 32             Rule pairTwoPair = new PairTwoPairRule();
 33             straightFlush.SetSuccessor(fourOfAKind);
 34             fourOfAKind.SetSuccessor(fullHouse);
 35             fullHouse.SetSuccessor(flush);
 36             flush.SetSuccessor(straight);
 37             straight.SetSuccessor(threeOfAKind);
 38             threeOfAKind.SetSuccessor(pairTwoPair);
 39             return straightFlush;
 40         }
 41     }
 42     public abstract class Rule
 43     {
 44         private Rule nextRule;
 45         public void SetSuccessor(Rule next)
 46         {
 47             nextRule = next;
 48         }
 49         public virtual (string, Card[]) Execute(Card[] cards)
 50         {
 51             if (nextRule != null)
 52             {
 53                 return nextRule.Execute(cards);
 54             }
 55             return ("nothing", cards.Take(5).ToArray());
 56         }
 57     }
 58
 59     public class PairTwoPairRule : Rule
 60     {
 61         public override (string, Card[]) Execute(Card[] cards)
 62         {
 63             var pairs = cards.GroupBy(x => x.number).Where(g => g.Count() >= 2).SelectMany(card => card).ToList();
 64             if (pairs.Any())
 65             {
 66                 if(pairs.Count() >= 4)
 67                 {
 68                     return ("two pair", pairs.Take(4).ToArray());
 69                 }
 70                 return ("pair", pairs.Take(2).ToArray());
 71             }
 72             return base.Execute(cards);
 73         }
 74     }
 75     public class ThreeOfAKindRule : Rule
 76     {
 77         public override (string, Card[]) Execute(Card[] cards)
 78         {
 79             var triple = cards.GroupBy(x => x.number).Where(g => g.Count() >= 3).SelectMany(card => card).ToList();
 80             if (triple.Any())
 81             {
 82                 return ("three-of-a-kind", triple.Take(3).ToArray());
 83             }
 84             return base.Execute(cards);
 85         }
 86     }
 87     public class StraightRule : Rule
 88     {
 89         public override (string, Card[]) Execute(Card[] cards)
 90         {
 91             for (int i = 0; i < cards.Length - 4; i++)
 92             {
 93                 List<Card> rtnList = new List<Card>() { cards[i] }; //  "A","J","10" "9", "9", "8", "7"
 94                 int counter = 4;
 95                 int j = i;
 96                 while (counter >= 0 && j < cards.Length - 1)
 97                 {
 98                     if (cards[j].value - cards[j + 1].value == 1)
 99                     {
100                         rtnList.Add(cards[j + 1]);
101
102                         if (rtnList.Count() == 5)
103                         {
104                             return ("straight", rtnList.ToArray());
105                         }
106                         counter--;
107                         j++;
108                     }
109                     else if (cards[j].value - cards[j + 1].value == 0)
110                     {
111                         j++;
112                     }
113                     else
114                     {
115                         break;
116                     }
117                 }
118             }
119             return base.Execute(cards);
120         }
121     }
122     public class FlushRule : Rule
123     {
124         public override (string, Card[]) Execute(Card[] cards)
125         {
126             var flush = cards.GroupBy(x => x.suit).Where(g => g.Count() >= 5).SelectMany(card => card).ToList();
127             if (flush.Any())
128             {
129                 return ("flush", flush.ToArray());
130             }
131             return base.Execute(cards);
132         }
133     }
134
135     public class FullHouseRule : Rule
136     {
137         public override (string, Card[]) Execute(Card[] cards)
138         {
139             var triple = new ThreeOfAKindRule();
140             var pair = new PairTwoPairRule();
141
142             var powerhands = triple.Execute(cards);
143             if (!powerhands.Item1.Equals("nothing"))
144             {
145                 if (powerhands.Item2.Count() == 6) // then 2 three of a kind found
146                 {
147                     return ("full house", powerhands.Item2.Take(5).ToArray());
148                 }
149                 var remainderHand = cards.Where(x => !powerhands.Item2.Any(y => y.Equals(x))).ToArray();
150                 var pairHand = pair.Execute(remainderHand);
151                 if (!pairHand.Item1.Equals("nothing"))
152                 {
153                     var fullhouseHand = powerhands.Item2.Concat(pairHand.Item2.Take(2)).ToArray();
154                     return ("full house", fullhouseHand.Take(5).ToArray());
155                 }
156             }
157             return base.Execute(cards);
158         }
159     }
160     public class FourOfAKindRule : Rule
161     {
162         public override (string, Card[]) Execute(Card[] cards)
163         {
164             var fourOfAKind = cards.GroupBy(x => x.number).Where(g => g.Count() >= 4).SelectMany(card => card).ToList();
165             if (fourOfAKind.Any())
166             {
167                 return ("four-of-a-kind", fourOfAKind.Take(4).ToArray());
168             }
169             return base.Execute(cards);
170         }
171     }
172     public class StraightFlushRule : Rule
173     {
174         public override (string, Card[]) Execute(Card[] cards)
175         {
176             var flushRule = new FlushRule();
177             var straightRule = new StraightRule();
178             var flushHand = flushRule.Execute(cards);
179             var straightHand = straightRule.Execute(flushHand.Item2);
180             if (!straightHand.Item1.Equals("nothing") && !flushHand.Item1.Equals("nothing"))
181             {
182                 return ("straight-flush", straightHand.Item2.Take(5).ToArray());
183             }
184             return base.Execute(cards);
185         }
186     }
187
188     public class Card{
189         public String number { get; set; }
190         public int value { get; set; }
191         public char suit { get; set; }
192         public Dictionary<char, int> mapping = new Dictionary<char, int>()
193         {
194             { 'A',14 },
195             { 'K',13 },
196             { 'Q',12 },
197             { 'J',11 },
198             { '1', 10}
199         };
200         public Card(String s)
201         {
202             number = (s[0] == '1')? "10": Char.ToString(s[0]);
203             value = mapping.ContainsKey(s[0])? mapping[s[0]]: (int) Char.GetNumericValue(s[0]);
204             suit = s[s.Length-1];
205         }
206         public override string ToString()
207         {
208             return number.ToString();
209         }
210
211         public bool equals(Card s)
212         {
213             return this.value == s.value && this.suit.Equals(s.suit);
214         }
215     }

测试用例：

  1 namespace Solution
  2 {
  3     using NUnit.Framework;
  4     using System;
  5     using System.Collections.Generic;
  6     using System.Diagnostics;
  7     using System.Linq;
  8     using System.Text;
  9
 10     [TestFixture]
 11     public class SolutionTest
 12     {
 13         #region Sample Tests
 14
 15         [Test(Description = "Fixed Tests")]
 16         public void FixedTests()
 17         {
 18             SampleTest(("nothing",         new[] { "A", "K", "Q", "J", "9" }),  new[] { "K", "A" },  new[] { "J", "Q", "9", "2", "3" });
 19             SampleTest(("pair",            new[] { "Q", "K", "J", "9" }),       new[] { "K", "Q" },  new[] { "J", "Q", "9", "2", "3" });
 20             SampleTest(("two pair",        new[] { "K", "J", "9" }),            new[] { "K", "J" },  new[] { "J", "K", "9", "2", "3" });
 21             SampleTest(("three-of-a-kind", new[] { "Q", "J", "9" }),            new[] { "4", "9" },  new[] { "J", "Q", "Q", "2", "Q" });
 22             SampleTest(("straight",        new[] { "K", "Q", "J", "10", "9" }), new[] { "Q", "2" },  new[] { "J", "10", "9", "K", "3" });
 23             SampleTest(("flush",           new[] { "Q", "J", "10", "5", "3" }), new[] { "A", "K" },  new[] { "J", "5", "10", "Q", "3" });
 24             SampleTest(("full house",      new[] { "A", "K" }),                 new[] { "A", "A" },  new[] { "K", "K", "A", "Q", "3" });
 25             SampleTest(("four-of-a-kind",  new[] { "2", "3" }),                 new[] { "2", "3" },  new[] { "2", "2", "3", "3", "2" });
 26             SampleTest(("straight-flush",  new[] { "J", "10", "9", "8", "7" }), new[] { "8", "6" },  new[] { "7", "5", "9", "J", "10" });
 27         }
 28
 29         private static void SampleTest((string type, string[] ranks) expected, string[] holeCards, string[] communityCards)
 30         {
 31             var actual = Act(holeCards, communityCards);
 32             Verify(expected, actual, holeCards, communityCards);
 33         }
 34
 35         #endregion
 36
 37         private static readonly StringBuilder template = new StringBuilder();
 38         private static readonly StringBuilder buffer = new StringBuilder();
 39         private static readonly string[] ranks = new string[] { "A", "K", "Q", "J", "10", "9", "8", "7", "6", "5", "4", "3", "2" };
 40         private static readonly string[] types = new string[] { "straight-flush", "four-of-a-kind", "full house", "flush", "straight", "three-of-a-kind", "two pair", "pair", "nothing" };
 41         private static readonly Dictionary<string, int> ranksLookup = ranks.ToDictionary(x => x, x => Array.FindIndex(ranks, y => y == x));
 42         private static string Show(string str) => $@"""{str}""";
 43         private static string ShowSeq(IEnumerable<string> seq) => $"[{string.Join(", ", seq.Select(Show))}]";
 44         private static (string type, string[] ranks) Act(string[] holeCards, string[] communityCards) => Edm.Hand(holeCards.Select(m=>m).ToArray(), communityCards.Select(m=>m).ToArray());
 45
 46         private static string Error(string message)
 47         {
 48             buffer.Clear();
 49             buffer.Append(template.ToString());
 50             buffer.AppendLine($"Error: {message}");
 51             return buffer.ToString();
 52         }
 53
 54         private static void Verify(
 55             (string type, string[] ranks) expected, (string type, string[] ranks) actual, string[] holeCards, string[] communityCards)
 56         {
 57             Debug.Assert(holeCards.Concat(communityCards).Distinct().Count() == 7, "Invalid input");
 58             template.Clear();
 59             template.AppendLine($"\tHole cards: {ShowSeq(holeCards)}");
 60             template.AppendLine($"\tCommunity cards: {ShowSeq(communityCards)}");
 61             template.AppendLine($"Expected: (type: {Show(expected.type)}, ranks: {ShowSeq(expected.ranks)})");
 62             Assert.IsNotNull(actual.type, Error("Type must not be null"));
 63             Assert.IsNotNull(actual.ranks, Error("Ranks must not be null"));
 64             template.AppendLine($"Actual: (type: {Show(actual.type)}, ranks: {ShowSeq(actual.ranks)})");
 65             Assert.IsTrue(types.Any(x => string.Equals(x, actual.type)),
 66                 Error($"{Show(actual.type)} is not valid, valid options are: {ShowSeq(types)}"));
 67             Assert.AreEqual(expected.type, actual.type, Error("Type is incorrect"));
 68             Assert.AreEqual(expected.ranks.Length, actual.ranks.Length, Error("Number of ranks is incorrect"));
 69             for (var i = 0; i < expected.ranks.Length; i++)
 70                 Assert.IsTrue(ranks.Any(x => string.Equals(x, actual.ranks[i])),
 71                     Error($"{Show(actual.ranks[i])} is not valid, valid options are: {ShowSeq(ranks)}"));
 72             for (var i = 0; i < expected.ranks.Length; i++)
 73                 Assert.AreEqual(expected.ranks[i], actual.ranks[i], Error($"Rank at position {i} is incorrect"));
 74         }
 75
 76         #region Test Cases
 77
 78         private static readonly string[] suits = new string[] { "", "", "", "" };
 79         private static Dictionary<string, int> stats = new Dictionary<string, int>();
 80
 81         [Test(Description = "Fixed Edge Case Tests")]
 82         public void FixedEdgeCaseTests()
 83         {
 84             // ace low straight invalidated
 85             SampleTest(("nothing", new[] { "A", "8", "7", "5", "4" }), new[] { "A", "2" }, new[] { "3", "4", "5", "7", "8" });
 86             // non straight around
 87             SampleTest(("nothing", new[] { "A", "K", "8", "7", "4" }), new[] { "A", "K" }, new[] { "3", "4", "2", "7", "8" });
 88
 89             // pair on board
 90             SampleTest(("pair", new[] { "4", "A", "9", "7" }), new[] { "A", "2" }, new[] { "3", "4", "9", "7", "4" });
 91             // pair made with 1 hole card
 92             SampleTest(("pair", new[] { "4", "A", "10", "9" }), new[] { "A", "4" }, new[] { "3", "4", "9", "7", "10" });
 93             // pair made with 2 hole cards
 94             SampleTest(("pair", new[] { "4", "A", "10", "9" }), new[] { "4", "4" }, new[] { "3", "A", "9", "7", "10" });
 95
 96             // two pair on board
 97             SampleTest(("two pair", new[] { "Q", "2", "K" }), new[] { "K", "J" }, new[] { "Q", "Q", "9", "2", "2" });
 98             // two pair made with 1 hole card and 1 pair on board
 99             SampleTest(("two pair", new[] { "Q", "2", "K" }), new[] { "K", "Q" }, new[] { "J", "Q", "9", "2", "2" });
100             // two pair made with 2 hole cards
101             SampleTest(("two pair", new[] { "Q", "2", "K" }), new[] { "2", "Q" }, new[] { "J", "Q", "9", "2", "K" });
102             // two pair made with pair in hole cards and 1 pair on board
103             SampleTest(("two pair", new[] { "Q", "2", "K" }), new[] { "Q", "Q" }, new[] { "K", "J", "9", "2", "2" });
104             // two pair made with 2 hole cards, invalidating a 3th pair on board
105             SampleTest(("two pair", new[] { "K", "J", "9" }), new[] { "K", "J" }, new[] { "J", "K", "9", "2", "2" });
106
107             // three-of-a-kind on board
108             SampleTest(("three-of-a-kind", new[] { "Q", "K", "J" }), new[] { "K", "J" }, new[] { "Q", "Q", "9", "2", "Q" });
109             // three-of-a-kind made with 1 hole card and 1 pair on board
110             SampleTest(("three-of-a-kind", new[] { "Q", "K", "J" }), new[] { "K", "Q" }, new[] { "Q", "Q", "9", "2", "J" });
111             // three-of-a-kind made with 2 hole cards
112             SampleTest(("three-of-a-kind", new[] { "Q", "K", "J" }), new[] { "Q", "Q" }, new[] { "K", "Q", "9", "2", "J" });
113
114             // board straight cancels out pocket aces
115             SampleTest(("straight", new[] { "A", "K", "Q", "J", "10" }), new[] { "A", "A" }, new[] { "A", "K", "Q", "J", "10" });
116             // super straight
117             SampleTest(("straight", new[] { "A", "K", "Q", "J", "10" }), new[] { "A", "Q" }, new[] { "K", "10", "J", "9", "8" });
118             // high straight
119             SampleTest(("straight", new[] { "7", "6", "5", "4", "3" }), new[] { "6", "7" }, new[] { "3", "4", "5", "10", "10" });
120             // low straight
121             SampleTest(("straight", new[] { "6", "5", "4", "3", "2" }), new[] { "2", "3" }, new[] { "4", "5", "6", "10", "10" });
122             // outside straight
123             SampleTest(("straight", new[] { "6", "5", "4", "3", "2" }), new[] { "2", "6" }, new[] { "4", "5", "3", "10", "10" });
124             // inside straight
125             SampleTest(("straight", new[] { "6", "5", "4", "3", "2" }), new[] { "4", "3" }, new[] { "2", "5", "6", "10", "10" });
126             // interspersed straight
127             SampleTest(("straight", new[] { "6", "5", "4", "3", "2" }), new[] { "4", "2" }, new[] { "3", "5", "6", "10", "10" });
128
129             // seven deuce runner runner
130             SampleTest(("full house", new[] { "2", "7" }), new[] { "7", "2" }, new[] { "A", "K", "2", "7", "2" });
131             // full house with 2 pairs on board where pockets make the triple
132             SampleTest(("full house", new[] { "A", "K" }), new[] { "A", "A" }, new[] { "K", "K", "A", "Q", "Q" });
133             // full house with 1 pair on board where pockets make the triple
134             SampleTest(("full house", new[] { "A", "K" }), new[] { "A", "A" }, new[] { "K", "K", "A", "J", "Q" });
135             // full house with 1 hole card making triple and other making pair
136             SampleTest(("full house", new[] { "K", "A" }), new[] { "A", "K" }, new[] { "K", "K", "A", "J", "Q" });
137             // full house with better triple than board
138             SampleTest(("full house", new[] { "A", "K" }), new[] { "A", "A" }, new[] { "K", "K", "A", "Q", "K" });
139
140             // flush and straight combo
141             SampleTest(("flush", new[] { "J", "10", "9", "8", "6" }), new[] { "8", "6" }, new[] { "7", "5", "9", "J", "10" });
142             // power flush
143             SampleTest(("flush", new[] { "A", "K", "Q", "J", "9" }), new[] { "A", "Q" }, new[] { "K", "4", "J", "9", "3" });
144
145             // four-of-a-kind on board
146             SampleTest(("four-of-a-kind", new[] { "A", "K" }), new[] { "K", "9" }, new[] { "A", "A", "A", "A", "3" });
147             // four-of-a-kind with 1 hole card and triple on board
148             SampleTest(("four-of-a-kind", new[] { "A", "K" }), new[] { "K", "A" }, new[] { "9", "A", "A", "A", "3" });
149             // carré
150             SampleTest(("four-of-a-kind", new[] { "A", "K" }), new[] { "A", "A" }, new[] { "A", "A", "K", "9", "3" });
151
152             // royal flush
153             SampleTest(("straight-flush", new[] { "A", "K", "Q", "J", "10" }), new[] { "A", "Q" }, new[] { "K", "10", "J", "9", "3" });
154
155             // regression tests
156             SampleTest(("straight", new[] { "6", "5", "4", "3", "2" }), new[] { "3", "4" }, new[] { "6", "5", "2", "2", "3" });
157             SampleTest(("straight", new[] { "10", "9", "8", "7", "6" }), new[] { "6", "10" }, new[] { "9", "8", "5", "7", "9" });
158             SampleTest(("straight", new[] { "K", "Q", "J", "10", "9" }), new[] { "2", "J" }, new[] { "Q", "9", "K", "10", "J" });
159         }
160
161         [Test(Description = "Random Tests (Batch #1)")]
162         public void RandomBatch1Tests()
163         {
164             var rand = new Random((int)(DateTime.Now.Ticks % int.MaxValue));
165             var bulkSize = 500;
166             for (var i = 0; i < bulkSize; i++)
167             {
168                 var hand = GenerateRandomHand(rand);
169                 var holeCards = hand.Take(2).ToArray();
170                 var communityCards = hand.Skip(2).ToArray();
171                 Test(holeCards, communityCards);
172             }
173         }
174
175         [Test(Description = "Random Tests (Batch #2)")]
176         public void RandomBatch2Tests()
177         {
178             var rand = new Random((int)(DateTime.Now.Ticks % int.MaxValue));
179             var bulkSize = 500;
180             for (var i = 0; i < bulkSize; i++)
181             {
182                 do
183                 {
184                     var hand = GenerateRandomHand(rand);
185                     var holeCards = hand.Take(2).ToArray();
186                     var communityCards = hand.Skip(2).ToArray();
187                     var expected = Expect(holeCards, communityCards);
188
189                     if (new[] { "nothing", "pair", "two pair", "three-of-a-kind" }.Contains(expected.type))
190                     {
191                         continue;
192                     }
193                     else
194                     {
195                         Test(holeCards, communityCards);
196                         break;
197                     }
198                 } while (true);
199             }
200         }
201
202         [Test(Description = "Random Tests (Batch #3)")]
203         public void RandomBatch3Tests()
204         {
205             var rand = new Random((int)(DateTime.Now.Ticks % int.MaxValue));
206             var hands = new List<string[]>();
207             var batchSize = 100;
208             for (var i = 0; i < batchSize; i++) hands.Add(GenerateStraightFlush(rand));
209             for (var i = 0; i < batchSize; i++) hands.Add(GenerateFourOfAKind(rand));
210             for (var i = 0; i < batchSize; i++) hands.Add(GenerateFullHouse(rand));
211             for (var i = 0; i < batchSize; i++) hands.Add(GenerateFlush(rand));
212             for (var i = 0; i < batchSize; i++) hands.Add(GenerateStraight(rand));
213             hands = hands.Select(x => x.OrderBy(y => rand.Next()).ToArray()).OrderBy(x => rand.Next()).ToList();
214             foreach (var hand in hands)
215             {
216                 var holeCards = hand.Take(2).ToArray();
217                 var communityCards = hand.Skip(2).ToArray();
218                 Test(holeCards, communityCards);
219             }
220         }
221
222         private static Dictionary<int, (string rank, string suit, int id)> Deck()
223         {
224             var id = 0;
225             var hand = new List<string>();
226             return (from suit in suits
227                     from rank in ranks
228                     select (rank, suit, id: id++)).ToDictionary(x => x.id);
229         }
230
231         private static void RemoveSuit(Dictionary<int, (string rank, string suit, int id)> deck, int suit)
232         {
233             var list = deck.Values.Where(card => card.id / ranks.Length == suit).ToList();
234             foreach (var card in list)
235             {
236                 deck.Remove(card.id);
237             }
238         }
239
240         private static void RemoveRank(Dictionary<int, (string rank, string suit, int id)> deck, int rank)
241         {
242             var list = deck.Values.Where(card => card.id % ranks.Length == rank).ToList();
243             foreach (var card in list)
244             {
245                 deck.Remove(card.id);
246             }
247         }
248
249         private static (string rank, string suit, int id) RandomCard(Dictionary<int, (string rank, string suit, int id)> deck, Random rand)
250         {
251             return deck.Skip(rand.Next(0, deck.Count)).First().Value;
252         }
253
254         private static string[] GenerateRandomHand(Random rand)
255         {
256             var hand = new List<string>();
257             var deck = Deck();
258
259             while (hand.Count < 7)
260             {
261                 var next = RandomCard(deck, rand);
262                 deck.Remove(next.id);
263                 hand.Add($"{next.rank}{next.suit}");
264             }
265
266             return hand.ToArray();
267         }
268
269         private static string[] GenerateStraightFlush(Random rand)
270         {
271             var hand = new List<string>();
272             var deck = Deck();
273             var suit = rand.Next(0, suits.Length);
274             var rank = rand.Next(0, ranks.Length - 5);
275             var head = suit * ranks.Length + rank;
276             // 5 cards make the straight flush
277             for (var i = 0; i < 5; i++)
278             {
279                 var current = head + i;
280                 var card = deck[current];
281                 deck.Remove(current);
282                 hand.Add($"{card.rank}{card.suit}");
283             }
284             // any 2 other cards may be added
285             for (var i = 0; i < 2; i++)
286             {
287                 var card = RandomCard(deck, rand);
288                 deck.Remove(card.id);
289                 hand.Add($"{card.rank}{card.suit}");
290             }
291             return hand.ToArray();
292         }
293
294         private static string[] GenerateFourOfAKind(Random rand)
295         {
296             var hand = new List<string>();
297             var deck = Deck();
298             var rank = rand.Next(0, ranks.Length);
299             var head = rank;
300             // 4 cards make the four-of-a-kind
301             for (var i = 0; i < 4; i++)
302             {
303                 var current = head + i * ranks.Length;
304                 var card = deck[current];
305                 deck.Remove(current);
306                 hand.Add($"{card.rank}{card.suit}");
307             }
308             // any 3 other cards may be added
309             for (var i = 0; i < 3; i++)
310             {
311                 var card = RandomCard(deck, rand);
312                 deck.Remove(card.id);
313                 hand.Add($"{card.rank}{card.suit}");
314             }
315             return hand.ToArray();
316         }
317
318         private static string[] GenerateFullHouse(Random rand)
319         {
320             var hand = new List<string>();
321             var deck = Deck();
322             var rank = rand.Next(0, ranks.Length);
323             var head = rank;
324             // 3 cards make the triple
325             for (var i = 0; i < 3; i++)
326             {
327                 var current = head + i * ranks.Length;
328                 var card = deck[current];
329                 deck.Remove(current);
330                 hand.Add($"{card.rank}{card.suit}");
331             }
332             // remaining rank would result in a four-of-a-kind
333             RemoveRank(deck, rank);
334             // 2 cards make a pair
335             var rank2 = Array.IndexOf(ranks, RandomCard(deck, rand).rank);
336             var head2 = rank2;
337             for (var i = 0; i < 2; i++)
338             {
339                 var current = head2 + i * ranks.Length;
340                 var card = deck[current];
341                 deck.Remove(current);
342                 hand.Add($"{card.rank}{card.suit}");
343             }
344             // remaining rank would result in a three-of-a-kind
345             RemoveRank(deck, rank2);
346             // any 2 other cards may be added
347             for (var i = 0; i < 2; i++)
348             {
349                 var card = RandomCard(deck, rand);
350                 deck.Remove(card.id);
351                 hand.Add($"{card.rank}{card.suit}");
352             }
353             return hand.ToArray();
354         }
355
356         private static string[] GenerateFlush(Random rand)
357         {
358             var hand = new List<string>();
359             var deck = Deck();
360             var primaryDeck = Deck();
361             var suit = rand.Next(0, suits.Length);
362             for (var i = 0; i < 4; i++)
363             {
364                 if (i != suit) RemoveSuit(primaryDeck, i);
365             }
366             // 5 cards make a flush
367             for (var i = 0; i < 5; i++)
368             {
369                 var card = RandomCard(primaryDeck, rand);
370                 primaryDeck.Remove(card.id);
371                 deck.Remove(card.id);
372                 hand.Add($"{card.rank}{card.suit}");
373             }
374             // any 2 other cards may be added
375             // small chance on straight flush, but that's ok
376             for (var i = 0; i < 2; i++)
377             {
378                 var card = RandomCard(deck, rand);
379                 deck.Remove(card.id);
380                 hand.Add($"{card.rank}{card.suit}");
381             }
382             return hand.ToArray();
383         }
384
385         private static string[] GenerateStraight(Random rand)
386         {
387             var hand = new List<string>();
388             var deck = Deck();
389             var rank = rand.Next(0, ranks.Length - 5);
390             var head = rank;
391             // 5 cards make the straight
392             for (var i = 0; i < 5; i++)
393             {
394                 var suit = rand.Next(0, suits.Length);
395                 var current = head + i + suit * ranks.Length;
396                 var card = deck[current];
397                 deck.Remove(current);
398                 hand.Add($"{card.rank}{card.suit}");
399             }
400             // any 2 other cards may be added
401             // small chance on straight flush, but that's ok
402             for (var i = 0; i < 2; i++)
403             {
404                 var card = RandomCard(deck, rand);
405                 deck.Remove(card.id);
406                 hand.Add($"{card.rank}{card.suit}");
407             }
408             return hand.ToArray();
409         }
410
411         private static void Test(string[] holeCards, string[] communityCards)
412         {
413             var expected = Expect(holeCards, communityCards);
414             var actual = Act(holeCards, communityCards);
415             Verify(expected, actual, holeCards, communityCards);
416             if (!stats.TryGetValue(expected.type, out var cnt)) cnt = 0;
417             stats[expected.type] = cnt + 1;
418         }
419
420         private static (string type, string[] ranks) Expect(string[] holeCards, string[] communityCards)
421         {
422             var cards = holeCards.Concat(communityCards).Select(Parse).OrderBy(x => ranksLookup[x.rank]).ToArray();
423             var cardsByRank = cards.ToLookup(x => x.rank);
424             var cardsBySuit = cards.ToLookup(x => x.suit);
425             var ans = findStraightFlush();
426             if (ans == null) ans = findFourOfAKind();
427             if (ans == null) ans = findFullHouse();
428             if (ans == null) ans = findFlush();
429             if (ans == null) ans = findStraight();
430             if (ans == null) ans = findThreeOfAKind();
431             if (ans == null) ans = findTwoPair();
432             if (ans == null) ans = findPair();
433             if (ans == null) ans = findNothing();
434             return ans.GetValueOrDefault(default);
435
436             (string rank, string suit) Parse(string card) => (card.Substring(0, card.Length - 1), card.Substring(card.Length - 1, 1));
437
438             (string type, string[] ranks)? findStraightFlush()
439             {
440                 var flush = cardsBySuit.SingleOrDefault(x => x.Count() >= 5)?.ToArray();
441                 if (flush == null) return null;
442                 for (var i = 0; i + 4 < flush.Length; i++)
443                 {
444                     var match = true;
445                     for (var j = 1; j <= 4; j++)
446                     {
447                         if (!flush.Any(card => ranksLookup[card.rank] == ranksLookup[flush[i].rank] + j))
448                         {
449                             match = false;
450                             break;
451                         }
452                     }
453                     if (match) return ("straight-flush", Enumerable.Range(0, 5).Select(k => ranks[k + ranksLookup[flush[i].rank]]).ToArray());
454                 }
455                 return null;
456             }
457
458             (string type, string[] ranks)? findFourOfAKind()
459             {
460                 var t4_cards = cardsByRank.SingleOrDefault(x => x.Count() == 4);
461                 if (t4_cards == null) return null;
462                 var t4 = t4_cards.First().rank;
463                 var h1 = cardsByRank.First(x => x.Key != t4).Key;
464                 return ("four-of-a-kind", new[] { t4, h1 });
465             }
466
467             (string type, string[] ranks)? findFullHouse()
468             {
469                 var t3_set = cardsByRank.Where(x => x.Count() == 3);
470                 if (!t3_set.Any()) return null;
471                 var t3 = t3_set.First().First().rank;
472                 var t2_ranks = cardsByRank.Where(x => x.Count() == 2).Select(x => x.Key).ToList();
473                 if (t3_set.Count() > 1) t2_ranks.Add(t3_set.Skip(1).First().Key);
474                 if (!t2_ranks.Any()) return null;
475                 var t2 = t2_ranks.OrderBy(x => ranksLookup[x]).First();
476                 return ("full house", new[] { t3, t2 });
477             }
478
479             (string type, string[] ranks)? findFlush()
480             {
481                 var flush = cardsBySuit.SingleOrDefault(x => x.Count() >= 5)?.ToArray();
482                 if (flush == null) return null;
483                 return ("flush", flush.Take(5).Select(x => x.rank).ToArray());
484             }
485
486             (string type, string[] ranks)? findStraight()
487             {
488                 for (var i = 0; i + 4 < cards.Length; i++)
489                 {
490                     var match = true;
491                     for (var j = 1; j <= 4; j++)
492                     {
493                         if (!cards.Any(card => ranksLookup[card.rank] == ranksLookup[cards[i].rank] + j))
494                         {
495                             match = false;
496                             break;
497                         }
498                     }
499                     if (match) return ("straight", Enumerable.Range(0, 5).Select(k => ranks[k + ranksLookup[cards[i].rank]]).ToArray());
500                 }
501                 return null;
502             }
503
504             (string type, string[] ranks)? findThreeOfAKind()
505             {
506                 var t3_cards = cardsByRank.SingleOrDefault(x => x.Count() == 3);
507                 if (t3_cards == null) return null;
508                 var t3 = t3_cards.First().rank;
509                 var h1 = cardsByRank.First(x => x.Key != t3).Key;
510                 var h2 = cardsByRank.First(x => x.Key != t3 && x.Key != h1).Key;
511                 return ("three-of-a-kind", new[] { t3, h1, h2 });
512             }
513
514             (string type, string[] ranks)? findTwoPair()
515             {
516                 var t2_set = cardsByRank.Where(x => x.Count() == 2);
517                 if (t2_set.Count() < 2) return null;
518                 var t2_high = t2_set.First().First().rank;
519                 var t2_low = t2_set.Skip(1).First().First().rank;
520                 var h1 = cardsByRank.First(x => x.Key != t2_high && x.Key != t2_low).Key;
521                 return ("two pair", new[] { t2_high, t2_low, h1 });
522             }
523
524             (string type, string[] ranks)? findPair()
525             {
526                 var t2_cards = cardsByRank.SingleOrDefault(x => x.Count() == 2);
527                 if (t2_cards == null) return null;
528                 var t2 = t2_cards.First().rank;
529                 var h1 = cardsByRank.First(x => x.Key != t2).Key;
530                 var h2 = cardsByRank.First(x => x.Key != t2 && x.Key != h1).Key;
531                 var h3 = cardsByRank.First(x => x.Key != t2 && x.Key != h1 && x.Key != h2).Key;
532                 return ("pair", new[] { t2, h1, h2, h3 });
533             }
534
535             (string type, string[] ranks) findNothing()
536             {
537                 return ("nothing", cards.Take(5).Select(x => x.rank).ToArray());
538             }
539         }
540
541         #endregion
542     }
543 }