华为OD机试 - 最长的顺子 - 动态规划（Python/JS/C/C++ 2024 E卷 200分）

已于 2024-09-06 07:53:50 修改
阅读量832 收藏 1
点赞数
分类专栏： 华为OD机试真题（Python/JS/C/C++） 文章标签： python 华为od 动态规划 java javascript c c++
于 2024-09-01 11:09:53 首次发布
本文为博主原创文章，未经博主允许不得转载。
本文链接：https://blog.csdn.net/guorui_java/article/details/141781514
版权

在这里插入图片描述

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

专栏导读

本专栏收录于《华为OD机试真题（Python/JS/C/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. 按指定格式输出。

五、测试用例

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。

六、Python算法源码

def main():
    # 获取输入：当前手中的牌 + 已经出过的牌，并合并
    my_pokers = input().strip()
    already_pokers = input().strip()
    merge_pokers = my_pokers + "-" + already_pokers
    merge_pokers = merge_pokers.split("-")

    # 为方便后续判断顺子，将JQKA转为int，reverse_map供后续打印顺子使用
    char2int = {'J': 11, 'Q': 12, 'K': 13, 'A': 14}
    reverse_map = {v: k for k, v in char2int.items()}

    # 定义数组表示对手的牌，遍历前面合并牌数组（当前手中的牌 + 已经出过的牌），每遍历到一张牌，对手的牌对应的数组元素 - 1
    # 注意: 数组长度由来：顺子有效的牌为3-14，所以长度为14 - 3 + 1
    # 注意：为什么-3：有效的顺子牌从3开始，而数组下标需要从0开始
    their_pokers = [0] * (14 - 3 + 1)
    for poker in merge_pokers:
        if len(poker) > 1:  # 10
            their_pokers[int(poker) - 3] -= 1
        elif poker in char2int:  # JQKA
            their_pokers[char2int[poker] - 3] -= 1
        elif poker not in ['2', 'B', 'C']:
            their_pokers[int(poker) - 3] -= 1

    # 动态规划获取最长的顺子，当前牌的顺子长度只与前一个牌的顺子长度和当前牌是否可用有关
    prev = 1 if their_pokers[0] > -4 else 0
    max_len = float('-inf')
    current = 0
    start = 1

    for i in range(1, len(their_pokers)):
        if their_pokers[i] > -4:  # 有剩余牌时，拼接顺子
            current = prev + 1
            if current > max_len:
                max_len = current
                start = i + 3 - max_len + 1  # 注意这里+3，是由于数组下标和扑克牌之间差了3
        else:  # 无剩余牌，顺子长度置为0
            current = 0
        prev = current

    # 符合条件
    if max_len >= 5:
        straight = "-".join(str(reverse_map.get(poker, poker)) for poker in range(start, start + max_len))
        print(straight)
    else:
        print("NO-CHAIN")


if __name__ == "__main__":
    main()

七、JavaScript算法源码

function main() {
    const readline = require('readline-sync');

    // 获取输入：当前手中的牌 + 已经出过的牌，并合并
    let myPokers = readline.question().trim();
    let alreadyPokers = readline.question().trim();
    let mergePokers = myPokers + "-" + alreadyPokers;
    mergePokers = mergePokers.split("-");

    // 为方便后续判断顺子，将JQKA转为int, reverseMap供后续打印顺子使用
    const char2int = { 'J': 11, 'Q': 12, 'K': 13, 'A': 14 };
    const reverseMap = Object.fromEntries(Object.entries(char2int).map(([k, v]) => [v, k]));

    // 定义数组表示对手的牌
    const theirPokers = new Array(14 - 3 + 1).fill(0);
    
    mergePokers.forEach(poker => {
        if (poker.length > 1) {                                      // 10
            theirPokers[parseInt(poker) - 3]--;
        } else if (char2int.hasOwnProperty(poker)) {            //JQKA
            theirPokers[char2int[poker] - 3]--;
        } else if (poker !== '2' && poker !== 'B' && poker !== 'C') {
            theirPokers[parseInt(poker) - 3]--;
        }
    });

    // 动态规划获取最长的顺子，当前牌的顺子长度只与前一个牌的顺子长度和当前牌是否可用有关
    let prev = theirPokers[0] > -4 ? 1 : 0;
    let current = 0;
    let max = -Infinity;
    let start = 1;

    for (let 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
            }
        } else {
            current = 0;
        }
        prev = current;
    }

    // 符合条件
    if (max >= 5) {
        const straight = Array.from({ length: max }, (_, i) => {
            const poker = start + i;
            return poker > 10 ? reverseMap[poker] : poker;
        }).join('-');
        console.log(straight);
    } else {
        console.log("NO-CHAIN");
    }
}

