C# Online Compiler | .NET Fiddle

<no name> by Anonymous

using System;
using System.Linq;
using System.Collections.Generic;

public class Program
{
	public void Main(string[] args)
	{
		Deck d = new Deck(3);

            d.ShowCards();
	}

	public class Deck
	{
		     private Random rnd;
        private List<Card> DeckCards { get; set; }
        private int PlayerCount { get; set; }
        public Deck(int playerCount)
        {
            rnd = new Random();
            List<Card> result = new List<Card>();
            for (int i = 2; i <= 14; i++)
            {
                result.Add(new Card(i, Suit.Club));
                result.Add(new Card(i, Suit.Diamond));
                result.Add(new Card(i, Suit.Heart));
                result.Add(new Card(i, Suit.Spade));
            }
            DeckCards = result;
            SetCards();
            CreatePlayerHands(playerCount);
            PlayerCount = playerCount;
        }

        public void CreatePlayerHands(int count)
        {
            if (count < 1 || count > 10)
                throw new IndexOutOfRangeException();
            for (int i = 1; i <= count; i++)
            {
                SetCards(i);
            }
        }

        public void ShowCards()
        {
            Console.WriteLine("Flop:");
            foreach (Card c in DeckCards.Where(x => x.UsedByPlayerID == 0))
            {
                c.ConsoleOutput();
            }
            Console.WriteLine();
            for (int i = 1; i <= PlayerCount; i++)
            {
                HandResult result = GetHandResult(i);
                Console.Write("Player #" + i + "\t(" + result.result + " ");
                foreach (Card cResult in result.resultCards)
                {
                    cResult.ConsoleOutput();
                }
                Console.Write(")");
                Console.WriteLine();
                foreach (Card c in DeckCards.Where(x => x.UsedByPlayerID == i))
                {
                    c.ConsoleOutput();
                }
                Console.WriteLine();
            }
        }

        private IOrderedEnumerable<Card> GetPlayerSet(int playerID)
        {
            return DeckCards.Where(x => x.UsedByPlayerID == 0 || x.UsedByPlayerID == playerID).OrderByDescending(x => x.Face);
        }

        private void SetCards(int? playerID = null)
        {
            IEnumerable<Card> playerCards = DeckCards.Where(x => !x.UsedByPlayerID.HasValue).OrderBy(x => rnd.Next()).Take(playerID.HasValue ? 2 : 5);
            foreach (Card c in playerCards)
            {
                c.UsedByPlayerID = playerID.HasValue ? playerID : 0;
            }
        }

        public class HandResult
        {
            public Hand result { get; set; }
            public IEnumerable<Card> resultCards { get; set; }
        }

        public HandResult GetHandResult(int playerID)
        {
            IEnumerable<Card> set = GetPlayerSet(playerID).OrderBy(x => x.Face);
            if (GetRoyalFlush(set).Any())
            {
                return new HandResult() { result = Hand.RoyalFlush, resultCards = GetRoyalFlush(set) };
            }
            else if (GetStraightFlush(set).Any())
            {
                return new HandResult() { result = Hand.StraightFlush, resultCards = GetStraightFlush(set) };
            }
            else if (GetFourOfAKind(playerID).Any())
            {
                return new HandResult() { result = Hand.FourOfAKind, resultCards = GetFourOfAKind(playerID) };
            }
            else if (GetFullHouse(set).Any())
            {
                return new HandResult() { result = Hand.FullHouse, resultCards = GetFullHouse(set) };
            }
            else if (GetFlush(set).Any())
            {
                return new HandResult() { result = Hand.Flush, resultCards = GetFlush(set) };
            }
            else if (GetStraight(set).Any())
            {
                return new HandResult() { result = Hand.Straight, resultCards = GetStraight(set) };
            }
            else if (GetThreeOfAKind(set).Any())
            {
                return new HandResult() { result = Hand.ThreeOfAKind, resultCards = GetThreeOfAKind(set) };
            }
            else if (GetTwoPair(set).Any())
            {
                return new HandResult() { result = Hand.TwoPair, resultCards = GetTwoPair(set) };
            }
            else if (GetOnePair(set).Any())
            {
                return new HandResult() { result = Hand.OnePair, resultCards = GetOnePair(set) };
            }
            else
            {
                return new HandResult() { result = Hand.HighCard, resultCards = GetPlayerSet(playerID).OrderByDescending(x => x.Face).Take(5) };
            }
        }

