Java 撲克牌發牌

今天看到這個算法題，http://www.cnblogs.com/xishuai/p/3392981.html ，忍不住本身用Java作了一個。

初始化很重要，全部的52張牌按順序放入到容器裏邊，標誌位標記爲false表示手裏沒這牌。

1 發牌

利用隨機數，找到容器中的這張牌，將標誌位標記爲true，表示手裏有了這張牌。

2 排序

由於放入的時候是按順序的，因而每一個花色各自，天然也是按照順序，找出標誌位爲true的，輸出便可。

3找出最大連續牌

思路是將連續的字符分隔出來，連續數目最大的，即爲最大連續牌。每一個花色的的最大牌找出來，再找出最大的。

作法：

每一個花色裏，生成一個字符串，其中，手裏有的排，將索引加入字符串，再加分隔符。手裏沒有的，用分號加入字符串。

用分號分隔後，長度大於1的即爲有連續牌的。從有連續牌的，找出最大的便可。

/**
 * desc
 * 程序描述：

　　一副紙牌有52張，4種花色，每種花色13張。咱們能用一個整數m就表示出全部的52種狀況，規則是：

  　　m / 13： =0: 紅心，=1: 方塊，=2: 梅花，=3: 黑桃

  　　m % 13:  =0:2，=1:3，=2:4 ....  =8:10，=9:J，=10:Q，=11: K，=12:A

　　好比：m = 15 就表示：方塊4  m=38表示：梅花A

　　咱們但願用程序模擬1副撲克牌隨機抽取13張，發給某人的過程。

　　發牌後須要排序：規則是：先按花色，再按點數。花色的大小順序是：梅花、方塊、紅心、黑桃。點數的順序是：二、三、四、…. 十、J、Q、K、A。

　　而後，挑選出最大的連續牌型。規則是：連續張數多的大。張數相等的則花色大的大（此時與點數無關）。

    我加了一條規則 最小連續是3張

 */
package algorithm;

import java.util.HashMap;
import java.util.Map;
import java.util.Random;
import java.util.Vector;

/**
 * @author new
 *
 */
public class Poker {
    private static final int CARDSNUM=13;
    private static final int MAX_NUM=52;
    private static final int MIN_CONSEC_NUM = 2;
    private Map<CardColor,Vector<Cards>> allCards=new HashMap<CardColor,Vector<Cards>>();
    public void start(){
        init();
        genarate();
        order();
        printMax();
    }
    
    private void init(){
        allCards.clear();
        for(CardColor color:CardColor.values()){
            Vector<Cards> v=new Vector<Cards>();
            for(CardDisplay cd:CardDisplay.values()){
                Cards  c = new Cards();
                c.setCardColor(color);
                c.setCardDisplay(cd);
                c.setExist(false);
                c.setRealNum(CARDSNUM*color.colorType+cd.num);
                v.add(c);
            }
            allCards.put(color, v);
        }
    }
    /**
     * 隨機抽取13張牌
     */
    private void genarate(){
        System.out.println("my cards is :");
        int i=0;
        do{
            Random r = new Random();
            int tmp = r.nextInt(MAX_NUM);
            int answer = tmp / CARDSNUM ;
            for(Cards obj:allCards.get(getColor(answer))){
                if(obj.getRealNum()==tmp&&obj.isExist()==false){
                    i++;
                    obj.setExist(true);
                    System.out.println(obj.getCardColor().colorDesc+":"+obj.getCardDisplay().displayStr);
                    break;
                }
            }
        }while(i<CARDSNUM);
    }
    private CardColor getColor(int answer){
        for(CardColor cc:CardColor.values()){
            if(cc.colorType == answer){
                return cc;
            }
        }
        return null;
    }
    /**
     * 開始排序 其實不用排序 枚舉初始化的時候已經排好序
     */
    private void order(){
        System.out.println();
        System.out.println("ofter order :");
        for(CardColor key:allCards.keySet()){
            System.out.print(key.colorDesc +" : ");
            for(Cards obj:allCards.get(key)){
                if(obj.isExist()){
                    System.out.print(obj.getCardDisplay().displayStr+" ");
                }
            }
            System.out.println();
        }
    }
    /**
     * 取出最大的連續牌型
     */
    private void printMax(){
        CardColor maxColor=null;
        int maxCardIdx = -1;
        int maxCardLength =0;
        for(CardColor key:allCards.keySet()){
            Vector<Cards> v = allCards.get(key);
            StringBuffer tmpcards=new StringBuffer();
            for(int idx=0;idx<v.size();idx++){
                Cards obj = v.get(idx);
                if(obj.isExist()){
                    tmpcards.append(idx).append("-");
                }else{
                    tmpcards.append(";");
                }
            }
            String cardstr=  tmpcards.toString().replaceAll("-;", ";");
            if(cardstr.endsWith("-"))cardstr=cardstr.substring(0,cardstr.length()-2);
            String[] tmpcardsarr=cardstr.split(";");
            int temp_maxCardIdx =-1;
            int tmp_maxCardLength =0;
            for(int i=0;i<tmpcardsarr.length;i++){
                String[] arr = tmpcardsarr[i].split("-");
                if(tmp_maxCardLength<=arr.length&&arr.length>=MIN_CONSEC_NUM){
                    temp_maxCardIdx=Integer.parseInt(arr[0]);
                    tmp_maxCardLength=arr.length;
                }
            }
            if(tmp_maxCardLength>=MIN_CONSEC_NUM){
                if(tmp_maxCardLength>maxCardLength||(maxColor!=null && tmp_maxCardLength==maxCardLength&&key.colorIndex>maxColor.colorIndex)){
                    maxColor = key;
                    maxCardIdx = temp_maxCardIdx;
                    maxCardLength = tmp_maxCardLength;
                }
            }
        }
        System.out.println();
        System.out.println("max :");
        if(maxCardLength>=MIN_CONSEC_NUM){            
            System.out.print(maxColor.colorDesc+":");
            Vector<Cards> v = allCards.get(maxColor);
            for(int i=maxCardIdx;i<v.size();i++){
                Cards obj = v.get(i);
                if(obj.isExist()){
                    System.out.print(obj.getCardDisplay().displayStr+" ");
                }else{
                    return;
                }
            }
        }
        else
        {
            System.out.println("無連續牌");
        }
    }
    /**
     * @param args
     */
    public static void main(String[] args) {
        Poker p = new Poker();
        p.start();
    }

}
class CardMax
{
    CardColor maxColor;
    int maxCardIdx;
}
/**
 * 
 * @author new
 *
 */
