华为OD机试 - 最长的顺子 - 感谢@禁止你发言提供的更简便算法（Java 2024 E卷 200分）

已于 2024-08-24 16:50:42 修改
阅读量1.4k 收藏 10
点赞数 19
分类专栏： 华为OD机试（JAVA）真题（E卷+D卷+A卷+B卷+C卷） 文章标签： 华为od java 七日集训 学习
于 2023-10-18 10:58:01 首次发布
本文为博主原创文章，未经博主允许不得转载。
本文链接：https://blog.csdn.net/guorui_java/article/details/133788190
版权
本文详细介绍了华为OD机试2023B卷中关于最长顺子的问题，包括题目描述、输入输出、解题思路和Java算法源码。解题关键在于利用映射转换和动态规划找到对手可能构成的最长顺子。
摘要由CSDN通过智能技术生成

在这里插入图片描述

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

专栏导读

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

刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新，全天CSDN在线答疑。

一、题目描述

斗地主起源于湖北十堰房县，据说是一位叫吴修全的年轻人根据当地流行的扑克玩法”跑得快”改编的，如今已风靡整个中国，并流行于互联网上。

牌型:单顺，又称顺子，最少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

二、输入描述

输入的第一行为当前手中的牌

输入的第二行为已经出过的牌

三、输出描述

最长的顺子

输入输出说明
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

四、解题思路

  1. 定义jqkaMap，进行JQKA的映射转换，便于排序；
  2. 第一行输入当前手中的牌；
  3. 第二行输入已经出过的牌；
  4. 定义集合list，存储当前手中的牌 + 已经出过的牌；
  5. 定义map，存储对手的牌；
    • 全部牌 - 当前手中的牌 - 已经出过的牌；
    • key：3-A，value：每张牌的数量；
  6. 获取最大的龙；
    • 定义集合dragonList，存储符合要求的最大的龙；
    • map倒序遍历，获取符合要求的最大的龙；
      • 有剩余牌时，拼接龙；
      • 当没有牌时，表示能获取到的最大的龙；
      • 如果获取的龙，符合斗地主要求，则直接返回，否则清空dragonList，重新计算；
  7. 如果能获取到的最大的龙，不符合斗地主要求，直接返回NO-CHAIN；
  8. 按指定格式输出。

五、Java算法源码

private static Map<String, Integer> jqkaMap = new HashMap<>();
private static Map<Integer, String> reverseMap = new HashMap<>();

// B(小王)C(大王)
private static String specialStr = "2BC";

static {
    jqkaMap.put("J", 11);
    jqkaMap.put("Q", 12);
    jqkaMap.put("K", 13);
    jqkaMap.put("A", 14);

    reverseMap.put(11, "J");
    reverseMap.put(12, "Q");
    reverseMap.put(13, "K");
    reverseMap.put(14, "A");
}

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    // 当前手中的牌
    List<Integer> line1 = Arrays.asList(sc.nextLine().split("-")).stream().filter(x->!specialStr.contains(x)).map(x -> {
        if (jqkaMap.containsKey(x)) {
            return String.valueOf(jqkaMap.get(x));
        }
        return x;
    }).mapToInt(Integer::parseInt).boxed().collect(Collectors.toList());

    // 已经出过的牌
    List<Integer> line2 = Arrays.asList(sc.nextLine().split("-")).stream().filter(x->!specialStr.contains(x)).map(x -> {
        if (jqkaMap.containsKey(x)) {
            return String.valueOf(jqkaMap.get(x));
        }
        return x;
    }).mapToInt(Integer::parseInt).boxed().collect(Collectors.toList());

    // 当前手中的牌 + 已经出过的牌
    List<Integer> list = new ArrayList<>();
    list.addAll(line1);
    list.addAll(line2);
    System.out.println(list);

    /**
     * 对手的牌 = 全部牌 - 当前手中的牌 - 已经出过的牌
     *
     * key：3-A，value：每张牌的数量
     */
    Map<Integer, Integer> map = new HashMap<>();
    for (int i = 0; i < list.size(); i++) {
        Integer s = list.get(i);
        s = jqkaMap.getOrDefault(s, s);
        Integer sum = map.getOrDefault(s, 4);
        map.put(s, --sum);
    }
    System.out.println(map);

    // 获取最大的龙
    List<Integer> dragonList = getDragonList(map);
    // 如果能获取到的最大的龙，不符合斗地主要求，直接返回NO-CHAIN
    if(dragonList.size() < 5){
        System.out.println("NO-CHAIN");
        return;
    }

    // 按指定格式输出
    StringJoiner stringJoiner = new StringJoiner("-");
    dragonList.stream().sorted((o1, o2) -> {
        return o1.compareTo(o2);
    }).map(x -> {
        if (reverseMap.containsKey(x)) {
            String temp = String.valueOf(reverseMap.get(x));
            stringJoiner.add(temp);
            return temp;
        }
        stringJoiner.add(String.valueOf(x));
        return x;
    }).collect(Collectors.toList());
    System.out.println(stringJoiner);
}