        private IEnumerable<Card> GetRoyalFlush(IEnumerable<Card> set)
        {
            IEnumerable<Card> straightflush = GetStraightFlush(set);
            return straightflush.Any(x => x.Face == 14 && x.Face == 13) ? straightflush : Enumerable.Empty<Card>();
        }

        private IEnumerable<Card> GetStraightFlush(IEnumerable<Card> set)
        {
            IEnumerable<Card> flush = set.GroupBy(x => x.Suit).Where(x => x.Count() >= 5).SingleOrDefault() ?? Enumerable.Empty<Card>();
            return GetStraight(flush);
        }

        private IEnumerable<Card> GetFourOfAKind(int playerID)
        {
            return GetPlayerSet(playerID).GroupBy(x => x.Face).SingleOrDefault(x => x.Count() >= 4) ?? Enumerable.Empty<Card>(); ;
        }

        private IEnumerable<Card> GetFullHouse(IEnumerable<Card> set)
        {
            IEnumerable<Card> threeOfAKind = GetThreeOfAKind(set);
            if (threeOfAKind.Any())
            {
                IEnumerable<Card> remainingCards = set.Where(x => !threeOfAKind.Any(y => y.Face == x.Face && y.Suit == x.Suit));
                IEnumerable<Card> highestTwoPair = remainingCards.GroupBy(x => x.Face).Where(x => x.Count() >= 2).OrderByDescending(x => x.Key).FirstOrDefault() ?? Enumerable.Empty<Card>(); ;
                if (highestTwoPair.Any())
                {
                    return threeOfAKind.Concat(highestTwoPair.Take(2));
                }
            }
            return Enumerable.Empty<Card>();
        }

        private IEnumerable<Card> GetFlush(IEnumerable<Card> set)
        {
            return set.GroupBy(x => x.Suit).Where(x => x.Count() >= 5).SelectMany(x => x.OrderByDescending(y => y.Face).Take(5));
        }

        private IEnumerable<Card> GetThreeOfAKind(IEnumerable<Card> set)
        {
            return set.GroupBy(x => x.Face).OrderByDescending(x => x.Key).FirstOrDefault(x => x.Count() == 3) ?? Enumerable.Empty<Card>(); ;
        }

        private IEnumerable<Card> GetTwoPair(IEnumerable<Card> set)
        {
            var pairs =  set.GroupBy(x => x.Face).Where(x => x.Count() == 2);
            return pairs.Count() >= 2 ? pairs.OrderByDescending(x => x.Key).Take(2).SelectMany(x => x) : Enumerable.Empty<Card>();
        }

        private IEnumerable<Card> GetOnePair(IEnumerable<Card> set)
        {
            return set.GroupBy(x => x.Face).SingleOrDefault(x => x.Count() >= 2) ?? Enumerable.Empty<Card>(); ;
        }
   
        private IEnumerable<Card> GetStraight(IEnumerable<Card> set)
        {
            if (set.Any())
            {                
                bool isAceStraight = !new List<int>() { 14, 2, 3, 4, 5 }.Except(set.Select(x => x.Face)).Any();
                if (isAceStraight)
                {
                    return set.Where(x => new List<int>() { 14, 2, 3, 4, 5 }.Contains(x.Face)).GroupBy(x => x.Face).Select(x => x.First());
                }
                int? temp = null;
                int conseductiveIndex = 0;
                for (int i = 0; i < set.Count(); i++)
                {
                    if (temp.HasValue)
                    {
                        if (temp != set.ElementAt(i).Face - 1)
                        {
                            conseductiveIndex = i;
                        }
                        if (i - conseductiveIndex == 4)
                        {
                            return set.Skip(conseductiveIndex).Take(5);
                        }
                    }
                    temp = set.ElementAt(i).Face;
                }
            }
            return Enumerable.Empty<Card>();
        }