// 执行主函数
main();

八、C算法源码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_LEN 100

// 字符转换为整数映射
int char2int(char c) {
    switch (c) {
        case 'J': return 11;
        case 'Q': return 12;
        case 'K': return 13;
        case 'A': return 14;
        default: return c - '0';
    }
}

// 整数转换为字符映射
char int2char(int n) {
    switch (n) {
        case 11: return 'J';
        case 12: return 'Q';
        case 13: return 'K';
        case 14: return 'A';
        default: return n + '0';
    }
}

int main() {
    char myPokers[MAX_LEN];
    char alreadyPokers[MAX_LEN];
    
    // 获取输入：当前手中的牌 + 已经出过的牌，并合并
    scanf("%s", myPokers);
    scanf("%s", alreadyPokers);

    char mergePokers[MAX_LEN * 2];
    snprintf(mergePokers, sizeof(mergePokers), "%s-%s", myPokers, alreadyPokers);

    int theirPokers[14 - 3 + 1] = {0}; // 记录对手的牌

    char *token = strtok(mergePokers, "-");
    while (token != NULL) {
        if (strlen(token) > 1) {
            theirPokers[atoi(token) - 3]--;
        } else if (token[0] != '2' && token[0] != 'B' && token[0] != 'C') {
            int value = char2int(token[0]);
            theirPokers[value - 3]--;
        }
        token = strtok(NULL, "-");
    }

    // 动态规划获取最长的顺子
    int prev = theirPokers[0] > -4 ? 1 : 0;
    int current = 0;
    int max = -1;
    int start = 1;

    for (int i = 1; i < sizeof(theirPokers) / sizeof(theirPokers[0]); i++) {
        if (theirPokers[i] > -4) {
            current = prev + 1;
            if (current > max) {
                max = current;
                start = i + 3 - max + 1;
            }
        } else {
            current = 0;
        }
        prev = current;
    }

    // 符合条件
    if (max >= 5) {
        for (int i = 0; i < max; i++) {
            int card = start + i;
            if (card > 10) {
                printf("%c", int2char(card));
            } else {
                printf("%d", card);
            }
            if (i < max - 1) {
                printf("-");
            }
        }
        printf("\n");
    } else {
        printf("NO-CHAIN\n");
    }

    return 0;
}

九、C++算法源码

#include <iostream>
#include <string>
#include <cstring>
#include <map>
#include <vector>

using namespace std;

// 字符转换为整数映射
int char2int(char c) {
    switch (c) {
        case 'J': return 11;
        case 'Q': return 12;
        case 'K': return 13;
        case 'A': return 14;
        default: return c - '0';
    }
}

// 整数转换为字符映射
char int2char(int n) {
    switch (n) {
        case 11: return 'J';
        case 12: return 'Q';
        case 13: return 'K';
        case 14: return 'A';
        default: return n + '0';
    }
}