/**
 * 获取最大的龙
 * @param map 对手的牌 key：3-A，value：每张牌的数量
 * @return 最大的龙
 */
private static List<Integer> getDragonList(Map<Integer, Integer> map){
    // 获取符合要求的最大的龙
    List<Integer> dragonList = new ArrayList<>();
    // map倒序遍历，获取符合要求的最大的龙
    ListIterator<Map.Entry<Integer, Integer>> mapList = new ArrayList<>(map.entrySet()).listIterator(map.size());
    while (mapList.hasPrevious()) {
        Map.Entry<Integer, Integer> previousMap = mapList.previous();
        // 有剩余牌时，拼接龙
        if (previousMap.getValue() > 0) {
            dragonList.add(previousMap.getKey());
        } else if (previousMap.getValue() == 0) {// 当没有牌时，表示能获取到的最大的龙
            // 如果获取的龙，符合斗地主要求，则直接返回，否则清空dragonList，重新计算
            if(dragonList.size()>=5){
                break;
            }else {
                dragonList = new ArrayList<>();
            }
        }
    }
    System.out.println(dragonList);
    return dragonList;
}

六、感谢@禁止你发言提供的更简单、更优质的算法

解题思路

1、获取输入：当前手中的牌 + 已经出过的牌，并合并字符串，分割为数组；

2、定义char2int map，进行JQKA的映射转换，便于排序;

3、定义reverseMap，int转回JQKA，方便最后打印顺子；

4、定义数组theirPokers表示对手的牌，遍历前述的合并牌数组（当前手中的牌 + 已经出过的牌），每遍历到一张牌，对手的牌对应的数组元素 - 1。

注意:

  1. 数组长度由来：有题目可知，顺子有效的牌为3-14，所以长度为14 - 3 + 1
  2. 为什么-3：有效的顺子牌从3开始，而数组下标需要从0开始

5、动态规划获取最长的顺子，以当前牌结尾的顺子长度只与以前一个牌结尾的顺子长度和当前牌是否可用有关。

  1. 如果对方的牌含有3，则初始值设置为1，否则为0
  2. 定义start记录最长顺子的起始牌
  3. 定义max记录最长顺子的长度
  4. 有剩余牌时，拼接顺子，即以当前牌结尾的顺子长度为以前一个牌结尾的顺子长度 + 1
  5. 没有剩余牌时，顺子长度置为0

注意这里有个优化技巧，由于当前牌的顺子长度只与前一个牌的顺子长度和当前牌是否可用有关，因此我们不需要定义dp数组
可优化为：

int prev = theirPokers[0] > -4 ? 1 : 0;
int current;
int max = Integer.MIN_VALUE;
//记录最长顺子的起始牌
int start = 1;
for (int i = 1; i < theirPokers.length; i++) {
    //有剩余牌时，拼接顺子
    if (theirPokers[i] > -4) {
        current = prev + 1;
        if (current > max) {
            max = current;
            start = i + 3 - max + 1;  //注意这里+3，是由于数组下标和扑克牌之间差了3
        }
        // 无剩余牌，顺子长度置为0
    } else {
        current = 0;
    }
    prev = current;
}

存储空间降低，但可读性差了点。

6、如果符合条件（顺子长度不小于5），则按格式输出

7、如果不符合，则输出NO-CHAIN

优质算法源码

