华为OD机试【最长的顺子】(java)(100分)

1、题目描述
斗地主起源于湖北十堰房县，据说是一位叫吴修全的年轻人根据当地流行的扑克玩法”跑得快”改编的，如今已风靡整个中国，并流行于互联网上。
牌型:单顺，又称顺子，最少5张牌，最多12张牌(3…A)不能有2，也不能有大小王，不计花色。
例:3-4-5-6-7-8，7-8-9-10-J-Q，3-4-5-6-7-8-9-10-J-Q-K-A可用的牌3<4<5<6<7<8<9<10<J<Q<K<A<2<B(小王)C(大王)，每种牌除大小王外有四种花色(共有13x4+2张牌)。
1、输入

1. 手上有的牌
2. 已经出过的牌(包括对手出的和自己出的牌)
   2、输出
   对手可能构成的最长的顺子(如果有相同长度的顺子，输出牌面最大的那一个)
   如果无法构成顺子，则输出NO-CHAIN
   2、输入描述
   输入的第一行为当前手中的牌
   输入的第二行为已经出过的牌
   3、输出描述
   最长的顺子。
   用例：

输入
3-3-3-3-4-4-5-5-6-7-8-9-10-J-Q-K-A
A-4-5-6-7-8-8-8

输出
9-10-J-Q-K-A

温馨提示！！！
华为OD机试考试官方会对考生代码查重。华为od机试因为有题库所以有很大的概率抽到原题。如果碰到了题库中的原题，千万不要直接使用题解中的代码，一定要做些修改，比如代码中的变量名，除此之外，代码的组织结构和逻辑也要进行一些改变，所以在日常的刷题中，要提前编写好属于自己的代码。
4、题解
分别统计出已知的牌及数量，未出的牌及数量，然后循环遍历未出的牌，判断是否可以组成顺子，将可以组成的顺子的牌序列放入集合中，根据顺子长度进行降序排序，集合中的第一个元素即是最长的顺子，若集合为空则无法构成顺子。
代码如下：

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    String[] curArr = sc.nextLine().split("-");
    String[] usedArr = sc.nextLine().split("-");

    Map<String, String> equalMap = new HashMap<>();
    equalMap.put("J", "11");
    equalMap.put("Q", "12");
    equalMap.put("K", "13");
    equalMap.put("A", "14");
    // 手中的牌+已出的牌 及数量
    Map<Integer, Integer> knownMap = new HashMap<>();
    for (String item : curArr) {
        if ("B".equals(item) || "C".equals(item)) {
            continue;
        }
        if (equalMap.containsKey(item)) {
            item = equalMap.get(item);
        }
        Integer num = knownMap.getOrDefault(Integer.valueOf(item), 0);
        knownMap.put(Integer.valueOf(item), num+1);
    }

    // 已经出的牌
    for (String item : usedArr) {
        if ("B".equals(item) || "C".equals(item)) {
            continue;
        }
        if (equalMap.containsKey(item)) {
            item = equalMap.get(item);
        }
        Integer num = knownMap.getOrDefault(Integer.valueOf(item), 0);
        knownMap.put(Integer.valueOf(item), num+1);
    }

    // 对手中的牌及数量
    Map<Integer, Integer> remainMap = new LinkedHashMap<>();
    for (Integer i=3; i<15; i++) {
        int num = 4;
        if (knownMap.containsKey(i)) {
            num = 4 - knownMap.get(i);
        }
        if (num > 0) {
            remainMap.put(i, num);
        }
    }

    List<Integer> reList = new ArrayList<>();
    for (Integer item : remainMap.keySet()) {
        reList.add(item);
    }
    //System.out.println(reList);
    List<String> res = getRes(reList);
    if (res.isEmpty()) {
        System.out.println("NO-CHAIN");
    }else {
        String str = res.get(0);
        System.out.println(str);
    }
}

private static List<String> getRes(List<Integer> sets) {
    Map<Integer, String> equalMap2 = new HashMap<>();
    equalMap2.put(11, "J");
    equalMap2.put(12, "Q");
    equalMap2.put(13, "K");
    equalMap2.put(14, "A");
    List<String> res = new ArrayList<>();
    StringBuilder sb = new StringBuilder();
    for (int i=0; i<sets.size(); i++) {
        sb.append(equalMap2.getOrDefault(sets.get(i), sets.get(i)+"")).append("-");
        int p = i;
        for (int j=p+1; j<sets.size(); j++) {
            // 是否可以构成顺子
            if (sets.get(j) - sets.get(p) == 1) {
                sb.append(equalMap2.getOrDefault(sets.get(j), sets.get(j)+""))
                .append("-");
                p = j;
            }else {
                break;
            }
        }
        // 将构成的顺子加入集合
        if (sb.toString().split("-").length > 4) {
            res.add(sb.deleteCharAt(sb.length()-1).toString());
        }
        i = p;
        sb.setLength(0);
    }
    // 按照顺子长度降序排序
    Collections.sort(res, (o1, o2) -> {
        if (o1.length() == o2.length()) {
            return o2.charAt(0) - o1.charAt(0);
        }else {
            return o2.length() - o1.length();
        }
    });
    return res;
}

执行结果如下：