一道亞馬遜的在線筆試題

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

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

題目描述:

規則一:
四張牌相同。自然數字大的勝出,比如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;

        }
    }
View Code

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

    然後是四張牌的類型(原諒我取了一個很sao二聲,四川人應該懂得起。金花:GlodFlower):

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

    }
View Code

    再後是主要的“金花”類(- -!):

  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;
            }
        }
    }
View Code

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

    最後,請教一下大家,我看他們的博客都好漂亮,爲什麼我的不行?排版這些怎麼弄的?真的第一次發這種東西,小白一枚!

 

發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章