public static void main(String[] args) {
    //获取输入：当前手中的牌 + 已经出过的牌， 并合并
    Scanner scanner = new Scanner(System.in);
    String myPokers = scanner.next();
    String alreadyPokers = scanner.next();
    String[] mergePokers = myPokers.concat("-").concat(alreadyPokers).split("-");

    //为方便后续判断顺子，将JQKA转为int, reverse为供后续打印顺子使用
    Map<Character, Integer> char2int = new HashMap<>();
    char2int.put('J', 11);
    char2int.put('Q', 12);
    char2int.put('K', 13);
    char2int.put('A', 14);
    Map<Integer, Character> reverseMap = char2int.entrySet().stream()
            .collect(Collectors.toMap(Map.Entry::getValue, Map.Entry::getKey));

    // 定义数组表示对手的牌，遍历前面合并牌数组（当前手中的牌 + 已经出过的牌），每遍历到一张牌，对手的牌对应的数组元素 - 1
    // 注意: 数组长度由来：有题目可知，顺子有效的牌为3-14，所以长度为14 - 3 + 1
    // 注意：为什么-3：有效的顺子牌从3开始，而数组下标需要从0开始
    int[] theirPokers = new int[14 - 3 + 1];
    for (String poker : mergePokers) {
        if (poker.length() > 1) {                                      // 10
            theirPokers[Integer.parseInt(poker) - 3]--;
        } else if (char2int.containsKey(poker.charAt(0))) {            //JQKA
            theirPokers[char2int.get(poker.charAt(0)) - 3]--;
        } else if (poker.charAt(0) != '2' && poker.charAt(0) != 'B' && poker.charAt(0) != 'C') {
            theirPokers[Integer.parseInt(poker) - 3]--;
        }
    }

    // 动态规划获取最长的顺子，当前牌的顺子长度只与前一个牌的顺子长度和当前牌是否可用有关
    //如果对方的牌含有3，则初始值设置为1，否则为0
    int prev = theirPokers[0] > -4 ? 1 : 0;
    int current;
    int max = Integer.MIN_VALUE;
    //记录最长顺子的起始牌
    int start = 1;
    for (int i = 1; i < theirPokers.length; i++) {
        //有剩余牌时，拼接顺子
        if (theirPokers[i] > -4) {
            current = prev + 1;
            if (current > max) {
                max = current;
                // 注意这里+3，是由于数组下标和扑克牌之间差了3
                start = i + 3 - max + 1;
            }
            // 无剩余牌，顺子长度置为0
        } else {
            current = 0;
        }
        prev = current;
    }

    // 符合条件
    if (max >= 5) {
        String straight = IntStream.range(start, start + max)
                .mapToObj(poker -> poker > 10 ? reverseMap.get(poker) : poker)
                .map(String::valueOf).collect(Collectors.joining("-"));
        System.out.println(straight);
        //长度小于5， 输出NO-CHAIN
    } else {
        System.out.println("NO-CHAIN");
    }
}

七、效果展示

1、输入

3-3-4-4-5-A-5-6-2-8-3-9-10-Q-7-K-J-10-B
A-4-5-8-8-10-C-6-7-8

2、输出

9-10-J-Q-K-A

3、说明

  1. 拼接两个字符串，排除掉不能成龙的2和大小王；
  2. [3, 3, 4, 4, 5, 14, 5, 6, 8, 3, 9, 10, 12, 7, 13, 11, 10, 14, 4, 5, 8, 8, 10, 6, 7, 8]
  3. 获取对手的牌，{3=1, 4=1, 5=1, 6=2, 7=2, 8=0, 9=3, 10=1, 11=3, 12=3, 13=3, 14=2}；
  4. 获取对手的牌能组成的最大的龙，[14, 13, 12, 11, 10, 9]；
  5. 数值映射转换9-10-J-Q-K-A。

在这里插入图片描述


🏆下一篇：华为OD机试 - 简易内存池 - 逻辑分析（Java 2024 D卷 200分）

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

刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新，全天CSDN在线答疑。

在这里插入图片描述

