撲克牌大小

題目描述

撲克牌遊戲你們應該都比較熟悉了，一副牌由54張組成，含3~A、2各4張，小王1張，大王1張。牌面從小到大用如
    下字符和字符串表示（其中，小寫joker表示小王，大寫JOKER表示大王）：
3 4 5 6 7 8 9 10 J Q K A 2 joker JOKER
輸入兩手牌，兩手牌之間用"-"鏈接，每手牌的每張牌以空格分隔，"-"兩邊沒有空格，
如：4 4 4 4-joker JOKER。
請比較兩手牌大小，輸出較大的牌，若是不存在比較關係則輸出ERROR。
基本規則：
（1）輸入每手牌多是個子、對子、順子（連續5張）、三個、炸彈（四個）和對王中的一種，不存在其餘狀況，
    由輸入保證兩手牌都是合法的，順子已經從小到大排列；
（2）除了炸彈和對王能夠和全部牌比較以外，其餘類型的牌只能跟相同類型的存在比較關係（如，對子跟對子比
    較，三個跟三個比較），不考慮拆牌狀況（如：將對子拆分紅個子）；
（3）大小規則跟你們平時瞭解的常見規則相同，個子、對子、三個比較牌面大小；順子比較最小牌大小；炸彈大
    於前面全部的牌，炸彈之間比較牌面大小；對王是最大的牌；
（4）輸入的兩手牌不會出現相等的狀況。

輸入描述

輸入兩手牌，兩手牌之間用"-"鏈接，每手牌的每張牌以空格分隔，"-"兩邊沒有空格，
如 4 4 4 4-joker JOKER。

輸出描述

輸出兩手牌中較大的那手，不含鏈接符，撲克牌順序不變，仍以空格隔開；若是不存在比較關係則輸出ERROR。

輸入例子

4 4 4 4-joker JOKER

輸出例子

joker JOKER

算法實現

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

/**
 * Declaration: All Rights Reserved !!!
 */
public class Main {

    private static enum Type {
        // 個子
        SINGLE,
        // 對子
        PAIR,
        // 三個
        TRIPLE,
        // 四個
        QUADRUPLE,
        // 順子
        STRAIGHT,
        // 對王
        JOKER,
        // 錯誤狀況
        ERROR
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
//        Scanner scanner = new Scanner(Main.class.getClassLoader().getResourceAsStream("data.txt"));
        while (scanner.hasNextLine()) {
            String input = scanner.nextLine();
            String[] parts = input.split("-");
            System.out.println(compare(parts[0], parts[1]));
        }
        scanner.close();
    }

    /**
     * 比較兩手牌的大小，保證兩手牌不相等
     *
     * @param s 第一手牌
     * @param t 第二手牌
     * @return 較大的牌，或者沒法比較
     */
    private static String compare(String s, String t) {

        int[] sr = {0};
        int[] tr = {0};

        Type st = getType(s, sr);
        Type tt = getType(t, tr);

        // 誰是王炸誰大
        if (st == Type.JOKER) {
            return s;
        }

        if (tt == Type.JOKER) {
            return t;
        }

        // 兩個炸彈
        if (st == Type.QUADRUPLE && tt == Type.QUADRUPLE) {
            if (sr[0] > tr[0]) {
                return s;
            } else if (sr[0] < tr[0]) {
                return t;
            }
        }
        // 只有一個炸彈
        if (st == Type.QUADRUPLE) {
            return s;
        }

        if (tt == Type.QUADRUPLE) {
            return t;
        }

        // 沒有王炸和炸彈，相同的才能比較
        if (st == tt) {
            if (sr[0] > tr[0]) {
                return s;
            } else if (sr[0] < tr[0]) {
                return t;
            }
        }


        return "ERROR";
    }

    /**
     * 判斷牌的類型，順子已經從小到大排列
     *
     * @param s 牌
     * @param r 返回牌類型的值
     * @return 類型
     */
    private static Type getType(String s, int[] r) {

        // 判斷是否是對王
        if (s.contains("joker") && s.contains("JOKER")) {
            return Type.JOKER;
        }

        // 判斷牌的種類
        int kind = 0;
        String[] parts = s.split("(\\s)+");

        Map<String, Integer> map = new HashMap<>();

        for (String str : parts) {
            if (map.containsKey(str)) {
                map.put(str, map.get(str) + 1);
            } else {
                map.put(str, 1);
            }
        }

        // 所有都是個子
        if (map.size() == parts.length) {
            int[] num = convert(parts);

            int max = num[0];
            boolean straight = true;
            for (int i = 1; i < num.length; i++) {
                // 記錄個子中的較大的值
                if (max < num[i]) {
                    max = num[i];
                }

                // 判斷是不是順子
                if (num[i] <= num[i - 1]) {
                    straight = false;
                    break;
                }
            }

            // 記錄最大值
            r[0] = max;
            // 是順子（不小於5張牌）
            if (straight && parts.length >= 5) {
                return Type.STRAIGHT;
            } else {
                return Type.SINGLE;
            }
        }
        // 有對子，三個，或者炸彈
        else {
            // 記錄是對子，三個，或者炸彈
            int type = 0;
            // 記錄牌面值
            int value = 0;

            for (Map.Entry<String, Integer> e : map.entrySet()) {
                // 比type高一階
                if (e.getValue() > type) {
                    type = e.getValue();
                    value = convert(e.getKey());
                }
                // 同一階，就記錄牌面值較大的
                else if (e.getValue() == type) {
                    int temp = convert(e.getKey());
                    if (temp > value) {
                        value = temp;
                    }
                }

                r[0] = value;

                if (type == 2) {
                    return Type.PAIR;
                } else if (type == 3) {
                    return Type.TRIPLE;
                } else if (type == 4) {
                    return Type.QUADRUPLE;
                }
            }
        }

        return Type.ERROR;
    }

    /**
     * 將一副牌轉換成數字
     *
     * @param poke 牌
     * @return 數字
     */
    private static int[] convert(String[] poke) {
        int[] result = new int[poke.length];
        for (int i = 0; i < poke.length; i++) {
            result[i] = convert(poke[i]);
        }

        return result;
    }

    private static int convert(String s) {

        if (s.length() == 1) {
            char c = s.charAt(0);
            if (c >= '3' && c <= '9') {
                return c - '0';
            }

            switch (c) {
                case 'J':
                    return 11;
                case 'Q':
                    return 12;
                case 'K':
                    return 13;
                case 'A':
                    return 14;
                case '2':
                    return 15;
                default:
                    // do nothing
            }

        } else {
            switch (s) {
                case "10":
                    return 10;
                case "joker":
                    return Integer.MAX_VALUE - 1;
                case "JOKER":
                    return Integer.MAX_VALUE;
                default:
                    // do nothing
            }
        }

        throw new RuntimeException("輸入錯誤");
    }


}