NTNU MT OOP | For Beginners: 2014-04-06

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace homework5
{
    class HandCard
    {
        public PokerCard[] hand = new PokerCard[5];
        private int amount = 0;
        private int maxRank = 0;
        private int secRank = 0;
        private int thrRank = 0;
        private string cardtype = "";
        private int cardtypenum = 0;
        private enum eCardType  {HighCard=0,OnePair,TwoPair,ThreeOfaKing,Straight,Flush,FullHouse,FourOfaKing,StraightFlush}
        public HandCard()
        {
            for (int i = 0; i < 5; i++)
            {
                hand[i] = new PokerCard();
            }
        }
        public void SortByRank()
        {
            //bubble sort
            PokerCard ChangeCard;
            for (int i = hand.GetUpperBound(0); i > 0; i--)
            {
                for (int j = 0; j < i; j++)
                {
                    if (hand[j].Rank > hand[j + 1].Rank)
                    {
                        ChangeCard = hand[j];
                        hand[j] = hand[j+1];
                        hand[j+1] = ChangeCard;
                    }
                }
            }
        }
        public void GetCardType()
        {
            //同花順（Straight Flush）n = 8
            //四條（Four of a Kind）n = 7
            //葫蘆（Fullhouse） n = 6
            //同花（Flush）n = 5
            //順子（Straight）n = 4
            //三條（Three of a kind）n = 3
            //兩對（Two Pairs）n = 2
            //一對（One Pair）n = 1
            //無對（High Card) n = 0

            SortByRank();
            if (CheckStraight() == "Stragiht" && CheckFlush() == "Flush") // 同花順 8
            {
                GetMaxRank();
                CardType = "Straight Flush";
                CardTypeNum = (int)eCardType.StraightFlush;
                return;
            }
            else if (CheckStraight() == null && CheckFlush() == "Flush") // 同花 5 
            {
                GetMaxRank();
                CardType = "Flush";
                CardTypeNum = (int)eCardType.Flush;
                return;
            }
            else if (CheckStraight() == "Stragiht" && CheckFlush() == null) // 順子 4
            {
                GetMaxRank();
                CardType = "Straight";
                CardTypeNum = (int)eCardType.Straight;
                return;
            }
            else if(CheckPair() != null)
            {
                CardType = CheckPair();
            }
            else
            {
                GetMaxRank();
                CardType = "High Card";
                CardTypeNum = (int)eCardType.HighCard;
                return;
            }
        }
        //函數內容: 檢查是否為順子
        //函數說明: 第2張是第1張 + 1 以此類推
        //須注意 A 10 J Q K 特殊例子
        public string CheckStraight()
        {
            int start = 0;
            if (hand[0].Rank == 1) // A,10,J,Q,K 特例
            {
                start = 10;
                for (int i = 0; i <= hand.GetUpperBound(0)-1; i++)
                    if (hand[i+1].Rank != start + i)
                        return null;
                return "Stragiht";
            }
            start = hand[0].Rank;
            for (int i = 0; i <= hand.GetUpperBound(0); i++)
                if (hand[i].Rank != start + i)
                    return null;
            return "Stragiht";
        }
        //函數內容: 檢查是否為同花
        //函數說明: 只要有一張不同即null 
        public string CheckFlush()
        {
            int start = hand[0].Suit;
            foreach (PokerCard card in hand)
                if (card.Suit != start)
                    return null;
            return "Flush";
        }
        //函數內容: 檢查是否為對子(包含 三條 葫蘆 鐵支)
        //函數說明: 先使用GETMAX()函數取得最長值
        //再依各情況分析
        public string CheckPair()
        {
            SortByRank();
            int sum = GetMax(); // 取得相同點數最長的數量
            // 4 張 只有鐵支
            if (sum == 4) 
            {
                CardTypeNum = (int)eCardType.FourOfaKing;
                return "Four Of a King";
            }
            // 3 張 有葫蘆 跟 三條
            // 葫蘆判斷 OOO XX 或 OO XXX 所以 1.2 與 3.4 張必相同
            // 為非則為三條
            if (sum == 3)
            {
                if (hand[0].Rank == hand[1].Rank && hand[3].Rank == hand[4].Rank)
                {   
                    CardTypeNum = (int)eCardType.FullHouse;
                    return "Full House";
                }
                else
                {
                    CardTypeNum = (int)eCardType.ThreeOfaKing;
                    return "Three Of aKing";
                }
            }
            // 2張 有 Two pair 跟 One pair
            // two pair排列組合 有 2 1 2 或 2 2 1 或 1 2 2 等情形
            // 再分別對各情形處理即可
            if (sum == 2)
            {
                if (hand[0].Rank == hand[1].Rank)
                {
                    if (hand[3].Rank == hand[4].Rank||hand[2].Rank == hand[3].Rank)
                    {
                        secRank = hand[0].Rank; // 第二組PAIR
                        thrRank = hand[2].Rank; // 雜牌
                        CardTypeNum = (int)eCardType.TwoPair;
                        return "Two Pair";
                    }
                    else // 1 1 2 3 4 情形
                    {
                        secRank = hand[4].Rank; // 單支 最後一張
                        secRank = hand[3].Rank; // 單支 倒數第二張
                        CardTypeNum = (int)eCardType.OnePair;
                        return "One Pair";
                    }
                }
                else
                {
                    if (hand[1].Rank == hand[2].Rank && hand[3].Rank == hand[4].Rank) // O XX WW 情形
                    {
                        secRank = hand[2].Rank; // 第二組PAIR
                        thrRank = hand[0].Rank; // 雜牌
                        CardTypeNum = (int)eCardType.TwoPair;
                        return "Two Pair";
                    }
                    else
                    {
                        //ONE PAIR牌剩下的三種情形 把最大 中間 第三 找到
                        if(hand[4].Rank == hand[3].Rank) //1 2 3 4 4 情形
                        {
                            secRank = hand[2].Rank;
                            thrRank = hand[1].Rank;
                        }
                        else if (hand[3].Rank == hand[2].Rank) // 1 2 3 3 4 情形
                        {
                            secRank = hand[4].Rank;
                            thrRank = hand[1].Rank;
                        }
                        else if (hand[2].Rank == hand[1].Rank) // 1 2 2 3 4 情形
                        {
                            secRank = hand[4].Rank;
                            thrRank = hand[3].Rank;
                        }
                        CardTypeNum = (int)eCardType.OnePair;
                        return "One Pair";
                    }
                }
            }
            return null;
        }
        //函數內容:取得最大相同牌數，並用maxRank紀錄最多相同牌的值
        //函數說明:
        //3 3 2 2 2 回傳 3 並記錄 2 
        //3 2 2 2 2 回傳 4 並紀錄 2
        //1 2 3 3 4 回傳 2 並記錄 3
        //1 2 3 4 5 回傳 1 
        //以此類推 
        public int GetMax() //取得最多相同牌數 
        {
            int count = 0;
            int max = 1;
            int last = 0;
            for (int j = 0; j < 5; j++)
            {
                if (last != hand[j].Rank)
                {
                    last = hand[j].Rank;
                    for (int i = j; i < 5; i++)
                    {
                        if (last == hand[i].Rank)
                            count++;
                    }
                    if (count > max)
                    {
                        max = count; // 紀錄長度
                        if (last == 1)
                            maxRank = last + 13; // 紀錄點數
                        else
                            maxRank = last;
                    }
                }
                count = 0;
            }
            return max;
        }
        //函數內容: 一般情況下判定最大張的牌並記錄在maxRank值內 (雜牌.順子.同花.同花順)
        public void GetMaxRank()
        {
            if (hand[0].Rank == 1)
            {
                maxRank = hand[0].Rank + 13; // 若A為最大，A = 14點
                secRank = hand[4].Rank;
                thrRank = hand[3].Rank;
            }
            else
            {
                maxRank = hand[4].Rank; //最大張為 最後一張牌 (A 例外)
                secRank = hand[3].Rank;
                thrRank = hand[2].Rank;
            }
        }
        //函數內容: 增加一張手牌
        //函數說明: amount紀錄目前手牌數量，若超過傳回false
        public bool Add(PokerCard c)
        {
            if (c == null || amount == 5)
                return false;
            hand[amount] = c;
            amount++;
            return true;
        }
        //函數內容: 兩張手牌比較牌的大小
        //函數說明: 先比較牌型，牌型較大者獲勝
        //牌行相同則比較最大張牌，若相同則在比較下一張，直到第三張
        public bool CombatTo(HandCard p2)
        {

            int P1CardType = CardTypeNum;
            int P2CardType = p2.CardTypeNum;
            if (P1CardType > P2CardType)
                return true;
            else if (P1CardType < P2CardType)
                return false;
            else //牌型相同 則比最大張
            {
     
                if (MaxRank > p2.MaxRank)
                    return true;
                else if (MaxRank < p2.MaxRank)
                    return false;
                else // 最大張相同 則比第二大張
                {
                    if (SecRank > p2.SecRank)
                        return true;
                    else if (SecRank < p2.SecRank)
                        return false;
                    else// 第二大張相同 則比第三大張 
                    {
                        if (ThrRank > p2.ThrRank)
                            return true;
                        else if (ThrRank < p2.ThrRank)
                            return false;
                    }
                }
            }
            //要是第三大張在比較點數總和
            int player1Sum = 0;
            int player2Sum = 0;
            for (int i = 0; i < 5; i++)
            {
                player1Sum += hand[i].Rank;
                player2Sum += p2.hand[i].Rank;
            }
            if (player1Sum > player2Sum)
                return true;
            else if (player1Sum < player2Sum)
                return false;
            //Default
            return true;
        }
        public string CardType
        {
            get 
            {
                if (cardtype == "")
                    GetCardType();
                return cardtype; 
            }
            set { cardtype = value; }
        }
        public int CardTypeNum
        {
            get 
            {
                if (cardtypenum == 0)
                    GetCardType();
                return cardtypenum; 
            }
            set
            {
                if (value > 8 || value < 0)
                    cardtypenum = 0;
                else
                    cardtypenum = value;
            }
        }
        public int MaxRank
        {
            get { return maxRank; }
        }
        public int SecRank
        {
            get { return secRank; }
        }
        public int ThrRank
        {
            get { return thrRank; }
        }

    }
}

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