int main() {
    string myPokers, alreadyPokers;

    // 获取输入：当前手中的牌 + 已经出过的牌，并合并
    cin >> myPokers >> alreadyPokers;
    string mergePokers = myPokers + "-" + alreadyPokers;

    int theirPokers[14 - 3 + 1] = {0}; // 记录对手的牌

    char *token = strtok(&mergePokers[0], "-");
    while (token != NULL) {
        if (strlen(token) > 1) {
            theirPokers[atoi(token) - 3]--;
        } else if (token[0] != '2' && token[0] != 'B' && token[0] != 'C') {
            int value = char2int(token[0]);
            theirPokers[value - 3]--;
        }
        token = strtok(NULL, "-");
    }

    // 动态规划获取最长的顺子
    int prev = theirPokers[0] > -4 ? 1 : 0;
    int current = 0;
    int max = -1;
    int start = 1;

    for (int i = 1; i < sizeof(theirPokers) / sizeof(theirPokers[0]); i++) {
        if (theirPokers[i] > -4) {
            current = prev + 1;
            if (current > max) {
                max = current;
                start = i + 3 - max + 1;
            }
        } else {
            current = 0;
        }
        prev = current;
    }

    // 符合条件
    if (max >= 5) {
        vector<string> straight;
        for (int i = 0; i < max; i++) {
            int card = start + i;
            if (card > 10) {
                straight.push_back(string(1, int2char(card)));
            } else {
                straight.push_back(to_string(card));
            }
        }
        for (size_t i = 0; i < straight.size(); i++) {
            cout << straight[i];
            if (i < straight.size() - 1) {
                cout << "-";
            }
        }
        cout << endl;
    } else {
        cout << "NO-CHAIN" << endl;
    }

    return 0;
}

🏆下一篇：华为OD机试真题 - 简易内存池（Python/JS/C/C++ 2024 E卷 200分）

🏆本文收录于，华为OD机试真题（Python/JS/C/C++）

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

在这里插入图片描述

