App:Poker Deck Sort

A deck pokers have 52 pieces except small king and big king, which with four different suit. We want to generate 52 pieces of pokers

and sort them by suit first or by value first.

We make a rule that is Spade>Heart>Diamond>Club, assign values (4,3,2,1) to each of them.

And anthter rule is code '2'<'3'<'4',...,'10'<'J'<'Q'<'K'<'A' with related values 2,3,4,...,10,11,12,13,14.

 

We should design architecture of the application. We need Poker entity class, PokerManager utility class and the invoker program class.

Details is below.

And now, we look into the detail implemental of each class.

First shows Poker class, which contains four constant values of suit(Spade,Heart,Diamond,Club),properties and some methods.

The primary memthods are CompareSuitFirstTo and CompareValueFirstTo, which supply how to compare two pokers.

using System;
namespace PokerDeck
{
     ///   <summary>
     ///  Poker entity
     ///   </summary>
     class Poker
    {
         public  const  char Spade =  ' ♠ ';
         public  const  char Heart =  ' ♥ ';
         public  const  char Diamond =  ' ♦ ';
         public  const  char Club =  ' ♣ ';
         public  int Suit {  get;  private  set; }
         public  int Value {  get;  private  set; }
         public  string Mark {  get;  private  set; }

         ///   <summary>
         ///  Initializes a new instance of Poker class
         ///   </summary>
         ///   <param name="mark"></param>
         public Poker( string mark)
        {
             if (mark ==  null || mark.Length <  2)
            {
                 throw  new ArgumentException();
            }

             this.Mark = mark;
             switch (mark[ 0])
            {
                 case Spade:
                     this.Suit =  4;
                     break;
                 case Heart:
                     this.Suit =  3;
                     break;
                 case Diamond:
                     this.Suit =  2;
                     break;
                 case Club:
                     this.Suit =  1;
                     break;
            }

             if (mark[ 1] >=  ' 2 ' && mark[ 1] <=  ' 9 ')
            {
                 this.Value = mark[ 1] -  ' 2 ' +  2;
            }
             else  if (mark[ 1] ==  ' 1 ' && mark.Length >  2 && mark[ 2] ==  ' 0 ')
            {
                 this.Value =  10;
            }
             else
            {
                 switch (mark[ 1])
                {
                     case  ' J ':
                         this.Value =  11;
                         break;
                     case  ' Q ':
                         this.Value =  12;
                         break;
                     case  ' K ':
                         this.Value =  13;
                         break;
                     case  ' A ':
                         this.Value =  14;
                         break;
                }
            }

             if ( this.Suit <=  0 ||  this.Value <=  0)
            {
                 throw  new ArgumentException();
            }
        }

         ///   <summary>
         ///  Compares two Pokers, suit first.
         ///   </summary>
         ///   <param name="other"></param>
         ///   <returns></returns>
         public  int CompareSuitFirstTo(Poker other)
        {
             int result =  this.Suit - other.Suit;
             if ( 0 == result)
            {
                result =  this.Value - other.Value;
            }

             return result;
        }

         ///   <summary>
         ///  Compares two Pokers, value first
         ///   </summary>
         ///   <param name="other"></param>
         ///   <returns></returns>
         public  int CompareValueFirstTo(Poker other)
        {
             int result =  this.Value - other.Value;
             if ( 0 == result)
            {
                result =  this.Suit - other.Suit;
            }

             return result;
        }

    }
}

 

Second, PokerManager utility class conatins serveral functions, such as CreatePoker,WritePoker,ReadPoker,SortBySuitFirst,SortByValueFirst.

I choose the QuickSort algorithms to sort pokers.

 

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

namespace PokerDeck
{
     ///   <summary>
     ///  Poker manager
     ///   </summary>
     class PokerManager
    {
         ///   <summary>
         ///  Creates a deck of pokers
         ///   </summary>
         ///   <returns></returns>
         public  static Poker[] CreatePoker()
        {
            Poker[] pokers =  new Poker[ 52];
             int n =  0;
             for ( int i =  2; i <=  14; i++)
            {
                 string valueCode = i.ToString();
                 switch (i)
                {
                     case  11:
                        valueCode =  " J ";
                         break;
                     case  12:
                        valueCode =  " Q ";
                         break;
                     case  13:
                        valueCode =  " K ";
                         break;
                     case  14:
                        valueCode =  " A ";
                         break;
                }

                pokers[n++] =  new Poker( string.Format( " {0}{1} ", Poker.Spade, valueCode));
                pokers[n++] =  new Poker( string.Format( " {0}{1} ", Poker.Heart, valueCode));
                pokers[n++] =  new Poker( string.Format( " {0}{1} ", Poker.Diamond, valueCode));
                pokers[n++] =  new Poker( string.Format( " {0}{1} ", Poker.Club, valueCode));
            }

             return pokers;
        }

