Покер. Консольное приложение. Два игрока

using System;
using System.IO;
 
namespace Poker
{
    class Program
    {
        static Game game;
        static StreamWriter file;
 
        static void Main(string[] args)
        {
            game = new Game();
 
            //for (int j = 0; j < 10000; j++)
            //{
 
            // Don't make it more than 10 players 
            int numberOfPlayers = 2;
 
            for (int i = 0; i < numberOfPlayers; i++)
            {
                var cards = game.DealCards();
                var summary = game.GetHandSummary(cards);
 
                Write(summary.Item2, true);
 
                foreach (Card card in cards)
                {
                    string suit = GetSuitSign(card.GetSuit());
                    string content = card.GetRank() + suit + ", ";
                    Write(content, false);
                }
 
                Write(string.Empty, true);
            }
 
            //game.Reset();
 
            //Write(string.Empty, true);
            //}
 
            file.Close();
            Console.ReadLine();
        }
 
        static string GetSuitSign(char suit)
        {
            string suitSign = string.Empty;
 
            switch (suit.ToString())
            {
                case "S":
                    suitSign = "♠";
                    break;
                case "H":
                    suitSign = "♥";
                    break;
                case "C":
                    suitSign = "♣";
                    break;
                case "D":
                    suitSign = "♦";
                    break;
                default:
                    throw new NotImplementedException();
            }
 
            return suitSign;
        }
 
        static StreamWriter CreateFile()
        {
            string path = Environment.GetFolderPath(Environment.SpecialFolder.Desktop);
            return new System.IO.StreamWriter(path + @"\test.txt");
        }
 