namespace HW5
{
class CardDeck
{
public PokerCard[] Deck = new PokerCard[52];

public void CreateDeck()
{
for (int i = 0; i < 52; i++)
{
Deck[i] = new PokerCard(i / 13, i % 13 + 1);
}
}

public void ResetDeck()
{
for (int i = 0; i < 52; i++)
{
Deck[i].Suit = i / 13;
Deck[i].Rank = i % 13 + 1;
}
}

public void Shuffle()
{
//亂數產生器
Random rand = new Random();
PokerCard temp;
int RandNum;

for (int i = 0; i < 52; i++)
{
RandNum = rand.Next(52);
temp = Deck[i];
Deck[i] = Deck[RandNum];
Deck[RandNum] = temp;
}
}

}
}
===================================================
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace HW5
{
class HandCard
{
public PokerCard[] Hand = new PokerCard[5];
private static string[] Type = { "Zilch", "One Pair", "Two Pairs", "Three of a kind", "Straight", "Flush", "Fullhouse", "Four of a Kind", "Straight Flush" };
int TopIndex = 0;
private bool isSort = true;

public void Draw(CardDeck D)
{
for (int i = 0; i < 5; i++)
{
if (TopIndex >= 50)
{
D.ResetDeck();
D.Shuffle();
TopIndex = 0;
}
Hand[i] = D.Deck[TopIndex];
TopIndex++;
}
}

public void Draw(CardDeck D,int Limit)
{
int Lnum = 0;

while (Lnum<Limit)
{
for (int i = 0; i < 5; i++)
{
if (TopIndex >= 50)
{
D.ResetDeck();
D.Shuffle();
TopIndex = 0;
}
Hand[i] = D.Deck[TopIndex];
TopIndex++;
}

Lnum++;
}
TopIndex += 5;
}

public void Sort()
{
PokerCard temp;

for (int i = 0; i < 5; i++)
{
for (int j = 1; j < 5; j++)
{
if (Hand[j - 1].Rank > Hand[j].Rank)
{
temp = Hand[j - 1];
Hand[j - 1] = Hand[j];
Hand[j] = temp;
}
}
}
}

public int CardsTypeNum()
{
if (!isSort)
Sort();

int Num = 0;

//判斷對子數目
int TypeNum = 0;

for (int i = 0; i < 5; i++)
{
for (int j = i + 1; j < 5; j++)
{
if (Hand[i].Rank == Hand[j].Rank)
TypeNum++;
}
}

switch (TypeNum)
{
case 0:
Num = 0;
break;
case 1:
Num = 1;
break;
case 2:
Num = 2;
break;
case 3:
Num = 3;
break;
case 4:
Num = 6;
break;
case 6:
Num = 7;
break;
}

//判斷同花
int FlushNum = 0;

for (int i = 1; i < 5; i++)
{
if (Hand[0].Suit == Hand[i].Suit)
FlushNum++;
}

if (FlushNum == 4)
Num = 5;

//判斷順子
int StraightNum = 0;

for (int i = 1; i < 5; i++)
{
if (Hand[i - 1].Rank + 1 == Hand[i].Rank)
{
StraightNum++;

if (Hand[i - 1].Rank == 13 && Hand[i].Rank == 1)
StraightNum++;
}
}

if (StraightNum == 4)
Num = 4;

//判斷同花順
if (FlushNum == 4 && StraightNum == 4)
Num = 8;

return Num;
}

public string TypeNumToStr()
{
return Type[CardsTypeNum()];
}

public string TypeProbability(CardDeck D,int Order)
{
double ZilchNum = 0;
double OnePairNum = 0;
double TwoPairsNum = 0;
double ThreeOfaKindNum = 0;
double StraightNum = 0;
double FlushNum = 0;
double FullHouseNum = 0;
double FourOfaKindNum = 0;
double StraightFlushNum = 0;
int N = 50000000;

for (int i = 0; i <= N; i++)
{
Draw(D);
Sort();
CardsTypeNum();

switch (CardsTypeNum())
{
case 0:
ZilchNum++;
break;
case 1:
OnePairNum++;
break;
case 2:
TwoPairsNum++;
break;
case 3:
ThreeOfaKindNum++;
break;
case 4:
StraightNum++;
break;
case 5:
FlushNum++;
break;
case 6:
FullHouseNum++;
break;
case 7:
FourOfaKindNum++;
break;
case 8:
StraightFlushNum++;
break;
default:
break;
}
}

switch (Order)
{
case 0:
return (ZilchNum / N).ToString();
case 1:
return (OnePairNum / N).ToString();
case 2:
return (TwoPairsNum / N).ToString();
case 3:
return (ThreeOfaKindNum / N).ToString();
case 4:
return (StraightNum / N).ToString();
case 5:
return (FlushNum / N).ToString();
case 6:
return (FullHouseNum / N).ToString();
case 7:
return (FourOfaKindNum / N).ToString();
case 8:
return (StraightFlushNum / N).ToString();
default:
return "Error!!";
}
}
}
}

