华为OD机试 - 最长的顺子 - 动态规划(Python/JS/C/C++ 新系统 200分)

AI摘要

本题为华为OD机试真题,要求根据手中牌和已出牌推断对手可能构成的最长顺子(5-12张连续牌,不含2及大小王)。核心是通过映射JQKA为数值、统计剩余牌频次、倒序贪心匹配最长连续序列,并验证长度与合法性。解法采用哈希统计+线性扫描,属典型动态规划思想变体,适用于牌型分析类算法题。

在这里插入图片描述

华为OD机试 双机位C卷题库疯狂收录中,刷题点这里

专栏导读

本专栏收录于《华为OD机试真题(Python/JS/C/C++)》。

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

一、题目描述

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

牌型:单顺,又称顺子,最少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++ 新系统 200分)

🏆本文收录于,华为OD机试真题(Python/JS/C/C++)

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

在这里插入图片描述

2026华为OD机考新系统真题 + 双机位C卷 + 往年真题 - 题库目录分值说明 + 考点说明+在线OJ 2026年4月1日起,华为OD机试正式切换至新系统模式!采用力扣模式,无需自己写输入! 难度大幅度降低。正在备考华为OD机试的同学,优先刷新系统机试真题,可大幅提升通过率。 新系统考题考点与旧版一致,无需重新适应。本专栏所有算法题均配有详细思路解析,并提供C语言、JS、C++、Python、Go、Java多语言源码实现。订阅后私信即可开通专属OJ刷题权限,高效备考一次上岸! 阅读详情

相关推荐

华为OD机试 新系统 双机位C卷 往年真题 机考题库(持续收录中)以及算法考点详解(Python/JS/C/C++)

刷的越多,抽中的概率越大,每一题都有详细的答题思路、详细的代码注释发现新题目,随时更新。

学Java,找哪吒 5万+

【持续更新】2025华为OD机试2025A卷机考真题库清单含考点说明 (已更新180+题)

【持续更新】2025华为OD机试2025A卷 机考真题库清单(全真题库)含考点说明(已更新40+题)

算法大师! 2万+

2026华为OD机考双机位C卷++ 双机位B卷 + 双机位A卷 + 2025C/B/A卷+ 往年真题 - 题库目录分值说明 + 考点说明+在线OJ

2025华为OD机考双机位C卷++ 双机位B卷 + 双机位A卷 + 2025C/B/A卷+ 往年真题 - 题库目录分值说明 + 考点说明+在线OJ

算法大师! 5万+

华为OD机试 新系统 双机位C卷 往年真题 机考题库(持续收录中)以及算法考点详解

每一题都有详细的答题思路、详细的代码注释、样例测试,发现新题目,随时更新,全天CSDN在线答疑。

学Java,找哪吒 7万+

2026华为OD机试(Python)真题【E卷+A卷+B卷+C卷+D卷】目录+在线OJ

华为OD机试真题题库【E卷+A卷+B卷+C卷+D卷】目录,Python实现。

MISAYAONE的博客 29万+

2026华为OD机试(JAVA&Go)真题【E卷+A卷+B卷+C卷+D卷】目录+在线OJ

华为OD机试真题题库【E卷+A卷+B卷+C卷+D卷】目录,Java实现。

MISAYAONE的博客 34万+

2026华为OD机试(C++)真题【E卷+A卷+B卷+C卷+D卷】目录+在线OJ

华为OD机试真题题库【E卷+A卷+B卷+C卷+D卷】目录,C++实现。

MISAYAONE的博客 20万+

2026华为OD机试(JavaScript)真题【E卷+A卷+B卷+C卷+D卷】目录+在线OJ

华为OD机试真题题库【E卷+A卷+B卷+C卷+D卷】目录,JavaScript实现。

MISAYAONE的博客 8万+

2025华为OD机试真题最新题库 (B+C+D+E+2025A+2025B卷) + 在线OJ在线刷题使用(C++、Java、Python C语言 JS合集)(正在更新2025B卷,目前已收录710道)

2024年,华为目前已经启用D卷,目前D卷和C卷的题目一样一次订阅永久阅读,支持在线刷题,持续更新,有问题随时解答,本专栏题目数量已收录到484道。每篇文章的思路分析都非常详细,题目新增图解思路,问题解疑,多样例测试,超过百字的思路参考解析。

KJ.JK 11万+

【全网最新OD题库】2026华为 OD 机试C卷 机考真题库清单(全真题库)含考点说明(华为OD+2025年C卷+2025年B卷+2025年A卷+E卷+D卷+C卷)

华为od机试,华为od机试真题,华为od机试E卷,华为odE卷,华为od机试真题E卷,华为OD,华为OD机试,华为OD机试真题,华为od机考,华为od机试D卷,华为od机试真题D卷,华为od手撕代码,华为od,华为od机试C卷,华为od e卷,华为2024e卷,od机试,2024E卷,华为OD机试E卷,什么是华为od,华为od介绍,全面了解华为od,2024华为od,如何备战华为od,华为od算法,华为od手撕代码,华为OD机试2024年最新题库,一文带你读懂华为OD,华为机试e卷,华为OD2025B卷、华