        static void Write(string text, bool moveToNewLine)
        {
            file = file ?? CreateFile();
 
            if (moveToNewLine)
            {
                Console.WriteLine(text);
                file.WriteLine(text);
            }
            else
            {
                Console.Write(text);
                file.Write(text);
            }
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
 
namespace Poker
{
    class Game
    {
        IList<Card> cards;
        ICollection<Card> cardsCopy;
        const int deckSize = 52;
        const int suitSize = 4;
        const int rankSize = deckSize / suitSize;
        const int cardsInHand = 5;
        Dictionary<int, char> rankMap;
        Dictionary<int, char> suitMap;
        IList<MethodInfo> combinations;
        Dictionary<int, int> rankOutput;
        Dictionary<char, int> suitOutput;
        Random random = new Random();
 
        public Game()
        {          
            InitializeRankMap();
            InitializeSuitMap();
            InitializeDeck();
 
            InitializeCombinations();
        }
 
        private void InitializeDeck()
        {
            cards = new List<Card>();
            cardsCopy = new HashSet<Card>();
 
            foreach (char rank in rankMap.Values)
            {
                foreach (char suit in suitMap.Values)
                {
                    Card card = new Card(rank, suit);
                    cards.Add(card);
                    cardsCopy.Add(card);
                }
            }
        }
 
        private void InitializeRankMap()
        {
            rankMap = new Dictionary<int, char>();
            
            for (int i = 1; i < 9; i++)
            {
                rankMap.Add(i, (i + 1).ToString().ToCharArray().First());
            }
 
            rankMap.Add(9, 'T');
            rankMap.Add(10, 'J');
            rankMap.Add(11, 'Q');
            rankMap.Add(12, 'K');
            rankMap.Add(13, 'A');
        }
 
        private void InitializeSuitMap()
        {
            suitMap = new Dictionary<int, char>();
            suitMap.Add(0, 'S');
            suitMap.Add(1, 'H');
            suitMap.Add(2, 'C');
            suitMap.Add(3, 'D');
        }
 
        public ICollection<Card> DealCards()
        {
            var cardsToDeal = new HashSet<Card>();
 
            for (int i = 0; i < cardsInHand; i++)
            {
                int index = random.Next(0, cards.Count);
 
                if (index > cards.Count - 1)
                {
                    throw new IndexOutOfRangeException();
                }
 
                Card card = new Card(cards[index]);
                cardsToDeal.Add(card);
 
                cards.RemoveAt(index);
            }
 
            return cardsToDeal;
        }
 
        public Tuple<bool, string> GetHandSummary(ICollection<Card> playerCards)
        {
            if (playerCards.Count != cardsInHand)
            {
                throw new ArgumentOutOfRangeException();
            }
 
            rankOutput = CalculateRankOutput(playerCards);
            suitOutput = CalculateSuitOutput(playerCards);
 
            foreach (var combination in combinations)
            {
                var tuple = (Tuple<bool, string>)combination.Invoke(this, new object[] { playerCards });
 
                if (tuple.Item1)
                {
                    return tuple;
                }
            }
 
            return new Tuple<bool, string>(true, "High Card");
        }
 
        private void InitializeCombinations()
        {            
            var methodInfoList = typeof(Game).GetMethodsBySignature(typeof(Tuple<bool, string>), typeof(ICollection<Card>));
            combinations = new List<MethodInfo>(methodInfoList);
        }
 
        private Tuple<bool, string> IsStraightFlush(ICollection<Card> hand)
        {
            bool isStraight = HasStraight(hand).Item1;
            bool isFlush = HasFlush(hand).Item1;
            bool isRoyalFlush = rankOutput.Min(o => o.Key) == 9;
 
            bool isStraightFlush = isStraight && isFlush;
            string name = isStraightFlush && isRoyalFlush ? "Royal Flush" : "Straight Flush";
 
            return Tuple.Create(isStraightFlush, name);
        }
 
        private Tuple<bool, string> IsFourOfKind(ICollection<Card> hand)
        {
            bool isFourOfKind = rankOutput.Where(r => r.Value == 4).Count() == 1;
            return Tuple.Create(isFourOfKind, "Four of a Kind");
        }
 
        private Tuple<bool, string> IsFullHouse(ICollection<Card> hand)
        {
            bool hasThreeOfKind = HasThreeOfKind(hand).Item1;
            bool hasPair = HasPair(hand).Item1;
 
            return Tuple.Create(hasThreeOfKind && hasPair, "Full House");
        }
 
        private Tuple<bool, string> HasFlush(ICollection<Card> hand)
        {
            bool hasFlush = suitOutput.Max(s => s.Value) == 5;
           // bool isStraight = IsStraight(hand).Item1;
 
            return Tuple.Create(hasFlush /*&& !isStraight*/, "Flush");
        }
 
        private Tuple<bool, string> HasStraight(ICollection<Card> hand)
        {
            var rankOutputCopy = new Dictionary<int, int>(rankOutput);
 
            if (rankOutputCopy.Keys.Contains(2) && rankOutputCopy.Keys.Contains(13))
            {
                int value = rankOutputCopy[13];
                rankOutputCopy.Remove(13);
                rankOutputCopy[0] = value;
            }
 
            int minRank = rankOutputCopy.Min(o => o.Key);
            int maxRank = rankOutputCopy.Max(o => o.Key);
 
            bool hasStraight = maxRank - minRank == 4;
            bool hasPair = HasPair(hand).Item1;
            bool hasTwoPair = HasTwoPair(hand).Item1;
            bool hasSet = HasThreeOfKind(hand).Item1;
            //bool hasFlush = HasFlush(hand).Item1;
 
            return Tuple.Create(hasStraight && !hasPair && !hasSet && !hasTwoPair /*&& !hasFlush*/, "Straight");
        }
 
        private Tuple<bool, string> HasThreeOfKind(ICollection<Card> hand)
        {
            bool hasThreeOfKind = rankOutput.Where(r => r.Value == 3).Count() == 1;
            //bool hasFlush = HasFlush(hand).Item1;
            //bool hasPair = HasOnePair(hand).Item1;
 
            return Tuple.Create(hasThreeOfKind /*&& !hasFlush && !hasPair*/, "Three of a Kind");
        }
 
        private Tuple<bool, string> HasTwoPair(ICollection<Card> hand)
        {
            bool hasTwoPair = rankOutput.Where(r => r.Value == 2).Count() == 2;
            //bool hasFlush = HasFlush(hand).Item1;
 
            return Tuple.Create(hasTwoPair /*&& !hasFlush*/, "Two Pair");
        }
 
        private Tuple<bool, string> HasPair(ICollection<Card> hand)
        {
            bool hasOnePair = rankOutput.Where(r => r.Value == 2).Count() == 1;
            //bool hasTwoPair = HasTwoPair(hand).Item1;
            //bool hasThreeOfKind = HasThreeOfKind(hand).Item1;
            //bool hasFlush = HasFlush(hand).Item1;
 
            return Tuple.Create(hasOnePair /*&& !isTwoPair && !isThreeOfKind && !isFlush*/, "One Pair");
        }
 
        private Dictionary<int, int> CalculateRankOutput(ICollection<Card> playerCards)
        {
            var output = new Dictionary<int, int>();
 
            foreach (Card card in playerCards)
            {
                int rank = rankMap.FirstOrDefault(x => x.Value == card.GetRank()).Key;
                int value;
                output.TryGetValue(rank, out value);
 
                output[rank] = value == 0 ? 1 : output[rank] + 1;
            }
 
            return output;
        }
 
        private Dictionary<char, int> CalculateSuitOutput(ICollection<Card> playerCards)
        {
            var output = new Dictionary<char, int>();
 
            foreach (Card card in playerCards)
            {
                char suit = card.GetSuit();
                int value;
                output.TryGetValue(suit, out value);
 
                output[suit] = value == 0 ? 1 : output[suit] + 1;
            }
 
            return output;
        }
 
        public void Reset()
        {
            InitializeDeck();
        }
    }
}

namespace Poker
{
    class Card
    {
        char rank;
        char suit;
 
        public Card(char rank, char suit)
        {
            this.rank = rank;
            this.suit = suit;          
        }
 
        public Card(Card card)
        {
            this.rank = card.rank;
            this.suit = card.suit;
        }
 
        public char GetRank()
        {
            return rank;
        }
 
        public char GetSuit()
        {
            return suit;
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
 
namespace Poker
{
    static class Helper
    {
        public static IEnumerable<MethodInfo> GetMethodsBySignature(this Type type, Type returnType, params Type[] parameterTypes)
        {
            return type.GetMethods(BindingFlags.NonPublic | BindingFlags.Instance).Where((m) =>
            {
                if (m.ReturnType != returnType)
                {
                    return false;
                }
 
                var parameters = m.GetParameters();
 
                if ((parameterTypes == null || parameterTypes.Length == 0))
                {
                    return parameters.Length == 0;
                }
 
                if (parameters.Length != parameterTypes.Length)
                {
                    return false;
                }
 
                for (int i = 0; i < parameterTypes.Length; i++)
                {
                    if (parameters[i].ParameterType != parameterTypes[i])
                    {
                        return false;
                    }
                }
 
                return true;
            });
        }
    }
}

void Main()
{
    var input = "Саша 3H, 4H, 5H, 6H, 8H ; Ваня 3C, 3D, 3S, 8C, TD";
    var result = Winner(input);
    Console.WriteLine("Победил игрок {0} (у него {1}).", result.Item1, combinations[result.Item2.Item1]);
    // Выводит: Победил игрок Саша (у него флеш).
}
 
static string[] combinations = new string[] {"старшая карта", "пара", "две пары", "тройка", "стрит", "флеш", "фул", "каре", "", "стрейт-флеш"};
Tuple<string,Tuple<int,int,int>> Winner(string input)
{
    Func<IEnumerable<string>,Tuple<int[],int[]>> parseHand = x => x.Aggregate(Tuple.Create(new int[4], new int[5]), (rs,cc) => {
        Action<int,int[],int> addToArr = null;
        addToArr = (i,a,m) => { if((a[i] & m) == 0) a[i] |= m; else addToArr(i+1, a, m); };
        addToArr(0, rs.Item1, 1 << "23456789TJQKA".IndexOf(cc[0]));
        addToArr(0, rs.Item2, 1 << "CDHS".IndexOf(cc[1]));
        return rs;
    });
    
    Func<int[],int[],Tuple<int,int,int>> handValue = (rr,ss) => {
        if(rr[3] > 0) return Tuple.Create(7,rr[3],rr[0]^rr[3]); // Four
        if(rr[2] > 0) return (rr[1]^rr[2]) > 0 ? Tuple.Create(6,rr[2],rr[1]) // FullHouse
                                               : Tuple.Create(3,rr[2],rr[0]^rr[2]); // Three
        if(rr[1] > 0) return (rr[1]&(rr[1]-1)) > 0 ? Tuple.Create(2,rr[1],rr[0]^rr[1]) // TwoPair
                                                   : Tuple.Create(1,rr[1],rr[0]^rr[1]); // Pair
        int fl = ss[4] > 0 ? 5 : 0; // Flush
        if(rr[0] == 4111) return Tuple.Create(4+fl,15,0); // Wheel
        if( (((rr[0]|(rr[0]-1))+1)&rr[0]) == 0 ) return Tuple.Create(4+fl,rr[0],0); // Straight
        return Tuple.Create(fl,rr[0],0); // HighCard
    };
    
    return input.Split(';').Select(x => x.Trim().Split(' ')).Select(x => Tuple.Create(x[0], parseHand(x.Skip(1))))
        .Select(x => Tuple.Create(x.Item1, handValue(x.Item2.Item1, x.Item2.Item2))).MaxBy(x => x.Item2);   
}