广州百田软件研发笔试题：求一套扑克牌中怎样出最后剩下的单牌数最少，只能出顺子和对（2/3/4）

顺子和对（2/3/4）"/>

广州百田软件研发笔试题：求一套扑克牌中怎样出最后剩下的单牌数最少，只能出顺子和对（2/3/4）

题目是这样的：有n张扑克牌，每张牌的取值范围是：2，3，4，5，6，7，8，9，10，J（11），Q（12），K（13），A（14）。（同样的牌的数目不超过4张）。可以出对子，三张一样的，四张一样的或者顺子，怎样出最后剩下的单牌最少。

        思路：首先考虑找出顺子。我的思路其实很简单，首先就是要去掉重复的牌，因为同样的顺子之算一个，显然JAVA中的Set很适合这个工作。同时又需要对这些牌进行排序，毫无疑问就是TreeSet了。然后从小到大遍历这些牌，并设置一个计数器count。若发现连续的牌，则count++；若发现不连续的，分2中情况：若count>4，则找到了一个顺子，存起来；反之则什么都不做。然后count=1，从新开始找顺子。下面就是代码：

import java.util.ArrayList;
import java.util.TreeSet;

public class Main {

    /**
     * @param args
     */
    public static void main(String[] args) {

        String[] cards = {“6″, ”2″ ,”3″ ,”7″ ,”4″, ”5″, ”8″, ”8″, ”10″, ”10″, ”10″, ”J”, ”K”, ”Q”, ”A”};
        TreeSet<Integer> set = init(cards);    //将字符串表示的扑克牌转换为数字，便于处理
        ArrayList<String> result = check(set);    //找出顺子
        printResult(result);    //打印顺子
        System.out.println(“程序结束！！”);
    }

    private static TreeSet<Integer> init(String[] cards) {
        TreeSet<Integer> set = new TreeSet<Integer>();
        for(String s:cards) {
            if(s.charAt(0)>=’1′&&s.charAt(0)<=’9′) {
                set.add(Integer.parseInt(s));
            }else {
                switch(s.toUpperCase().charAt(0)) {
                case ’J':
                    set.add(11);    break;
                case ’Q':
                    set.add(12);    break;
                case ’K':
                    set.add(13);    break;
                case ’A':
                    set.add(14);    break;
                }
            }
        }
        return set;

    }

    private static ArrayList<String> check(TreeSet<Integer> set) {
        ArrayList<String> result = new ArrayList<String>();
        StringBuilder temp = new StringBuilder();
        int count = 0;
        Integer[] nums = new Integer[1];
        nums = set.toArray(nums);
        int begin = 0;
        for(Integer i:set) {
            if(count == 0) {
                begin = i;
                count++;
                temp.append(numToCard(begin));
            }else if(i == begin+count) {
                temp.append(“, ”+numToCard(i));
                count++;
            }else {
                if(count>4) {
                    result.add(temp.toString());
                }
                begin = i;
                temp.replace(0, temp.length(), numToCard(i)+”");
                count = 1;
            }
        }

        if(count>4)        result.add(temp.toString());
        return result;
    }

    private static String numToCard(int x) {
        if(x>10) {
            switch(x) {
            case 11:
                return ”J”;
            case 12:
                return ”Q”;
            case 13:
                return ”K”;
            case 14:
                return ”A”;
            }
        }else {
            return x+”";
        }
        return null;
    }

                     //可以将长顺子分解为短顺子的打印模式
    private static void printResult1(ArrayList<String> result) {

        int count = 0;
        String[] nodes = null;
        if(result.size() == 0) {
            System.out.println(“没有顺子！！”);
        }else {
            for(String s:result) {
                nodes = s.split(“,”);
                count += (1+(nodes.length-4))*(nodes.length-4)/2;
            }
            System.out.println(“共有”+count+”个顺子:”);
            for(String s:result) {
                nodes = s.split(“,”);
                for(int i=5; i<=nodes.length; i++)
                    for(int j=0; i-j>4; j++) {
                        System.out.print(nodes[j].trim());
                        for(int x = j+1; x<i; x++) {
                            System.out.print(“,” + nodes[x]);
                        }
                        System.out.println();
                    }
            }
        }
    }

                     //不将长顺子进行分解的打印模式
    private static void printResult2(ArrayList<String> result) {
        if(result.size() == 0) {
            System.out.println(“没有顺子！！”);
        }else {
            System.out.println(“共有”+result.size()+”个顺子:”);
            for(String s:result) {
                System.out.println(s);
            }
        }
    }
}