        public enum Hand { RoyalFlush, StraightFlush, FourOfAKind, FullHouse, Flush, Straight, ThreeOfAKind, TwoPair, OnePair, HighCard }
        public enum Suit { Heart, Diamond, Spade, Club }

        public class Card
        {
            public Card(int face, Suit suit)
            {
                Suit = suit;
                Face = face;
            }
            public Suit Suit { get; set; }
            public int Face { get; set; }
            public int? UsedByPlayerID { get; set; }

            public void ConsoleOutput()
            {
                //Console.OutputEncoding = System.Text.Encoding.UTF8;
                char club = '\u2663', spade = '\u2660', diamond = '\u2666', heart = '\u2665';
                //Console.BackgroundColor = ConsoleColor.White;
                string face = GetFace(Face).PadLeft(2);
                switch (Suit)
                {
                    case Suit.Diamond:
                        //Console.ForegroundColor = ConsoleColor.Red;
                        Console.Write(face + diamond);
                        break;
                    case Suit.Heart:
                        //Console.ForegroundColor = ConsoleColor.Red;
                        Console.Write(face + heart);
                        break;
                    case Suit.Club:
                        //Console.ForegroundColor = ConsoleColor.Black;
                        Console.Write(face + club);
                        break;
                    case Suit.Spade:
                        //Console.ForegroundColor = ConsoleColor.Black;
                        Console.Write(face + spade);
                        break;
                }
                //Console.ResetColor();
                Console.Write(" ");
            }
			
            private string GetFace(int face)
            {
                switch (face)
                {
                    case 11:
                        return "J";
                    case 12:
                        return "Q";
                    case 13:
                        return "K";
                    case 14:
                        return "A";
                    default:
                        return face.ToString();
                }
            }
        }
	}
}

​x
 
