华为OD机试真题B卷 Java 实现【整理扑克牌】，附详细解题思路

news2024/11/24 5:58:20

一、题目描述

给定一组数字，表示扑克牌的牌面数字，忽略扑克牌的花色，请按如下规则对这一组扑克牌进行整理：

步骤1

对扑克牌进行分组，形成组合牌，规则如下：

当牌面数字相同张数大于等于4时，组合牌为“炸弹”；
3张相同牌面数字 + 2张相同牌面数字，且3张牌与2张牌不相同时，组合牌为“葫芦”；
3张相同牌面数字，组合牌为“三张”；
2张相同牌面数字，组合牌为“对子”；
剩余没有相同的牌，则为“单张”；

步骤2

对上述组合牌进行由大到小排列，规则如下：

不同类型组合牌之间由大到小排列规则：“炸弹” > “葫芦” > “三张” > “对子” > “单张”；
相同类型组合牌之间，除“葫芦”外，按组合牌全部牌面数字加总由大到小排列；
“葫芦”则先按3张相同牌面数字加总由大到小排列，3张相同牌面数字加总相同时，再按另外2张牌面数字加总由大到小排列；
由于“葫芦”>“三张”，因此如果能形成更大的组合牌，也可以将“三张”拆分为2张和1张，其中的2张可以和其它“三张”重新组合成“葫芦”，剩下的1张为“单张”。

步骤3

当存在多个可能组合方案时，按如下规则排序取最大的一个组合方案：

依次对组合方案中的组合牌进行大小比较，规则同上；
当组合方案A中的第n个组合牌大于组合方案B中的第n个组合牌时，组合方案A大于组合方案B；

二、输入描述

5 2 5 4 1 3 4 3 3 2 5 4 5

三、输出描述

5 5 5 5 4 4 4 3 3 2 2 3 1

四、解题思路

首先，将输入的一组数字存储在一个List中，表示扑克牌的牌面数字；
创建一个HashMap map，用于统计每个牌面数字出现的次数；Key为牌面数字，Value为对应的次数；
将HashMap map 转换为List，并根据牌面数字的出现次数和牌面数字本身进行排序；排序规则为：
- 如果两个牌面数字的出现次数相同，则按牌面数字本身从大到小排序；
- 如果两个牌面数字的出现次数不同，则按出现次数从大到小排序；
创建一个StringBuilder builder，用于拼接排列后的扑克牌结果；
创建一个List splitList，用于存储拆分后的牌组中的"三张"的牌面数字；
遍历排序后的List，按照规则进行牌组的排列；
- 如果遍历到的牌组是"葫芦"且之前有"三张"，则拆分该"葫芦"为两个"对子"和一个"单张"；
- 如果遍历到的牌组是"单张"且之前有"葫芦"拆分的"单张"，则与之前的"葫芦"中的"对子"组合为新的"葫芦"；
- 其他情况直接按照出现次数将牌面数字添加到StringBuilder builder中；
如果存在拆分后的"单张"，将其按照牌面数字从大到小的顺序添加到StringBuilder builder中；
输出StringBuilder builder的内容作为结果；

五、Java算法源码

public static void main(String[] args) {
    // 处理输入
    Scanner in = new Scanner(System.in);
    List<Integer> nums = Arrays.stream(in.nextLine().split(" "))
            .map(Integer::parseInt)
            .collect(Collectors.toList());

    //key：牌面点数，value：该点数的张数
    Map<Integer, Integer> map = new HashMap<>();
    for (int num : nums) {
        map.put(num, map.getOrDefault(num, 0) + 1);
    }

    // 先按张数排序，再按点数排序
    List<Map.Entry<Integer, Integer>> list = new ArrayList<>(map.entrySet());
    list.sort((a, b) -> {
        if (b.getValue() == a.getValue()) {
            return b.getKey() - a.getKey();
        }
        return b.getValue() - a.getValue();
    });

    StringBuilder builder = new StringBuilder();
    List<Integer> splitList = new ArrayList<>();
    for (int i = 0; i < list.size(); i++) {
        Map.Entry<Integer, Integer> temp = list.get(i);
        int num = temp.getKey();
        int count = temp.getValue();
        // 由于“葫芦”>“三张”，因此如果能形成更大的组合牌，也可以将“三张”拆分为2张和1张，
        // 其中的2张可以和其它“三张”重新组合成“葫芦”，剩下的1张为“单张”。
        if (i > 0 && list.get(i - 1).getValue() == 3 && count == 3) {
            splitList.add(num);
            count = 2;
            temp.setValue(2);
        } else if (count == 1 && splitList.size() != 0) {
            for (int k = 0; k < splitList.size(); k++) {
                if (splitList.get(k) > num) {
                    builder.append(splitList.get(k) + " ");
                    splitList.remove(k);
                    k--;
                }
            }
        }
        for (int j = 0; j < count; j++) {
            builder.append(num + " ");
        }
    }

    if (splitList.size() != 0) {
        for (int i : splitList) {
            builder.append(i + " ");
        }
    }
    System.out.println(builder.substring(0, builder.length() - 1));
}