一道亞馬遜的在線筆試題

    來園子快一年了，從來都是只看看，不說話。一來覺得自己技術太弱，說出來誤導別人；二來自己文筆太差，寫出來不通就貽笑大方了。

    之前看到園子有人發了一道面試題，覺得蠻有意思的，鼓起勇氣寫一篇，讓大神們扶正一下，也好促進自己進步！

題目描述：

規則一：
四張牌相同。自然數字大的勝出，比如3,3,3,3 < 6,6,6,6
規則二：
四張牌連續。當然序列最大的那個勝出。但是有個小trick，A在這里默認表最大牌，但是如果后接2,3,4，則A表最小牌，為了獲得連續序列
比如A,2,3,4 < J,Q,K,A
規則三：
有三張相同。以每個序列相同牌較大的勝出。  
比如3,3,3,2>2,2,2,A  
規則四:  
兩個對子。當然以對子較大的勝出，最大的對子相同，則以次大的對子較大者勝出。
比如4,4,3,3 > 4,2,4,2
規則五：
一個對子。對子較大者勝出，如果對子相同，則比較剩下較大牌，如果還相同，比較次大牌
3,3,7,4 < 3,3,7,5
規則六：  
規則序號越小越號，即規則一大於規則二，規則二大於規則三，依次類推；如果以上皆不滿足，則按照大牌>小牌比較（即從最大牌開始比較，分出高下為止）

 

    看到這個規則第一印象就是我們四川的斗地主嘛（每年過年，全家必玩的游戲，嘿嘿），不過是四張牌和沒有花色而已！

    首先是Card類：

/// <summary>
    /// 牌
    /// </summary>
    public class Card : IComparable
    {
        private string num;
        private int count;
        /// <summary>
        /// 數字
        /// </summary>
        public int Num
        {
            get
            {
                return ConvertStringToNum(num);
            }
            set
            {
                num = value.ToString();
            }
        }
        /// <summary>
        /// 出現次數
        /// </summary>
        public int Count
        {
            get { return count; }
            set { count = value; }
        }
        public Card(string num)
        {
            this.num = num.Trim();
            this.Count = 1;
        }
        public Card()
        { }
        /// <summary>
        /// 實現排序
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public int CompareTo(object obj)
        {
            int result;
            try
            {
                Card card = obj as Card;
                result = this.Count.CompareTo(card.Count);
                if (result == 0)
                {
                    result = this.Num.CompareTo(card.Num);
                }
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            return result;
        }
        /// <summary>
        /// 將JQKA轉為數字，方便比較
        /// </summary>
        /// <param name="inputStr"></param>
        /// <returns></returns>
        private int ConvertStringToNum(string inputStr)
        {
            int result = 0;
            if (!Int32.TryParse(inputStr, out result))
            {
                switch (inputStr)
                {
                    case "J":
                        result = 11;
                        break;
                    case "Q":
                        result = 12;
                        break;
                    case "K":
                        result = 13;
                        break;
                    case "A":
                        result = 14;
                        break;

                }
            }
            return result;

        }
    }

    這個類主要實現了IComparable中的CompareTo方法，方便之后的排序比較。

    然后是四張牌的類型（原諒我取了一個很sao二聲，四川人應該懂得起。金花：GlodFlower）：

 public enum GlodFlowerType
    {
        /// <summary>
        /// 散牌
        /// </summary>
        Other,
        /// <summary>
        /// 順子
        /// </summary>
        Progression,
        /// <summary>
        /// 全相同
        /// </summary>
        AllSame,

    }

    再后是主要的“金花”類（- -！）:

  public class GoldFlower
    {
        public static  List<string> cardNumList =new List<string>  { "A","2","3","4","5","6","7",
        "8","9","10","J","Q","K"};

        private List<int> numList = new List<int>();
        public List<Card> cardList = new List<Card>();
        public GlodFlowerType Type
        {
            get
            {
                numList.Sort();
                if (numList[0] == numList[numList.Count - 1])
                    return GlodFlowerType.AllSame;
                else if (IsProgression(numList))
                    return GlodFlowerType.Progression;
                else
                    return GlodFlowerType.Other;

            }
        }
        /// <summary>
        /// 判斷是否是連牌
        /// </summary>
        /// <param name="list"></param>
        /// <returns></returns>
        private bool IsProgression(List<int> list)
        {
            list.Sort();
            for (int i = 0; i < list.Count - 1; i++)
            {
                if (list[i + 1] != list[i] + 1)
                    return false;
            }
            return true;
        }
        public GoldFlower(List<string> list)
        {
            Card card;
            Card cardA = null;
            List<int> tempList = new List<int>();
            foreach (string s in list)
            {
                card = new Card(s);
                numList.Add(card.Num);
                if (card.Num == 14)
                    cardA = card;
                if (!tempList.Contains(card.Num))
                {
                    tempList.Add(card.Num); ;
                    cardList.Add(card);
                }
                else
                {
                    int index = numList.IndexOf(card.Num);
                    cardList[index].Count += 1;
                }
            }
            if (cardA != null)
            {
                int index = cardList.IndexOf(cardA);
                numList.Remove(14);
                if (IsProgression(numList) && numList.Contains(2))
                {
                    cardList[index].Num = 1;
                    numList.Add(1);
                }
                else
                    numList.Add(14);
            }
        }

        public int CompareTo(GoldFlower glodFlower)
        {
            int result = 0;
            this.cardList.Sort();
            glodFlower.cardList.Sort();
            result = this.Type.CompareTo(glodFlower.Type);
            if (result == 0)
                result = ComparenTwoArray(this.cardList, glodFlower.cardList, this.cardList.Count, glodFlower.cardList.Count);

            return result;
        }

        /// <summary>
        /// 字符串比較思想比較兩個數組的大小
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <param name="aLen"></param>
        /// <param name="bLen"></param>
        /// <returns></returns>
        private int ComparenTwoArray(List<Card> a, List<Card> b, int aLen, int bLen)
        {
            int i = aLen - 1, j = bLen - 1;
            while (i > 0 && j > 0)
            {
                if (a[i].Count == b[j].Count && a[i].Num == b[j].Num)
                {
                    i--;
                    j--;
                }
                else if (a[i].Count != b[j].Count)
                    return a[i].Count.CompareTo(b[j].Count);
                else if (a[i].Num != b[j].Num)
                    return a[i].Num.CompareTo(b[j].Num);
            }
            if (i == 0 && j == 0)
            {
                return 0;
            }
            else
            {
                return i == 0 ? -1 : 1;
            }
        }
    }

    比較兩個類的時候，先比較類型，類型相同后再比較牌的數字大小。
    測了幾組數據，還沒有發現誤判，但是感覺好慢。不知道是我的機子太爛還是算法不好。希望各位大神幫幫小女子！

    最后，請教一下大家，我看他們的博客都好漂亮，為什么我的不行？排版這些怎么弄的？真的第一次發這種東西，小白一枚！