using System;
using System.Linq;
using System.Collections.Generic;
​
public class Program
{
    public void Main(string[] args)
    {
        Deck d = new Deck(3);
​
            d.ShowCards();
    }
​
    public class Deck
    {
             private Random rnd;
        private List<Card> DeckCards { get; set; }
        private int PlayerCount { get; set; }
        public Deck(int playerCount)
        {
            rnd = new Random();
            List<Card> result = new List<Card>();
            for (int i = 2; i <= 14; i++)
            {
                result.Add(new Card(i, Suit.Club));
                result.Add(new Card(i, Suit.Diamond));
                result.Add(new Card(i, Suit.Heart));
                result.Add(new Card(i, Suit.Spade));
            }
            DeckCards = result;
            SetCards();
            CreatePlayerHands(playerCount);
            PlayerCount = playerCount;
        }
​
        public void CreatePlayerHands(int count)
        {
            if (count < 1 || count > 10)
                throw new IndexOutOfRangeException();
            for (int i = 1; i <= count; i++)
            {
                SetCards(i);
            }
        }
​
        public void ShowCards()
        {
            Console.WriteLine("Flop:");
            foreach (Card c in DeckCards.Where(x => x.UsedByPlayerID == 0))
            {
                c.ConsoleOutput();
            }
            Console.WriteLine();
            for (int i = 1; i <= PlayerCount; i++)
            {
                HandResult result = GetHandResult(i);
                Console.Write("Player #" + i + "\t(" + result.result + " ");
                foreach (Card cResult in result.resultCards)
                {
                    cResult.ConsoleOutput();
                }
                Console.Write(")");
                Console.WriteLine();
                foreach (Card c in DeckCards.Where(x => x.UsedByPlayerID == i))
                {
                    c.ConsoleOutput();
                }
                Console.WriteLine();
            }
        }
​
        private IOrderedEnumerable<Card> GetPlayerSet(int playerID)
        {
            return DeckCards.Where(x => x.UsedByPlayerID == 0 || x.UsedByPlayerID == playerID).OrderByDescending(x => x.Face);
        }
​
        private void SetCards(int? playerID = null)
        {
            IEnumerable<Card> playerCards = DeckCards.Where(x => !x.UsedByPlayerID.HasValue).OrderBy(x => rnd.Next()).Take(playerID.HasValue ? 2 : 5);
            foreach (Card c in playerCards)
            {
                c.UsedByPlayerID = playerID.HasValue ? playerID : 0;
            }
        }
​
        public class HandResult
        {
            public Hand result { get; set; }
            public IEnumerable<Card> resultCards { get; set; }
        }
​
        public HandResult GetHandResult(int playerID)
        {
            IEnumerable<Card> set = GetPlayerSet(playerID).OrderBy(x => x.Face);
            if (GetRoyalFlush(set).Any())
            {
                return new HandResult() { result = Hand.RoyalFlush, resultCards = GetRoyalFlush(set) };
            }
            else if (GetStraightFlush(set).Any())
            {
                return new HandResult() { result = Hand.StraightFlush, resultCards = GetStraightFlush(set) };
            }
            else if (GetFourOfAKind(playerID).Any())
            {
                return new HandResult() { result = Hand.FourOfAKind, resultCards = GetFourOfAKind(playerID) };
            }
            else if (GetFullHouse(set).Any())
            {
                return new HandResult() { result = Hand.FullHouse, resultCards = GetFullHouse(set) };
            }
            else if (GetFlush(set).Any())
            {
                return new HandResult() { result = Hand.Flush, resultCards = GetFlush(set) };
            }
            else if (GetStraight(set).Any())
            {
                return new HandResult() { result = Hand.Straight, resultCards = GetStraight(set) };
            }
            else if (GetThreeOfAKind(set).Any())
            {
                return new HandResult() { result = Hand.ThreeOfAKind, resultCards = GetThreeOfAKind(set) };
            }
            else if (GetTwoPair(set).Any())
            {
                return new HandResult() { result = Hand.TwoPair, resultCards = GetTwoPair(set) };
            }
            else if (GetOnePair(set).Any())
            {
                return new HandResult() { result = Hand.OnePair, resultCards = GetOnePair(set) };
            }
            else
            {
                return new HandResult() { result = Hand.HighCard, resultCards = GetPlayerSet(playerID).OrderByDescending(x => x.Face).Take(5) };
            }
        }
​
        private IEnumerable<Card> GetRoyalFlush(IEnumerable<Card> set)
        {
            IEnumerable<Card> straightflush = GetStraightFlush(set);
            return straightflush.Any(x => x.Face == 14 && x.Face == 13) ? straightflush : Enumerable.Empty<Card>();
        }
​
        private IEnumerable<Card> GetStraightFlush(IEnumerable<Card> set)
        {
            IEnumerable<Card> flush = set.GroupBy(x => x.Suit).Where(x => x.Count() >= 5).SingleOrDefault() ?? Enumerable.Empty<Card>();
            return GetStraight(flush);
        }
​
        private IEnumerable<Card> GetFourOfAKind(int playerID)
        {
            return GetPlayerSet(playerID).GroupBy(x => x.Face).SingleOrDefault(x => x.Count() >= 4) ?? Enumerable.Empty<Card>(); ;
        }
​
        private IEnumerable<Card> GetFullHouse(IEnumerable<Card> set)
        {
            IEnumerable<Card> threeOfAKind = GetThreeOfAKind(set);
            if (threeOfAKind.Any())
            {
                IEnumerable<Card> remainingCards = set.Where(x => !threeOfAKind.Any(y => y.Face == x.Face && y.Suit == x.Suit));
                IEnumerable<Card> highestTwoPair = remainingCards.GroupBy(x => x.Face).Where(x => x.Count() >= 2).OrderByDescending(x => x.Key).FirstOrDefault() ?? Enumerable.Empty<Card>(); ;
                if (highestTwoPair.Any())
                {
                    return threeOfAKind.Concat(highestTwoPair.Take(2));
                }
            }
            return Enumerable.Empty<Card>();
        }
​
        private IEnumerable<Card> GetFlush(IEnumerable<Card> set)
        {
            return set.GroupBy(x => x.Suit).Where(x => x.Count() >= 5).SelectMany(x => x.OrderByDescending(y => y.Face).Take(5));
        }
​
        private IEnumerable<Card> GetThreeOfAKind(IEnumerable<Card> set)
        {
            return set.GroupBy(x => x.Face).OrderByDescending(x => x.Key).FirstOrDefault(x => x.Count() == 3) ?? Enumerable.Empty<Card>(); ;
        }
​
        private IEnumerable<Card> GetTwoPair(IEnumerable<Card> set)
        {
            var pairs =  set.GroupBy(x => x.Face).Where(x => x.Count() == 2);
            return pairs.Count() >= 2 ? pairs.OrderByDescending(x => x.Key).Take(2).SelectMany(x => x) : Enumerable.Empty<Card>();
        }
​
        private IEnumerable<Card> GetOnePair(IEnumerable<Card> set)
        {
            return set.GroupBy(x => x.Face).SingleOrDefault(x => x.Count() >= 2) ?? Enumerable.Empty<Card>(); ;
        }
   
