华为OD机试 - 德州扑克 - 逻辑分析（Java 2023 B卷 200分）

华为OD机试 2023B卷题库疯狂收录中，刷题点这里

专栏导读

本专栏收录于《华为OD机试（JAVA）真题（A卷+B卷）》。

刷的越多，抽中的概率越大，每一题都有详细的答题思路、详细的代码注释、样例测试，发现新题目，随时更新，全天CSDN在线答疑。

一、题目描述

五张牌，每张牌由牌大小和花色组成，牌大小2~10、J、Q、K、A，牌花色为红桃、黑桃、梅花、方块四种花色之一

1、判断牌型

牌型1，同花顺:同一花色的顺子，如红桃2红桃3红桃4红桃5红桃6。

牌型2，四条:四张相同数字+单张，如红桃A黑桃A梅花A方块A+黑桃K.

牌型3，葫芦:三张相同数字+一对，如红桃5黑桃5梅花5+方块9梅花9。

牌型4，同花:同一花色，如方块3方块7方块10方块J方块Q.

牌型5，顺子:花色不一样的顺子，如红桃2黑桃3红桃4红桃5方块6。

牌型6，三条:三张相同+两张单。

2、说明

1. 五张牌里不会出现牌大小和花色完全相同的牌；
2. 编号小的牌型较大，如同花顺比四条大，依次类推；
3. 包含A的合法的顺子只有10JQKA和A2345;类似KA23的序列不认为是顺子。

二、输入描述

输入由5行组成，每行为一张牌大小和花色，牌大小为2~10、J、Q、K、A，花色分别用字符H、S、C、D表示红桃、黑桃、梅花、方块。

三、输出描述

输出牌型序号，5张牌符合多种牌型时，取最大的牌型序号输出。

用例：

1、输入

4 H
5 S
6 C
7 D
8 D

2、输出

5

3、说明

可以组成45678，牌型5，顺子

四、解题思路

1. 输入由5行组成，每行为一张牌大小和花色，牌大小为2~10、J、Q、K、A，花色分别用字符H、S、C、D表示红桃、黑桃、梅花、方块。
2. 特殊字符转换；
3. 根据数值升序排序；
4. 判断对手的牌型；
   • 默认为顺子，如果扑克牌不是自增的，判断不是顺子；
   • 默认为同花，如果扑克牌不是相同颜色，判断不是同花；
   • 定义map，存储对手的牌型，key：joker value：张数；
   • 特殊处理，2、3、4、5、A；
   • 判断四条、三条、葫芦；
5. 组合判断牌型，按照牌型级别顺序输出。

五、Java算法源码

// 同花
private static boolean sameColor = true;
// 顺子
private static boolean dragon = true;
// 四条
private static boolean fourKind = false;
// 三条
private static boolean threeKind = false;
// 两条
private static boolean twoKind = false;

private static Map<String, Integer> jqkaMap = new HashMap<>();
static {
    jqkaMap.put("J", 11);
    jqkaMap.put("Q", 12);
    jqkaMap.put("K", 13);
    jqkaMap.put("A", 14);
}

/**
 * 输入由5行组成，每行为一张牌大小和花色，牌大小为2~10、J、Q、K、A，
 * 花色分别用字符H、S、C、D表示红桃、黑桃、梅花、方块。
 */
public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    List<String[]> intList = new ArrayList<>();
    for (int i = 0; i < 5; i++) {
        intList.add(sc.nextLine().split(" "));
    }

    List<String[]> collect = intList.stream().map(x -> {// 特殊字符转换
        if (jqkaMap.containsKey(x[0])) {
            x[0] = String.valueOf(jqkaMap.get(x[0]));
        }
        return x;
    }).sorted(new Comparator<String[]>() {// 根据数值升序排序
        @Override
        public int compare(String[] o1, String[] o2) {
            Integer poker1 = jqkaMap.getOrDefault(o1[0], Integer.valueOf(o1[0]));
            Integer poker2 = jqkaMap.getOrDefault(o2[0], Integer.valueOf(o2[0]));
            return poker1 - poker2;
        }
    }).collect(Collectors.toList());

    // 判断牌型
    judgeJoker(collect);
    // 输出牌型
    System.out.println(judge());
}

// key：joker value：张数
static Map<Integer, Integer> map = new HashMap<>();
private static void judgeJoker(List<String[]> intList) {
    for (int i = 0; i < intList.size(); i++) {
        Integer poker = Integer.valueOf(intList.get(i)[0]);
        String color = intList.get(i)[1];
        if (i + 1 < intList.size()) {
            Integer next = Integer.valueOf(intList.get(i + 1)[0]);
            // 默认为顺子，如果扑克牌不是自增的，判断不是顺子
            if (dragon && !(++poker).equals(next)) {
                dragon = false;
            }

            // 默认为同花，如果扑克牌不是相同颜色，判断不是同花
            String nextColor = intList.get(i + 1)[1];
            if (sameColor && !color.equals(nextColor)) {
                sameColor = false;
            }
        }

        // key：joker value：张数
        Integer sum = map.getOrDefault(poker, 0);
        map.put(poker, ++sum);
    }

    // 特殊处理，2、3、4、5、A
    specialDragon(intList);

    List<Map.Entry<Integer, Integer>> mapList = new ArrayList<>(map.entrySet());
    mapList.stream().map(x -> {
        Integer sum = x.getValue();
        if (sum.equals(4)) {// 判断四条
            fourKind = true;
        }
        if (sum.equals(3)) {// 判断三条
            threeKind = true;
        }
        if (sum.equals(2)) {// 判断葫芦
            twoKind = true;
        }
        return x;
    }).collect(Collectors.toList());
}

// 特殊处理，2、3、4、5、A
private static void specialDragon(List<String[]> intList) {
    Integer first = Integer.valueOf(intList.get(0)[0]);
    Integer two = Integer.valueOf(intList.get(1)[0]);
    Integer three = Integer.valueOf(intList.get(2)[0]);
    Integer four = Integer.valueOf(intList.get(3)[0]);
    Integer five = Integer.valueOf(intList.get(4)[0]);
    if (first.equals(2) && two.equals(3) && three.equals(4) && four.equals(5) && five.equals(14)) {
        dragon = true;
    }
}

/**
 * 组合判断牌型，按照牌型级别顺序输出
 */
private static int judge() {
    if (dragon && sameColor) return 1;// 牌型1，同花顺
    if (fourKind) return 2;// 牌型2，四条
    if (threeKind && twoKind) return 3;// 牌型3，葫芦
    if (sameColor) return 4;// 牌型4，同花
    if (dragon) return 5;// 牌型5，顺子
    if (threeKind) return 6;// 牌型6，三条
    return 0;
}

六、效果展示

1、输入

10 H
J H
K H
A H
Q H

2、输出

1

3、说明

可以组成10JQKA, 花色相同，牌型1，同花顺

下一篇：华为OD机试 - 荒岛求生 - 栈Stack（Java 2023 B卷 100分）

本文收录于，华为OD机试（JAVA）真题（A卷+B卷）

刷的越多，抽中的概率越大，每一题都有详细的答题思路、详细的代码注释、样例测试，发现新题目，随时更新，全天CSDN在线答疑。