哪 吒
关注
专栏目录
订阅专栏
华为OD机试 - 最长的顺子（C++题解）
算法大师！
05-22 608
斗地主起源于湖北十堰房县，据说是一位叫吴修全的年轻人根据当地流行的扑克玩法“跑得快”改编的，如今已风靡整个中国，并流行于互联网上。
华为OD机试真题-猜字谜-2024年OD统一考试（E卷）
面试高手的博客
09-06 559
第二种条件可以使用 set 来去重，由于题目中要求满足其中一个条件即可，因此我们可以把两个条件放在一起做，只需要先对所有的字符串进行去重，然后排序，最终对比两个字符串是否一致，一致则加入答案数组中，最终按要求输出即可。小王设计了一个简单的猜字谜游戏，游戏的谜面是一个错误的单词，比如 nesw，玩家需要猜出谜底库中正确的单词。2、字母去重以后是一样的，比如“woood”和“wood”是一样的，它们去重后都是“wod'请你写一个程序帮忙在谜底库中找到正确的谜底。匹配到的正确单词列表，以“，”分隔。
华为OD机试真题-贪心的商人-2024年OD统一考试（E卷）
面试高手的博客
09-04 563
商人经营一家店铺,有number种商品,由于仓库限制每件商品的最大持有数量是item[index],每种商品的价格是item_price[item_index][day]针对第一件商品,商人在第一天的价格是itemprice[0][0]=1时买入item[0]件,在第三天item_price[0][2]=3的时候卖出,获利最大是8;针对第三件商品,商人在第一天价格是itemprice[2][0]=1时买入item[2]件,在第二天itemprice[2][0]=5的时候卖出,获利最大是24;
华为OD机试真题-日志采集-2024年OD统一考试（E卷）
面试高手的博客
09-04 653
日志会按行生成，每一行记为一条日志，采集系统会分批上报这些日志。如果第2个时刻上报，最多上报100条，前50条延迟上报1s，每条扣除1分，共获得积分为100-50=50。3. 输出结果：在所有可能的上报时机中，选择积分最高的一次作为最终的上报时间点，并输出该积分。- 判断最佳时机：通过比较在不同时间点上报的积分，找到最大积分的时间点。- 当累计的日志达到100条时，强制上报，并记录此时的积分。- 迭代检查：遍历日志序列，模拟在每个时间点上报日志时的积分。- 对于每一个时间点，累加当前时间点生成的日志条数。
华为OD机试真题-模拟目录管理-2024年OD统一考试（C卷D卷）
面试高手的博客
04-23 838
不支持嵌套路径和绝对路径，如mkdir abc/efg, cd abc/efg, mkdir /abc/efg, cd /abc/efg是不支持的。2）进入目录命令：cd 目录名称, 如cd abc为进入abc目录，特别地，cd ..为返回上级目录，如果目录不存在则不执行任何操作。1）创建目录命令：mkdir 目录名称，如mkdir abc为在当前目录创建abc目录，如果已存在同名目录则不执行任何操作。在根目录创建一个abc的目录并进入abc目录中查看当前目录路径，输出当前路径/abc/。
华为OD机试真题-分糖果-2024年OD统一考试（E卷）
面试高手的博客
09-04 491
把每个数字看作其二进制数，对于奇数情况，必须加1或减1，对于减1再 / 2 对于该位之前的数字没有任何影响，加1后如果前位也是1则前面的1也变成0，这相当于通过加1操作将多个1变成了0，而最多只会产生一个新的进位。其余情况下，如果能每次加1能去除2个以上的非最高位上的1一定是赚的。当糖果不能 平均分配只时，小明可以选择从糖果盒中(假设盒中糖果足够)取出一个糖果或放回一个糖果。- 如果糖果数量是奇数：根据当前糖果数量是加一还是减一能最快到达1来决定操作。- 如果糖果数量是偶数，我们直接除以2。
2024华为OD机考机试E卷 +C卷 + D卷 + B卷 + A卷：真题目录 + 考点说明
热门推荐
算法大师！
03-18 38万+
OD，全称(Outsourcing Dispacth)模式，目前华为和德科联合招聘的简称。华为社招基本都是OD招聘，17级以下都是OD模式（13-17）。
华为OD机试笔试2024年E卷- 斗地主之顺子 (java/c++/python)
Run
08-30 570
而{J,Q,K,A,2}、 {2,3,4,5,6}、{3,4,5,6}、{3,4,5,6,8}等都不是顺子。当把五张顺子找完后，继续检查total 是否大于 0，若total > 0，则说明还有剩余牌，此时我们外层遍历每一个顺子，内层遍历每一个剩余牌，如果剩余牌可以追加到顺子尾巴，形成新顺子，则更新顺子尾巴。在斗地主扑克牌游戏中， 扑克牌由小到大的顺序为：3,4,5,6,7,8,9,10,J,Q,K,A,2，玩家可以出的扑克牌阵型有：单张、对子、顺子、飞机、炸弹等。如果没有满足出牌规则的顺子，请输出No。
华为OD机试E卷 - 斗地主之顺子（Java & Python& JS & C++ & C ）
算法大师！
08-18 3701
华为OD机试E卷 - 斗地主之顺子斗地主扑克牌游戏中， 扑克牌由小到大的顺序为：3,4,5,6,7,8,9,10,J,Q,K,A,2，玩家可以出的扑克牌阵型有：单张、对子、顺子、飞机、炸弹等。
2024华为OD机试题库-(A卷+B卷+C卷+D卷+E)-(JAVA、Python、C++)
goldarmour的博客
03-28 4万+
博主是一名资深后端开发人员，精通C++，Python，Java，乐于分享面试经验，已帮助千余名同学通过OD机考！这些题目博主每一道都刷了至少两遍，每一行代码都蕴含了博主从业以来所积累的所有经验和技巧，可谓干货满满！
华为OD机试真题-计算疫情扩散时间-2024年OD统一考试（E卷）
面试高手的博客
09-06 312
每次我们扩展所有当前感染区域的上下左右相邻区域，将这些区域标记为感染，然后继续下一天的扩展，直到所有区域都被感染为止。如果初始地图上所有区域全部都被感染，或者没有被感染区域，返回-1。- 如果地图上所有区域都已经感染或没有感染区域，直接返回 -1。在一个地图中(地图由n*n个区域组成)，有部分区域被感染病菌。- 以天为单位，扩展所有当前感染区域的上下左右相邻区域。请根据给定的地图计算，多少天以后，全部区域都会被感染。1个整数，表示经过多少天以后，全部区域都被感染。- 如果最终所有区域都被感染，返回天数。
华为OD机试笔试2024年E卷- 猜字谜 (java/c++/python)
最新发布
Run
09-06 117
小王设计了一个简单的猜字谜游戏，游戏的谜面是一个错误的单词，比如 nesw，玩家需要猜出谜底库中正确的单词。变换顺序后一样的，比如通过变换 w 和 e 的顺序，“nwes” 跟 “news” 是可以完全对应的；字母去重后是一样的，比如 “woood” 和 “wood” 是一样的，它们去重后都是 “wod”谜面是多个单词，都需要找到对应的谜底，如果找不到的话，返回 “not found”单词的数量 N 的范围：0 < N < 1000。匹配到的正确单词列表，以 “,” 分隔。谜面单词列表，以 “,” 分隔。
【华为OD笔试E卷正在更新】2024D+E卷机考套题汇总【真实反馈，不断更新，限时免费，全网最快】
weixin_48157259的博客
04-22 1万+
可上练习华子OD、大厂真题绿色聊天软件戳od1441了解算法冲刺训练（备注【CSDN】否则不通过）
2024华为OD统一考试题库清单（持续收录中）以及考点说明
学Java，找哪吒
07-14 4万+
每一题都有详细的答题思路、详细的代码注释、样例测试，发现新题目，随时更新，全天CSDN在线答疑。
华为OD机试2024年E卷-工号不够用了怎么办[100分]（ Java | Python3 | C++ | C语言 | JsNode | Go ）实现100%通过率
算法算法算法！！！
08-30 1750
但是过长的工号会增加同事们的记忆成本，现在给出新工号至少需要分配的人数 X 和新工号中字母的长度 Y，求新工号中数字的最短长度Z。新工号由一段英文字母开头，之后跟随一段数字，比如"aaahw0001","a12345","abcd1","a00"。现在，请你负责调研新工号系统。继承历史传统，新的工号系统由小写英文字母（a-z）和数字（0-9）两部分构成。注意新工号不能全为字母或者数字，允许数字部分有前导 0 或者全为 0。一行两个非负整数 X Y，用数字用单个空格分隔。输出新工号中数字的最短长度 Z。
2024华为OD试题及答案-A004-插队
2401_86417859的博客
08-04 346
题目描述了一个银行排队处理业务的场景，不同优先级的客户可以插队到优先级较低的客户前面。当多个客户同时到达时，优先级高的客户先处理，如果优先级相同，则按照到达顺序处理。某银行将客户分为了若干个优先级， 1 级最高， 5 级最低，当你需要在银行办理业务时，优先级高的人随时可以插队到优先级低的人的前面。输出包含若干行，对于每个 p ， 输出一行，仅包含一个正整数 num , 表示办理业务的客户编号。现在给出一个人员到来和银行办理业务的时间序列，请你在每次银行办理业务时输出客户的编号。
华为OD机试【最长的顺子】(java)(100分)
weixin_52914380的博客
05-04 287
斗地主起源于湖北十堰房县，据说是一位叫吴修全的年轻人根据当地流行的扑克玩法”跑得快”改编的，如今已风靡整个中国，并流行于互联网上。 牌型:单顺，又称顺子，最少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
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

哪 吒

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

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

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

打赏作者

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

抵扣说明：

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

余额充值