        private IEnumerable<Card> GetStraight(IEnumerable<Card> set)
        {
            if (set.Any())
            {                
                bool isAceStraight = !new List<int>() { 14, 2, 3, 4, 5 }.Except(set.Select(x => x.Face)).Any();
                if (isAceStraight)
                {
                    return set.Where(x => new List<int>() { 14, 2, 3, 4, 5 }.Contains(x.Face)).GroupBy(x => x.Face).Select(x => x.First());
                }
                int? temp = null;
                int conseductiveIndex = 0;
                for (int i = 0; i < set.Count(); i++)
                {
                    if (temp.HasValue)
                    {
                        if (temp != set.ElementAt(i).Face - 1)
                        {
                            conseductiveIndex = i;
                        }
                        if (i - conseductiveIndex == 4)
                        {
                            return set.Skip(conseductiveIndex).Take(5);
                        }
                    }
                    temp = set.ElementAt(i).Face;
                }
            }
            return Enumerable.Empty<Card>();
        }
​
​
        public enum Hand { RoyalFlush, StraightFlush, FourOfAKind, FullHouse, Flush, Straight, ThreeOfAKind, TwoPair, OnePair, HighCard }
        public enum Suit { Heart, Diamond, Spade, Club }
​
        public class Card
        {
            public Card(int face, Suit suit)
            {
                Suit = suit;
                Face = face;
            }
            public Suit Suit { get; set; }
            public int Face { get; set; }
            public int? UsedByPlayerID { get; set; }
​
            public void ConsoleOutput()
            {
                //Console.OutputEncoding = System.Text.Encoding.UTF8;
                char club = '\u2663', spade = '\u2660', diamond = '\u2666', heart = '\u2665';
                //Console.BackgroundColor = ConsoleColor.White;
                string face = GetFace(Face).PadLeft(2);
                switch (Suit)
                {
                    case Suit.Diamond:
                        //Console.ForegroundColor = ConsoleColor.Red;
                        Console.Write(face + diamond);
                        break;
                    case Suit.Heart:
                        //Console.ForegroundColor = ConsoleColor.Red;
                        Console.Write(face + heart);
                        break;
                    case Suit.Club:
                        //Console.ForegroundColor = ConsoleColor.Black;
                        Console.Write(face + club);
                        break;
                    case Suit.Spade:
                        //Console.ForegroundColor = ConsoleColor.Black;
                        Console.Write(face + spade);
                        break;
                }
                //Console.ResetColor();
                Console.Write(" ");
            }
            
            private string GetFace(int face)
            {
                switch (face)
                {
                    case 11:
                        return "J";
                    case 12:
                        return "Q";
                    case 13:
                        return "K";
                    case 14:
                        return "A";
                    default:
                        return face.ToString();
                }
            }
        }
    }
}

tanggal,bulan dan tahun lahir defani
12-9-2009

Last Run:	5:02:20 pm
Compile:	0.007s
Execute:	0.05s
Memory:	2.72Mb
CPU:	0.057s

View IL Code