HJ88 扑克牌大小

HJ88 扑克牌大小

描述

扑克牌游戏大家应该都比较熟悉了，一副牌由 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）输入的两手牌不会出现相等的情况。

数据范围：字符串长度：3≤s≤10 3≤s≤10

输入描述：

输入两手牌，两手牌之间用"-“连接，每手牌的每张牌以空格分隔，”-"两边没有空格，如 4 4 4 4-joker JOKER。

输出描述：

输出两手牌中较大的那手，不含连接符，扑克牌顺序不变，仍以空格隔开；如果不存在比较关系则输出 ERROR。

示例 1

输入：

4 4 4 4-joker JOKER

输出：

joker JOKER

题解

使用 List 集合记录牌大小顺序,通过比较索引来判断牌面大小

import java.util.Scanner;

import java.util.ArrayList;
import java.util.List;


// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNext()) { // 注意 while 处理多个 case
            // 输入两手牌，两手牌之间用"-"连接，
            // 每手牌的每张牌以空格分隔，
            // "-"两边没有空格，如 4 4 4 4-joker JOKER。
            String []str = in.nextLine().split("-");
            //  输出两手牌中较大的那手，不含连接符，
            //  扑克牌顺序不变，仍以空格隔开；如果不存在比较关系则输出ERROR。
            String res = getRes(str);
            System.out.println(res);
        }
    }
    // 输出两手牌中较大的那手，不含连接符，扑克牌顺序不变，仍以空格隔开；如果不存在比较关系则输出ERROR。
    public static String getRes(String[] str) {
        //
        // 3 4 5 6 7 8 9 10 J Q K A 2 joker JOKER
        // System.out.println(str);
        List<String> list = new ArrayList <>();
        list.add("3");
        list.add("4");
        list.add("5");
        list.add("6");
        list.add("7");
        list.add("8");
        list.add("9");
        list.add("10");
        list.add("J");
        list.add("Q");
        list.add("K");
        list.add("A");
        list.add("2");
        list.add("joker");
        list.add("JOKER");
        String []a = str[0].split(" "); // 第一首牌
        String []b = str[1].split(" "); // 第二首牌
        // System.out.println(a);
        // System.out.println(b);
        // a 是 个子
        if (a.length == 1) {
            // 个子
            if (b.length == 1) {
                // 也是 个子
                int aIndex = list.indexOf(a[0]);
                int bIndex = list.indexOf(b[0]);
                String res = aIndex > bIndex ? str[0] : str[1];
                return res;
            }
            // 炸弹
            if (b.length == 4) {
                return str[1];
            }
            // 王炸
            if ( str[1].contains("JOKER") && str[1].contains("joker")) {
                return str[1];
            }
        }
        // a 是 对子 不是王炸
        if (a.length == 2 && !str[0].contains("JOKER")) {
            // 对子
            if (b.length == 2 ) {
                int aIndex = list.indexOf(a[0]);
                int bIndex = list.indexOf(b[0]);
                String res = aIndex > bIndex ? str[0] : str[1];
                return res;
            }
            // 炸弹
            if (b.length == 4) {
                return str[1];
            }
            // 王炸
            if ( str[1].contains("JOKER") && str[1].contains("joker")) {
                return str[1];
            }
        }
        // a 是 三个
        if (a.length == 3) {
            // 三个
            if (b.length == 3) {
                int aIndex = list.indexOf(a[0]);
                int bIndex = list.indexOf(b[0]);
                String res = aIndex > bIndex ? str[0] : str[1];
                return res;
            }
            // 炸弹
            if (b.length == 4) {
                return str[1];
            }
            // 王炸
            if ( str[1].contains("JOKER") && str[1].contains("joker")) {
                return str[1];
            }
        }
        // a 是 顺子
        if (a.length == 5) {
            // 顺子
            if (b.length == 5) {
                int aIndex = list.indexOf(a[0]);
                int bIndex = list.indexOf(b[0]);
                String res = aIndex > bIndex ? str[0] : str[1];
                return res;
            }
            // 炸弹
            if (b.length == 4) {
                return str[1];
            }
            // 王炸
            if ( str[1].contains("JOKER") && str[1].contains("joker")) {
                return str[1];
            }
        }
        // a 是 炸弹 或者 王炸
        if (a.length == 4 ) {
            // 个子
            if (b.length == 1) {
                return str[0];
            }
            // 对子
            if (b.length == 2 ) {
                return str[0];
            }
            // 顺子
            if (b.length == 5) {
                return str[0];
            }
            // 三个
            if (b.length == 3) {
                return str[0];
            }
            // 炸弹
            if (b.length == 4) {
                int aIndex = list.indexOf(a[0]);
                int bIndex = list.indexOf(b[0]);
                String res = aIndex > bIndex ? str[0] : str[1];
                return res;
            }
            // 王炸
            if (str[1].contains("JOKER") && str[1].contains("joker")) {
                return str[1];
            }
        }
        if ( (str[0].contains("JOKER") && str[0].contains("joker"))) {
            // all
            return str[0];
        }
        // 不存在比较关系则输出ERROR。
        return "ERROR";
    }
}