         ///   <summary>
         ///  Writes a deck of pokers to text file
         ///   </summary>
         ///   <param name="pokers"></param>
         ///   <param name="filename"></param>
         public  static  void WritePoker(Poker[] pokers, string filename)
        {
             if (pokers ==  null)
            {
                 return;
            }

             using (StreamWriter sw = File.CreateText(filename))
            {
                 foreach (Poker p  in pokers)
                {
                     if (p !=  null)
                    {
                        sw.WriteLine(p.Mark);
                    }
                }
            }
        }

         ///   <summary>
         ///  Reads a deck of pokers from text file
         ///   </summary>
         ///   <param name="filename"></param>
         ///   <returns></returns>
         public  static List<Poker> ReadPoker( string filename)
        {
             if (!File.Exists(filename))
            {
                 throw  new FileNotFoundException();
            }

            List<Poker> pokerList =  new List<Poker>();

             string[] pokers = File.ReadAllLines(filename);
             if (pokers !=  null)
            {
                 foreach ( string poker  in pokers)
                {
                    pokerList.Add( new Poker(poker));
                }
            }

             return pokerList;
        }

         ///   <summary>
         ///  Sorts pokers by suit first
         ///   </summary>
         ///   <param name="pokers"></param>
         public  static  void SortBySuitFirst(Poker[] pokers)
        {
             if (pokers !=  null)
            {
                PokerQuickSort(pokers,  0, pokers.Length -  1,  true);
            }
        }

         ///   <summary>
         ///  Sorts pokers by value first
         ///   </summary>
         ///   <param name="pokers"></param>
         public  static  void SortByValueFirst(Poker[] pokers)
        {
             if (pokers !=  null)
            {
                PokerQuickSort(pokers,  0, pokers.Length -  1,  false);
            }
        }

         ///   <summary>
         ///  Details to sorting pokers by suitFirst parameter, using Quick Sort algorithms
         ///   </summary>
         ///   <param name="pokers"></param>
         ///   <param name="left"></param>
         ///   <param name="right"></param>
         ///   <param name="suitFirst">  if true, suit first; false, value first  </param>
         private  static  void PokerQuickSort(Poker[] pokers,  int left,  int right,  bool suitFirst)
        {
             if (pokers ==  null || pokers.Length <=  1)
            {
                 return;
            }

             if (right > pokers.Length -  1 || left <  0)
            {
                 throw  new ArgumentOutOfRangeException();
            }

             int i = left;
             int j = right;
            Poker key = pokers[left];
             do
            {
                 while ((pokers[i].CompareSuitFirstTo(key) <  0 && suitFirst) || (pokers[i].CompareValueFirstTo(key) <  0 && !suitFirst))
                {
                    i++;
                }

                 while ((pokers[j].CompareSuitFirstTo(key) >  0 && suitFirst) || (pokers[j].CompareValueFirstTo(key) >  0 && !suitFirst))
                {
                    j--;
                }

                 if (i < j)
                {
                     if (pokers[i].CompareSuitFirstTo(pokers[j]) ==  0)
                    {
                        i++;
                         continue;
                    }

                    Poker temp = pokers[i];
                    pokers[i] = pokers[j];
                    pokers[j] = temp;
                }

            }  while (i < j);

             if (i -  1 > left)
            {
                PokerQuickSort(pokers, left, i -  1, suitFirst);
            }

             if (i +  1 < right)
            {
                PokerQuickSort(pokers, i +  1, right, suitFirst);
            }

        }
    }
}

 

All finished expect implementing how to run, that the program does.

 

namespace PokerDeck
{
     class Program
    {
         static  void Main( string[] args)
        {
            Poker[] pokers = PokerManager.CreatePoker();
            PokerManager.SortBySuitFirst(pokers);
            PokerManager.WritePoker(pokers,  " suitfirst.txt ");
            PokerManager.SortByValueFirst(pokers);
            PokerManager.WritePoker(pokers,  " valuefirst.txt ");
        }
    }
}

 

When run the PokerDeck.exe, you will generate two files(suitfirst.txt and valuefirst.txt) in the same directory of the PokerDeck.exe.

 

转载于:https://www.cnblogs.com/ericwen/archive/2012/07/17/PokerDeck.html