enum CardColor
{
    CLUB(2,"梅花",1),//梅花
    DIAMOND(1,"方塊",2),//方塊
    HEART(0,"紅桃",3),//紅桃
    SPADE(3,"黑桃",4);//黑桃
    protected final int colorType;
    protected final String colorDesc;
    protected final int colorIndex;//表明花色大小 值越大越大
    private CardColor(int type,String desc,int oidx)
    {
        this.colorType = type;
        this.colorDesc = desc;
        this.colorIndex = oidx;
    }
}
enum CardDisplay
{
    CARD_2(0),
    CARD_3(1),
    CARD_4(2),
    CARD_5(3),
    CARD_6(4),
    CARD_7(5),
    CARD_8(6),
    CARD_9(7),
    CARD_10(8),
    CARD_J(9),
    CARD_Q(10),
    CARD_K(11),
    CARD_A(12);
    protected final String displayStr;
    protected final int num;
    private CardDisplay(int num)
    {
        this.num = num;
        if(num<9){
            this.displayStr = String.valueOf(num+2);
        }
        else{
            String str="";
            switch(num){
            case 9:
                str = "J";
                break;
            case 10:
                str = "Q";
                break;
            case 11:
                str = "K";
                break;
            case 12:
                str="A";
                break;
            }    
            this.displayStr = str;
        }        
    }
}
/**
 * 每張牌對象
 * @author new
 *
 */
class Cards
{
    Cards(){
    }
    Cards(CardColor cardColor,CardDisplay cardDisplay,int realNum,boolean exist){
        this.cardColor = cardColor;
        this.cardDisplay = cardDisplay;
        this.realNum = realNum;
        this.exist = exist;
    }
    private CardColor cardColor;//花色
    private CardDisplay cardDisplay;
    private int    realNum;
    private boolean   exist;
    public CardColor getCardColor() {
        return cardColor;
    }
    public CardDisplay getCardDisplay() {
        return cardDisplay;
    }
    public int getRealNum() {
        return realNum;
    }
    public boolean isExist() {
        return exist;
    }
    public void setCardColor(CardColor cardColor) {
        this.cardColor = cardColor;
    }
    public void setCardDisplay(CardDisplay cardDisplay) {
        this.cardDisplay = cardDisplay;
    }
    public void setRealNum(int realNum) {
        this.realNum = realNum;
    }
    public void setExist(boolean exist) {
        this.exist = exist;
    }
}

測試結果：

my cards is :
方塊:6
方塊:8
方塊:4
梅花:4
方塊:A
紅桃:9
黑桃:Q
梅花:9
梅花:5
黑桃:10
黑桃:5
方塊:3
方塊:9

ofter order :
方塊 : 3 4 6 8 9 A 
黑桃 : 5 10 Q 
紅桃 : 9 
梅花 : 4 5 9 

max :
方塊:8 9