KJ.JK 3万+

上海市大数据中心笔试模拟试卷

为帮助考生熟悉上海市大数据中心笔试的题型、考点及答题逻辑,以下整理了一份的模拟试卷,涵盖大数据专业知识、行政职业能力测试(行测)、公共基础知识(含上海本地政策)三大核心模块,并附详细答案解析。

一叶之秋的博客 1821

HT7036计量芯片SPI通信与数据读取实战解析

本文详细解析HT7036计量芯片的SPI通信与数据读取实战,涵盖SPI时序配置、命令发送、数据读取及常见问题排查。重点介绍如何通过SPI接口与MCU通信,实现电能数据的稳定采集与处理,为智能电表等应用提供实用解决方案。

vscode5coder的博客 270

Crush 终端 LLM 工具安装与使用指南:把 AI 编程助手装进你的命令行

喜欢命令行的开发者需要离线/轻量级 AI 助手的场景希望自定义模型与工具链的高级用户通过LSP + MCP + 多模型支持,Crush 不仅能写代码,还能理解项目、调用工具、连接服务,真正成为你的“终端编程搭档”。

weixin_44058951的博客 1619

73、结合无人机进行rk3588oak-lite跟踪目标物体进行识别、跟踪

搭建仿真转换模型环境,主要python版本和我下载的rknn2的版本。截取shape节点,输出模型。so库也要对应转模型的whl。其中安装的whl版本。

sxj731533730 1629

手把手教你学Simulink--基于光伏(PV)系统的建模与仿真场景:-不同天气条件下光伏系统的输出性能分析

本文介绍了使用Simulink和Simscape Electrical工具箱进行光伏系统建模与仿真的完整流程。内容涵盖准备工作、模型构建、仿真分析三大步骤,重点演示了如何模拟不同天气条件(光照强度、温度变化)对光伏输出性能的影响。通过添加PVArray模块、配置参数、设置环境变化条件、连接测量仪器等操作,实现了光伏系统在动态天气条件下的输出特性分析。文章还提供了仿真参数设置建议和结果分析方法,帮助用户理解环境因素与光伏性能的关联性,为光伏系统设计和优化提供参考。

MHD0815的博客 191

用Python爬虫抓取大宗交易成交数据:全面解析与实战代码

大宗交易是指在证券市场中,涉及大额买卖的交易。此类交易通常由机构投资者进行,其交易量较大,对市场的影响显著。大宗交易数据包含了买卖双方的成交价格、成交量等关键信息,这些数据对于投资者和分析师而言,具有重要的市场预测意义。Python爬虫是一种自动化抓取互联网上数据的工具。通过爬虫,我们可以定期获取大宗交易数据,节省人工查询的时间。爬虫的工作原理通常包括:发送HTTP请求、获取响应数据、解析网页内容、提取关键信息、存储和展示数据。

2201_76125261的博客 418

PCB结构和谐振(二)

在此章节中,我们通过不同的测试研究了旋转角度/复杂层叠/走线pitch和layout设计等,所有的测试都是基于Intel Delta L 4.0规范。

小孟同学的博客 4297

deepstream车道线检测自定义插件化,其中要注意pipeline的配置,如果插件位置配置不对,会报input format should be RGBA when using blur-obje

以上代码中,我们先从对象池中获取一个 DsUserMeta 对象,然后使用 get_lane_line_from_frame 函数获取车道线检测结果,并使用 add_lane_line_meta 函数将其添加到 DsUserMeta 对象中。注意,上述代码中的 get_lane_line_from_frame 函数和 add_lane_line_meta 函数需要你自己实现,用于从视频帧中提取车道线检测结果,并将其添加到 DsUserMeta 中。

pvmsmfchcs的博客 694

计算机控制技术及应用

《计算机控制技术及应用》通过总结作者的科研成果和吸收国内外的先进理论、方法和技术,以计算机控制系统的网络化、开放化、智能化和集成化发展趋势为主线索,主要介绍计算机控制系统的基本概念和计算机控制系统的典型形式,计算机控制系统的数学描述与基本分析方法,以及数字PID控制器、最少拍控制系统、达林算法、状态变量设计法等设计方法及其各种改进算法。重点突出计算机控制系统输入输出通道接口的设计方法和典型控制系统的设计案例与实现方法等。

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

上一篇: 华为OD机试 - 绘图机器 - 双指针(Python/JS/C/C++ 新系统 100分)
下一篇: 华为OD机试 - 猴子吃桃 - 二分查找(Python/JS/C/C++ 2025 B卷 100分)
哪 吒
哪 吒 2022年度博客之星TOP 1 2022年度博客之星TOP 1 领域专家: 后端开发技术领域 领域专家: 后端开发技术领域
博客等级 码龄9年 59万+粉丝 2962原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

哪 吒

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

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

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

打赏作者

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

抵扣说明:

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

余额充值
⌂ 换网址