===================================================
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace HW5
{
class PokerCard
{
//Fields
private int suit;
private int rank;
private static string[] StrUni = { "\u2665", "\u2666", "\u2663", "\u2660" };

//Constructors
public PokerCard(int suit, int rank)
{
this.suit = suit;
this.rank = rank;
}

//Attributes
public int Suit
{
get { return suit; }
set
{
if (value >= 0 && value < 4)
suit = value;
}

}

public int Rank
{
get { return rank; }
set
{
if (value > 0 && value <= 13)
rank = value;
}
}

/// <summary>
/// method
/// </summary>
/// <returns></returns>
public string SuitToUni()
{
return StrUni[Suit];
}

public string RankToStr()
{
string rankStr="";

switch (Rank)
{
case 1:
rankStr = "A";
return rankStr;
case 2:
case 3:
case 4:
case 5:
case 6:
case 7:
case 8:
case 9:
case 10:
rankStr = rank.ToString();
return rankStr;
case 11:
rankStr = "J";
return rankStr;
case 12:
rankStr = "Q";
return rankStr;
case 13:
rankStr = "K";
return rankStr;
default:
return "Error!!";
}
}
}
}

===================================================

2014年4月6日星期日

[Code Review] Team 03 - Hw05

執行檔 Form1.cs 按我顯示