哪 吒
关注
专栏目录
订阅专栏
华为OD机试E卷 - 斗地主之顺子（Java & Python& JS & C++ & C ）
算法大师！
08-18 4668
华为OD机试E卷 - 斗地主之顺子斗地主扑克牌游戏中， 扑克牌由小到大的顺序为：3,4,5,6,7,8,9,10,J,Q,K,A,2，玩家可以出的扑克牌阵型有：单张、对子、顺子、飞机、炸弹等。
斗地主最大顺子查找
longxingtx520的博客
04-06 995
  package cn.longxingtx.number; import java.util.ArrayList; public class Straight { private int[] straight_arr; public int[] getStraight_arr() { return straight_arr; } public...
“排序+计数”实现找顺子功能
学无止境
03-23 634
题目描述 LL今天心情特别好,因为他去买了一副扑克牌,发现里面居然有2个大王,2个小王(一副牌原本是54张^_^)...他随机从中抽出了5张牌,想测测自己的手气,看看能不能抽到顺子,如果抽到的话,他决定去买体育彩票,嘿嘿！！“红心A,黑桃3,小王,大王,方片5”,“Oh My God!”不是顺子.....LL不高兴了,他想了想,决定大\小 王可以看成任何数字,并且A看作1,J为11,Q为12
棋牌开发里面如何写好搜索顺子的算法
huangdecai2的专栏
08-10 648
很多有3年开发经验以上的朋友，可能不屑一顾,这有何难，不就是几行代码的事，从我所见到的所有版本中，目前还没有一个令我满意的版本，满分100分最多占到70，不合格的占90%。下面我就让大家看看我公司同事写的各个搜索顺子算法的版本吧。先看斗地主的一个搜索顺子的版本 -- 顺子 local function IsSingleLine(nCards,nCardNum) for i=1,nCardNum-1 do if GetCard(nCards[1]) > 12 the...
扑克牌游戏中, 使用python实现一个查找顺子的算法
weixin_42784553的博客
02-28 2288
在扑克牌游戏中, 需要实现一个查找顺子的算法:(连续的数字即为顺子), 随机发N张牌, 从中挑出最长的顺子, 并返回其长度, 如果没有顺子返回0. 现在手上的牌为[12,3,4,10,6,5,6,8,11,9,11,11,9,12,1]. # 1.去重,排序 m= [12,3,4,10,6,5,6,8,11,9,11,11,9,12,1] m.sort() s = set(m) m1 = list...
华为OD机试 - 乘坐保密电梯 - 感谢 @陈凌 提供的改进代码（Java 2024 C卷 200分）
学Java，找哪吒
03-19 1437
刷的越多，抽中的概率越大，每一题都有详细的答题思路、详细的代码注释、样例测试，发现新题目，随时更新，全天CSDN在线答疑。
2024华为OD机考机试E卷 +C卷 + D卷 + B卷 + A卷：真题目录 + 考点说明
热门推荐
算法大师！
03-18 39万+
OD，全称(Outsourcing Dispacth)模式，目前华为和德科联合招聘的简称。华为社招基本都是OD招聘，17级以下都是OD模式（13-17）。
华为OD机试 - 最长的顺子 - 动态规划（Python/JS/C/C++ 2024 E卷 200分）
最新发布
学Java，找哪吒
09-01 932
每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新，全天CSDN在线答疑。
整型数组处理算法（十二）请实现一个函数：最长顺子。[风林火山]
军说网事
10-10 4767
请实现一个函数：最长顺子；输入很多个整数(1<=数值<=13)， 返回其中可能组成的最长的一个顺子(顺子中数的个数代表顺的长度)； 其中数字1也可以代表14； 顺子包括单顺\双顺\3顺； 单顺的定义是连续5个及以上连续的数，比如1,2,3,4,5、3,4,5,6,7,8和10,11,12,13,1等； 双顺的定义是连续3个及以上连续的对(对:两个相同的数被称为对), 比如1,1,2,2,3,3、4,4,5,5,6,6,7,7和11,11,12,12,13,13,1,1等; 3顺的定义是连续2个及以上连续的3
从一组数据中找出最长的连续子串（以一副扑克牌手牌为例）
Always_MyHomeTown的博客
06-21 1218
前几天听同学说到面试时的一道算法题，就是找出一幅手牌中最长的连续子串，怎么实现，想来最近在找工作，所以写出来当练练手，好久没有写代码了，有些手硬了。 我做这个问题的思路：1，使手上产生17张手牌，当然手牌数可以随机，可以在getDatas（）中抽取；2，在产生手牌时要做一些扑克牌限制（如最多相同牌只有四张）；3，查找过程中，为了提高速度，所以需要过滤相同的手牌，4在过滤后的手牌中遍历比较，以冒泡算法为基础遍历查找，每当有一组子串数据时，就存储在一个集合中，然后集合去存储这些子串集合，便于后面的长度查找。
扑克牌顺子
水滴石穿
06-28 3094
题目LL今天心情特别好,因为他去买了一副扑克牌,发现里面居然有2个大王,2个小王(一副牌原本是54张^_^)…他随机从中抽出了5张牌,想测测自己的手气,看看能不能抽到顺子,如果抽到的话,他决定去买体育彩票,嘿嘿！！“红心A,黑桃3,小王,大王,方片5”,“Oh My God!”不是顺子…..LL不高兴了,他想了想,决定大\小 王可以看成任何数字,并且A看作1,J为11,Q为12,K为13。上面的5张
在扑克牌游戏中, 需要实现一个查找顺子的算法
一叶孤舟YI的博客
07-15 4237
A: 在扑克牌游戏中, 需要实现一个查找顺子的算法:(连续的数字即为顺子), 随机发N张牌, 从中挑出最长的顺子, 并返回其长度, 如果没有顺子返回0. 现在手上的牌为[12,3,4,10,6,5,6,8,11,9,11,11,9,12,1]. # 1.去重,排序 m= [12,3,4,10,6,5,6,8,11,9,11,11,9,12,1] m.sort() s = set(m) m1 =...
实现一个函数：最长顺子
aiaiya
10-24 1857
XX公司综合机试题第三题，以前有人讨论过，这里列出不同的算法 3.请实现一个函数：最长顺子；输入很多个整数(1 0) { Map maxList = allList.get(allList.lastKey()); List resultList = new LinkedList(); Collection coll = maxList.values(); int m...
剑指offer——扑克牌的顺子
weixin_30571465的博客
09-06 72
思想： 1、先将输入的几个数进行排序，sort函数是#include<algorithm>下的。 2、统计0的个数，以及相邻数的差值，比较0的个数及差值的和。看是否可以用大王填充中间的差值。 1 #include <iostream> 2 #include <algorithm> 3 #include <stdlib.h> 4...
在n张扑克牌中找出顺子
华丽的痘痘
08-13 7905
        这是今天在论坛看到的一个题目，挺有意思的，我做了一下，得了28分。呵呵，很有成就感，干脆写到博客里面算了。       题目是这样的：有n张扑克牌，每张牌的取值范围是：2，3，4，5，6，7，8，9，10，J，Q，K，A。在这n张牌中找出顺子（5张及5张以上的连续的牌），并将这些顺子打印出来。        思路：我的思路其实很简单，首先就是要去掉重复的牌，因为同样的顺子之
b卷-华为od机试 - 代表团坐车 java
08-30
华为OD机试-B卷代表团坐车Java实现如下： 可以使用Java中的对象和类来实现代表团坐车的功能。 首先，我们可以创建一个代表团类（DelegateGroup），用于存储代表团中每个成员的姓名、目的地和乘车状态等信息。在代表团类中可以定义成员变量name、destination和status等，并添加相应的getter和setter方法。 然后，我们可以创建一个乘车类（Bus），表示可以坐的公共交通工具。在乘车类中可以定义一个成员变量capacity，表示公共交通工具的总容量，以及一个成员变量occupied，表示当前已经被占用的座位数量。同样，还可以添加getter和setter方法。 接下来，在主程序中，我们可以实例化几个代表团对象，例如通过DelegateGroup类创建代表团成员A、B、C等，并为每个成员指定目的地和乘车状态等信息。 然后，我们可以实例化一个公共交通工具对象，例如通过Bus类创建一个公交车对象bus，并设置总容量和当前已被占用的座位数量等信息。 接着，我们可以通过循环遍历代表团成员，根据成员的乘车状态来判断是否可以为该成员分配座位。如果成员的乘车状态为“需要乘车”且公共交通工具的座位尚未全部被占用，那么可以为该成员分配一个座位，并将公共交通工具的已占用座位数量加1。如果成员的乘车状态为“不需要乘车”或公共交通工具的座位已全部占满，那么不为该成员分配座位。 最后，我们可以输出每个代表团成员的姓名、目的地和乘车状态，并输出公共交通工具的总容量和已占用座位数量等信息。 以上就是用Java实现代表团坐车功能的简单示例。还可以根据实际需求进行扩展和优化。
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

哪 吒

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值