牛牛

牛牛是一种简单却又非常有意思的棋牌游戏：
1．牌面分数：10、J、Q、K都为10，其他按牌面数字计算。
2．任意3张牌之和为10的整数倍数，如果另外2张牌之和不为10的整数倍数，则根据这2张牌之和的个数为该副牌的牛数。例如（4，6，Q，9，9）牛数为8。
3．任意3张牌之和都不能为10的整数倍数，则判定该副牌无牛。例如（7，8，A，4。J）
4．任意3张牌之和为10的整数倍数，如果另外2张牌之和也为10的整数倍数，即为牛牛。例如（7，8，5，K，10）
5．在牛牛游戏中分数大的玩家获胜
牌型比较：五小 ＞五花 ＞四花 ＞ 牛牛 ＞ 有分 ＞ 没分；
分数比较：牛9＞ 牛8＞牛7＞牛6＞牛5＞牛4＞牛3＞牛2＞牛1。

/**
     * 无牛 五张牌中没有任意三张牌点数之和为10的整数倍。例如: a、8、4、k、7。
     * 有牛 五张牌中有三张的点数之和为10点的整数倍，并且另外两张牌之和与10进行取余，所得之数即为牛几。例如: 2、8、j、6、3，即为牛9。牛一到牛6为1倍，牛七到牛九位2倍。
     * 牛牛 五张牌中第一组三张牌和第一组二张牌之和分别为10的整数倍。 3、7、k、10、j。
     * 银牛 五张牌全由10～k组成且只有一张10，例如10、j、j、q、k。
     * 金牛 五张牌全由j～k组成，例如j、j、q、q、k。
     * 炸弹 五张牌中有4张牌点数相同的牌型，例如：2、2、2、2、k。
     * 五小牛 五张牌的点数加起来小于10，且每张牌点数都小于5，例如a、3、2、a、2。
     * @param list 五张牌
     * @return 结果
     */
    public static String nn(List<Integer> list) {
        if (CollUtil.isEmpty(list) || list.size() != 5) {
            return "数目不对";
        }
        // 小于5的 (五小牛)
        List<Integer> lte5 = list.stream().filter(s -> s < 5).collect(Collectors.toList());
        if (lte5.size() == 5) {
            int sum = lte5.stream().mapToInt(s -> s).sum();
            if (sum < 10) {
                return "五小牛";
            }
        }
        // 是否相同的数>=4 (炸弹)
        int maxSameSize = maxSameSize(list);
        if (maxSameSize >= 4) {
            return "炸弹";
        }
        // 大等于10的
        List<Integer> gte10 = list.stream().filter(s -> s >= 10).collect(Collectors.toList());
        if (gte10.size() == 5) {
            if (gte10.stream().filter(s -> s > 10).count() == 5) {
                return "金牛";
            }
            if (gte10.stream().filter(s -> s == 10).count() == 1) {
                return "银牛";
            }
            return "牛牛";
        }
        // 小于10的
        List<Integer> lt10 = list.stream().filter(s -> s < 10).collect(Collectors.toList());
        if (lt10.size() == 1) {
            return "牛" + lt10.get(0);
        } else if (lt10.size() == 2) {
            int x = lt10.get(0) + lt10.get(1);
            if (x == 10) {
                return "牛牛";
            }
            return "牛" + (x % 10);
        } else if (lt10.size() == 3) {
            // 三张相加
            int x = lt10.stream().mapToInt(s -> s).sum();
            if (x == 10) {
                return "牛牛";
            }
            // 其中两张相加=10
            int y = x % 10;
            if (lt10.contains(y)) {
                return "牛" + y;
            }
            return "无牛，最大为：" + CollUtil.max(list);
        } else if (lt10.size() == 4) {
            // 其中3张相加=10的倍数
            int x = lt10.stream().mapToInt(s -> s).sum();
            int y = x % 10;
            if (lt10.contains(y)) {
                return "牛" + y;
            }
            // 其中两张相加=10
            for (int i = 0; i < lt10.size() - 1; i++) {
                for (int j = i + 1; j < lt10.size(); j++) {
                    if (lt10.get(i) + lt10.get(j) == 10) {
                        int z = (x - 10) % 10;
                        if (z == 0) {
                            return "牛牛";
                        }
                        return "牛" + z;
                    }
                }
            }
            return "无牛，最大为：" + CollUtil.max(list);
        } else {
            // 5张牌都小于10
            int x  = lt10.stream().mapToInt(s -> s).sum();
            int size = lt10.size();
            List<Integer> left = new ArrayList<>();
            for (int i = 0; i < size - 2; i++) {
                for (int j = i + 1; j < size - 1; j++) {
                    for (int k = j + 1; k < size; k++) {
                        int y = lt10.get(i) + lt10.get(j) + lt10.get(k);
                        int z = (x - y) % 10;
                        if (y % 10 == 0) {
                            if (z == 0) {
                                return "牛牛";
                            }
                            left.add(z);
                        }
                    }
                }
            }
            if (CollUtil.isNotEmpty(left)) {
                return "牛" + CollUtil.max(left);
            }
            return "无牛，最大为：" + CollUtil.max(list);
        }
    }

    private static int maxSameSize(List<Integer> list) {
        Map<Integer, Integer> map = new HashMap<>();
        list.forEach(item -> {
            if (map.containsKey(item)) {
                map.put(item, map.get(item) + 1);
            } else {
                map.put(item, 1);
            }
        });
        return CollUtil.max(map.values());
    }

demo演示