public HW5()
        {
            InitializeComponent();
        }

        private void btn_RunMyChioce_Click(object sender, EventArgs e)
        {
            HandCard hand1 = new HandCard();
            
            CardDeck carddeck = new CardDeck();
            carddeck.ResetDeck();

            switch (cbox_MyChioce.SelectedIndex)
            {
                case 0:
                    carddeck.Shuffle();
                    hand1.Rest(carddeck);
                    MessageBox.Show(hand1.MyCardAndCardType());
                    break;
                case 1:
                    HandCard hand2 = new HandCard();
                    carddeck.Shuffle();
                    hand1.Rest(carddeck);
                    hand2.Rest(carddeck);
                    string result = hand1.MyCardAndCardType() + hand2.MyCardAndCardType() + WhoWin(hand1,hand2);
                    MessageBox.Show(result);
                    break;
                case 2:
                    float[] FrequencyData =new float[10];
                    for (int pass = 1; pass <= 5000000; pass++)
                    {
                        carddeck.ResetDeck();
                        carddeck.Shuffle();
                        for (int x = 1; x <= 10; x++)
                        {
                            hand1.Rest(carddeck);
                            FrequencyData[hand1.CardType()] += 1;
                        }
                    }
                    PrintProbability(hand1, FrequencyData);
                    break;
                default:
                    MessageBox.Show("Error");
                    break;
            }
           
        }

        string WhoWin(HandCard player1, HandCard player2)
        {
            if (player1.CardType() > player2.CardType())
                return "Player1 Win";
            else if(player1.CardType() < player2.CardType())
                return "Player2 Win";
            else 
                return "Draw Game";

        }

        void PrintProbability(HandCard p,float[] q)
        {
            string output;
            for (int i = 0; i < 10; i++)
            {
                output = "";
                output += p.TypeStr[i];
                output += ":";
                output += (q[i]/50000000).ToString();
                output += "\n";
                txt_ShowMessage.AppendText(output);
            }
        }

CardDeck 按我顯示

public PokerCard[] Cards = new PokerCard[52];
        private int topIndex = 0;

        public void ResetDeck()
        {
            for (int i = 0; i <= 51; i++)
            {
                Cards[i] = new PokerCard((i / 13) + 3, (i % 13) + 1);

            }
            topIndex = 0;
        }


        public void Shuffle()
        {
            Random rand = new Random();
            PokerCard Change = new PokerCard();
            for (int i = 0; i <= 51; i++)
            {
                Change = Cards[i];
                int position = rand.Next(52);
                Cards[i] = Cards[position];
                Cards[position] = Change;
            }
            topIndex = 0;
        }

        public PokerCard Deal()
        {
            if (topIndex >= 52)
                return null;

            return Cards[topIndex++];

        }

PokerCard 按我顯示

class PokerCard
    {
        private int suit;
        private int rank;

        public PokerCard(int suit, int rank)
        {
            this.suit = suit;
            this.rank = rank;
        }
        public PokerCard()
        {
        }


        public int Rank
        {
            get { return rank; }
            set { rank = value; }
        }
        public int Suit
        {
            get { return suit; }
            set { suit = value; }
        }

        private string RankToStr()
        {
            switch (Rank)
            {
                case 1:
                    return "A";
                case 11:
                    return "J";
                case 12:
                    return "Q";
                case 13:
                    return "K";
                default:
                    return Convert.ToString(Rank);
            }
        }
        private string SuitToUni()
        {
            string Str_Suit;
            switch (Suit)
            {
                case 3:
                    Str_Suit = "\u2665";
                    break;
                case 4:
                    Str_Suit = "\u2666";
                    break;
                case 5:
                    Str_Suit = "\u2663";
                    break;
                case 6:
                    Str_Suit = "\u2660";
                    break;
                default:
                    Str_Suit = "Error";
                    break;
            }
            return Str_Suit;

        }

        public string RankAndSuit()
        {
            return RankToStr() + SuitToUni();
        }

HandCard 按我顯示

private PokerCard[] Hand = new PokerCard[5];
        private enum Type { Error,Highcard, Onepair, Twopair, Threeofkind, Straight, Flush, Fullhouse, Fourofkind, StraightFlush };
        public string[] TypeStr = { "Error", "Highcard", "Onepair", "Twopair", "Threeofkind", "Straight", "Flush", "Fullhouse", "Fourofkind", "StraightFlush" };
       
        //發牌和做大小排列
        public void Rest(CardDeck p)
        {
            for (int i = 0; i < 5; i++)
            {
                Hand[i] = p.Deal();
            }
            this.Sort();
        }

        //將5張牌由點數小到大排列
        private void Sort()
        {
            PokerCard temp = new PokerCard();
            for (int pass = 0; pass < 5; pass++)
            {
                for (int i = 0; i < 4; i++)
                {
                    if (Hand[i].Rank > Hand[i + 1].Rank)
                    {
                        temp = Hand[i];
                        Hand[i] = Hand[i + 1];
                        Hand[i + 1] = temp;

                    }
                }
            }
        }

        //判斷5張手牌所組成得類型
        
        public int CardType()
        {
            switch (JudgeRepeatHowManyTime())
            {
                case 0:
                    if (isFlush())
                    {
                        if (isStraight())
                            return (int)(Type.StraightFlush);
                        else
                            return (int)(Type.Flush);
                    }
                    else if (isStraight())
                        return (int)(Type.Straight);
                    else
                        return (int)(Type.Highcard);
                case 2:
                    return (int)(Type.Onepair);
                case 4:
                    return (int)(Type.Twopair);
                case 5:
                    return (int)(Type.Threeofkind);
                case 7:
                    return (int)(Type.Fullhouse);
                case 8:
                    return (int)(Type.Fourofkind);
                default:
                    return (int)(Type.Error);

            }


        }
        private bool isFlush()
        {
            for (int i = 0; i < 4; i++)
            {
                if (Hand[i].Suit != Hand[i + 1].Suit)
                    return false;
            }
            return true;
        }

        /*isStraight
         * 如果單純檢查5張牌是否連續會使[A,10,J,Q,K]出現錯誤
         * 
         * 所以先檢查第一張是否是A
         * 是A=====>檢查第2~第5張是否連續。是連續======>檢查第2張是否是2或10。是2或10======>是順子
         *                                 不是連續=====>不是順子
         * 不是A======>屏蔽掉[A,10,J,Q,K]這個組合，直接檢查五張牌是否連續。是連續======>是順子
         *                                                                 不是連續=====>不是順子
        */
        private bool isStraight()
        {
            if (Hand[0].Rank == 1)
            {
                for (int i = 1; i < 4; i++)
                {
                    if (Hand[i].Rank != (Hand[i + 1].Rank) - 1)
                    {
                        return false;
                    }
                }
                if (Hand[1].Rank == 2 || Hand[1].Rank == 10)
                    return true;
                else
                    return false;
            }
            else
            {
                for (int i = 0; i < 4; i++)
                {
                    if (Hand[i].Rank != (Hand[i + 1].Rank) - 1)
                    {
                        return false;
                    }

                }
                return true;
            }
            
        }

        /*JudgeRepeatHowManyTime
          若第i張和第(i+1)張相同，是的話x+1和y+1，並在檢查第(i+1)張和第(i+2)張相同，是的話y+1
          若第i張和第(i+1)張不相同，不做任何事
          for loop跑完時 
          若牌型是Highcard，則x=0、y=0
                  Onepair，則x=1，y=1
                  Twopair，則x=2、y=2
                  Threeofkind，則x=2、y=3
                  Straight，則x=0、y=0
                  Flush，則x=0、y=0
                  Fullhouse，則x=3、y=4
                  Fourofkind，則x=3、y=5
                  StraightFlush，則x=0、y=0*/
        private int JudgeRepeatHowManyTime()
        {
            int x = 0, y = 0;
            for (int i = 0; i < 4; i++)
            {
                if (Hand[i].Rank == Hand[i + 1].Rank)
                {
                    x += 1;
                    y += 1;

                    if (i + 2 > 4) //只有五張牌
                        continue;
                    if (Hand[i + 1].Rank == Hand[i + 2].Rank)
                    {
                        y += 1;
                    }
                }
            }
            return x+y;
            
        }





        //將5張牌和組成的牌型做成字串
        public string MyCardAndCardType()
        {
            string output = "";
            for (int i = 0; i < 5; i++)
            {
                output += Hand[i].RankAndSuit();
                output += "  ";
            }
            output += "\n";
            output+=TypeStr[CardType()];
            output += "\n";
            return output;
        }

[Code Review] Team 08 - Hw05

執行檔
ppt

Lecture - Week 07

訂閱：意見 (Atom)

NTNU MT OOP | For Beginners

2014年4月12日星期六

[Code Review] Team 08 - Hw06

2014年4月11日星期五

Lecture - Week 08

2014年4月10日星期四

[Code Review] Team 02 - Hw06 Version 2

2014年4月9日星期三

[Code Review] Team 02 - Hw06

[Code Review] Team 07 - Hw05 (修改(參考吳順德老師Code))

2014年4月7日星期一

Reference - Homework Week 05

[Code Review] Team 08 - Hw05 (修改)

[Code Review] Team 09 - Hw05

2014年4月6日星期日

[Code Review] Team 03 - Hw05

[Code Review] Team 08 - Hw05

Lecture - Week 07

2014年4月12日 星期六

2014年4月11日 星期五

2014年4月10日 星期四

2014年4月9日 星期三

2014年4月7日 星期一

2014年4月6日 星期日

2014年4月12日星期六

2014年4月11日星期五

2014年4月10日星期四

2014年4月9日星期三

2014年4月7日星期一

2014年4月6日星期日