简介：面向华为OD机试备考者的Python刷题资源合集，收录牛客网与CSDN等平台常见题型，覆盖IP地址识别、01背包动态规划、扑克牌大小比较、素数伴侣配对、数字转英文等经典算法与编程挑战，用于检验候选人在实际问题解决中的Python编程能力，适合考前冲刺与日常训练。整个压缩包为zip格式，共106个文件，以103个Python脚本为主体，辅以3个txt说明文档，包体仅59KB，轻量便携，便于按文件名快速定位与检索题目。目前已有1592人学习下载，适合正在冲刺OD机试或系统提升Python算法水平的读者。脚本覆盖IP地址校验、排序统计、动态规划状态转移、素数筛法、数字英文转换、索引与次数统计等Python核心知识点，并穿插字符串格式化技巧与字典、列表的灵活运用；对照题目逐项演练，可加深对数据结构运用和最佳实践的理解，也为自己的解题思路提供额外参考。
1. 华为OD机试Python代码库：拿来即用的刷题底盘
华为OD机试的通过率一直是个玄学，有人刷了两百题照样挂，有人只看五十题就过。区别往往不在题量，而在有没有把题目背后的考查点吃透。这份以Python语言为主的机试代码资源，整理的是一整套可以直接跑、直接改的解题模板和代码实现，覆盖数组、字符串、栈队列、动态规划、图搜索这些机试高频考点。适合两类人：一是刚接到机试通知、想快速摸底题型的新手，照着代码跑一遍就能建立题感；二是已经刷过一些题、卡在笔试超时或内存超限上的熟手，拿它当查漏补缺的代码字典。它不是那种丢给你一百道题和答案的题库，而是把每类题目的通用解法抽出来，让你在考场上遇到变形题也能往下写。
2. 资源全景：这份代码库由哪些模块组成
2.1 目录结构与文件组织
打开这份资源，第一眼看到的是按题型分层的目录结构，而不是一堆散落的脚本。这种组织方式非常符合机试备考的使用习惯——你不需要记住每个文件名，只需要按题型去找对应解法。常见的分层方式是：01_数组_双指针、02_字符串处理、03_栈与队列、04_哈希表、05_链表、06_树与二叉树、07_图与搜索、08_动态规划、09_贪心算法、10_数学_位运算。每个目录下通常包含三类文件：题目描述文本、Python解法脚本、测试用例文件。
huawei_od_python/ ├── 01_数组_双指针/ │ ├── 两数之和_描述.md │ ├── 两数之和.py │ └── test_cases.txt ├── 02_字符串处理/ │ ├── 最长回文子串_描述.md │ ├── 最长回文子串.py │ └── test_cases.txt ├── 03_栈与队列/ │ ├── 有效的括号_描述.md │ ├── 有效的括号.py │ └── test_cases.txt ├── 08_动态规划/ │ ├── 背包问题_描述.md │ ├── 背包问题.py │ └── test_cases.txt └── README.md这种「一题一目录」的结构有一个实际好处：你可以把每道题的解法脚本单独拿出来直接运行，不需要依赖项目里其他文件。有些代码库把公共工具函数抽到utils.py里，看起来更优雅，但对机试场景反而不友好——考试环境里你没法保证能复制多个文件，最稳妥的做法是每个脚本自包含。这份资源里的解法基本都是自包含的，import的只有Python标准库。
2.2 代码风格与注释规范
我翻看了资源里的Python代码，整体风格偏「应试实战」，不是那种工程级代码。所谓实战风格，体现在几个细节上：变量名短但可读，函数入口统一为solve()，输入读取用sys.stdin而非input()，对机试场景做了针对性适配。比如处理大量输入时，input()逐行调用在数据量大的时候会拖慢速度，sys.stdin.read()配合split()一次读完更稳。
import sys def solve(): data = sys.stdin.read().split() if not data: return n = int(data[0]) nums = list(map(int, data[1:1+n])) # 核心逻辑写在这里 print(result) if __name__ == "__main__": solve()代码里的if __name__ == "__main__"这行值得专门说一句。在本地调试时，你可能会直接把这个脚本当模块导入做单元测试，有这行保护就不会在导入时意外执行solve()。在华为OD机试的在线评测环境里，判题系统会直接执行整个脚本，这行代码保证了脚本被运行时才调用入口函数，避免有的评测环境重复导入导致的异常行为。参数读取用data[0]和切片data[1:1+n]也是一种约定俗成——机试输入格式经常是「第一行一个整数n，第二行n个整数」，这种一次性读取的写法比input()循环更不容易出错，尤其是在输入行数不确定的题目里。
2.3 题目覆盖范围的判断依据
从目录文件名来看，这份资源的选题明显偏向华为OD机试的真实出题风格。华为OD机试和传统校招笔试不太一样，它更看重工程落地能力和边界条件处理，纯算法难题反而比例不高。高频出现的题型包括数组操作与排序、字符串匹配与变换、栈的应用、哈希表计数、二叉树的遍历和重建、图的最短路径、基础的动态规划（背包、子序列、编辑距离）、贪心模拟。相对冷门的复杂数据结构如红黑树、线段树、AC自动机，在这份资源里基本不会出现，这一点是合理的——机试考的是在规定时间内写出能跑的代码，不是炫技。
打开README.md通常能看到整理者写的一段话，说明这套资源的使用顺序。我认可用三步走的方式：第一步按目录顺序把每道题的描述.md看一遍，只看题目不看答案，想一下思路；第二步运行对应的.py脚本，对照测试用例理解输入输出格式；第三步才是重点——关掉答案，自己重新写一遍，再和资源里的解法做对比，看差异在什么地方。这种做法比从头到尾刷三遍题目有效得多，差异点就是你最容易在考场上暴露的问题。
3. 核心代码模块拆解：从输入到输出的完整链路
3.1 输入处理模块：适配在线评测的IO模板
华为OD机试的在线评测环境对代码的输入输出格式要求极其严格——多一个空格、少一个换行都可能导致判题失败。很多考生不是不会做题，而是栽在输入输出解析上。这份资源里几乎每个脚本都封装了一个标准的IO读取模板，我摘一个典型例子来分析。
import sys def read_ints(): """读取所有整数，返回list""" return list(map(int, sys.stdin.read().split())) def read_lines(): """按行读取，去掉首尾空白符，返回list""" return [line.strip() for line in sys.stdin if line.strip()] def main(): arr = read_ints() # 业务逻辑 print(" ".join(map(str, result))) if __name__ == "__main__": main()这个模板设计的核心逻辑是sys.stdin.read()一次性读取全部输入，配合split()按空白字符切分，能同时处理空格、制表符、换行三种分隔方式。这在机试里很实用，因为不同题目给出的输入样例格式并不统一，有的用空格分隔，有的用换行，有的混合使用。参数说明：read_ints()返回的是整数列表，适合题目给出「第一行数组长度，第二行数组元素」这类格式；read_lines()保留行结构，适合矩阵类题目，每一行代表矩阵的一行数据。strip()的作用是去掉行尾的换行符，避免把\n当成数据的一部分。
3.2 动态规划模块：以背包问题为例看状态设计
背包问题是华为OD机试动态规划题型的常客，但机试考的往往不是标准的01背包，而是加了各种变形的版本——比如要求的不是最大价值而是恰好装满的方案数，或者物品数量巨大需要换一种DP方式。资源里的背包解法展示了怎么从标准模板过渡到变体。
# 01背包标准模板：dp[j]表示容量为j时的最大价值 def knapsack_01(weights, values, capacity): dp = [0] * (capacity + 1) for i in range(len(weights)): # 逆序遍历容量，保证每件物品只取一次 for j in range(capacity, weights[i] - 1, -1): dp[j] = max(dp[j], dp[j - weights[i]] + values[i]) return dp[capacity] # 完全背包变体：每件物品可取无限次 def knapsack_complete(weights, values, capacity): dp = [0] * (capacity + 1) for i in range(len(weights)): # 正序遍历容量，同一件物品可以重复选 for j in range(weights[i], capacity + 1): dp[j] = max(dp[j], dp[j - weights[i]] + values[i]) return dp[capacity]这两个函数之间的差别只在一行——内层循环的遍历方向。逆序遍历时，dp[j]的更新用的是本次循环之前的状态，相当于每件物品最多被选一次；正序遍历时，dp[j]的更新会用到本轮已经更新过的dp[j - weights[i]]，等于允许同一件物品反复取。这个细节在机试里是高频考点，翻车率极高。我见过很多考生把01背包和完全背包的模板混用，导致答案错误。资源里把这两个版本放在一起对比，就是在提醒你注意这个关键差异。
3.3 图搜索模块：BFS求最短路径的完整实现
图相关的题目在华为OD机试中通常以「二维矩阵迷宫」「地图导航」「网络连通性」的形式出现，核心解法逃不开BFS和DFS。BFS适合求最短路径，DFS适合判断连通性和路径存在性。资源里有一个典型的BFS求迷宫最短路径实现，我用它来讲一个完整的搜索流程。
from collections import deque def bfs_shortest_path(grid, start, end): """ grid: 二维列表，0表示可通行，1表示障碍物 start: (x, y)起点坐标 end: (x, y)终点坐标 返回最短路径长度，若不可达返回-1 """ if not grid or not grid[0]: return -1 rows, cols = len(grid), len(grid[0]) # 四个方向的偏移量：上、下、左、右 directions = [(-1, 0), (1, 0), (0, -1), (0, 1)] visited = [[False] * cols for _ in range(rows)] q = deque([(start[0], start[1], 0)]) # (x, y, step) visited[start[0]][start[1]] = True while q: x, y, step = q.popleft() if (x, y) == end: return step for dx, dy in directions: nx, ny = x + dx, y + dy if 0 <= nx < rows and 0 <= ny < cols \ and not visited[nx][ny] and grid[nx][ny] == 0: visited[nx][ny] = True q.append((nx, ny, step + 1)) return -1 # 队列耗尽仍未到达终点，说明不可达这个实现的关键在于三元组(x, y, step)同时存储坐标和步数，省去了单独维护步数数组的麻烦，代码更简洁但需要留意内存占用——当一个迷宫很大时，三元组里的步数会随路径长度增长。边界条件检查0 <= nx < rows and 0 <= ny < cols必须先于障碍物判断，否则访问越界会直接抛出IndexError。这里还有个常见的性能陷阱：visited数组的类型选择。Python里用bool列表没问题，但如果迷宫特别大，用bytearray逐行初始化会更省内存，不过在机试场景下数据规模通常到不了需要抠这个的程度。
3.4 字符串处理模块：双指针与滑动窗口
字符串类型的题目在华为OD机试里占据至少三成比例，其中最长无重复子串、最小覆盖子串这类滑动窗口题目几乎是必考题型。资源里对这类问题的解法做了一个统一抽象——滑动窗口框架。
def min_window_substring(s, t): """ 在s中找到包含t所有字符的最短子串 输入: s = "ADOBECODEBANC", t = "ABC" 输出: "BANC" """ from collections import Counter need = Counter(t) missing = len(t) # 还缺少的字符个数 left = 0 min_len = float('inf') start = 0 for right, ch in enumerate(s): if need[ch] > 0: missing -= 1 need[ch] -= 1 while missing == 0: # 窗口已包含所有目标字符 if right - left + 1 < min_len: min_len = right - left + 1 start = left # 收缩窗口 left_char = s[left] need[left_char] += 1 if need[left_char] > 0: missing += 1 left += 1 return s[start:start + min_len] if min_len != float('inf') else ""这个框架的核心变量是need字典和missing计数器。need记录每个目标字符还缺多少个，初始值为t中每个字符的出现次数；missing记录总共还缺多少个字符，这个值从len(t)开始递减到0表示窗口已经覆盖全部目标字符。代码逻辑分为两个阶段：右指针扩展窗口，直到missing == 0；左指针收缩窗口，每次移动时更新need和missing。特别注意收缩阶段的顺序——先记录当前窗口的最小值，再移动左指针，否则会丢失最优解。missing的判定条件用的是need[ch] > 0而非need[ch] >= 0，这是被很多人忽略的细节，它区分了「这个字符恰好是目标字符」和「这个字符是多余字符」。
4. 机试场景实战：高频题型的Python解题套路
4.1 数组类题目：排序、二分查找与去重
数组类题目在机试中往往是「送分题」和「送命题」的分水岭。送分的是直接排序、统计、去重这种只需调用内置函数的题；送命的是那些看起来会做、但一写就超时的优化题。资源里反复强调一个原则：能用Python内置方法解决的，绝不用手写逻辑。列表的sort()方法底层是Timsort，平均时间复杂度接近O(n)，比手写快排稳定得多。
def merge_sorted_arrays(arr1, arr2): """合并两个有序数组，返回新的有序数组""" # 方法一：直接合并后排序，代码量最小 result = arr1 + arr2 result.sort() return result # 方法二：双指针归并，时间复杂度O(n+m) i, j = 0, 0 result = [] while i < len(arr1) and j < len(arr2): if arr1[i] < arr2[j]: result.append(arr1[i]) i += 1 else: result.append(arr2[j]) j += 1 # 剩余元素直接拼接 result.extend(arr1[i:]) result.extend(arr2[j:]) return result这两种方法各有适用场景。方法一在数组长度较小（比如总长小于10000）时完全没有问题，代码量最小，不容易出错；方法二在数组很长或对时间复杂度有明确要求时用，双指针遍历只做一次循环，时间复杂度是O(n+m)，而且不需要额外的大排序开销。在机试里，如果题目只是要求合并有序数组而没有明确说明时间限制，用方法一即可，省下时间去想后面的难题。但如果你发现评测超时，优先把这种可以优化的地方换掉。
关于去重，机试里常见的一个需求是「去掉重复元素并保持原顺序」。这里有个经典陷阱：set()去重会打乱顺序，直接用dict.fromkeys()才是保持顺序的正解。
def dedup_keep_order(nums): """去重并保持原顺序""" return list(dict.fromkeys(nums))dict.fromkeys(nums)会创建一个字典，键是nums里的元素，值统一为None，而字典在Python 3.7+中保持插入顺序，所以这一步同时完成了去重和保序两个操作。
4.2 树与二叉树：遍历模板与重建问题
二叉树题目考的通常是三种遍历的递归和迭代写法、根据遍历序列重建二叉树、最近公共祖先、层序遍历这几个方向。资源里的树相关代码有一个共同特征——递归版往往简短，但备注里总会补充迭代版，因为机试里递归过深会触发Python的递归深度限制。默认递归深度是1000层，如果树退化成链状，递归版可能直接RecursionError。
class TreeNode: def __init__(self, val=0, left=None, right=None): self.val = val self.left = left self.right = right def preorder_recursive(root): """前序遍历：根 -> 左 -> 右（递归版）""" if not root: return [] return [root.val] + preorder_recursive(root.left) + preorder_recursive(root.right) def preorder_iterative(root): """前序遍历：根 -> 左 -> 右（迭代版，用栈模拟）""" if not root: return [] stack, result = [root], [] while stack: node = stack.pop() result.append(node.val) # 先压右子树，再压左子树，保证出栈顺序是左先右后 if node.right: stack.append(node.right) if node.left: stack.append(node.left) return result迭代版的关键在于压栈顺序的前后关系——前序遍历需要先访问左子树，所以右子树先入栈、左子树后入栈，出栈时才能保证左子树先被处理。这个顺序搞反是常见翻车点。递归版虽然简短，但实际执行时，每层递归都要保存当前函数调用栈，当树高度接近1000时会报错。所以我建议在机试时优先考虑迭代版——反正两种写法在代码量上差别不大，但迭代版能规避运行时错误。
4.3 经典博弈类题目：模拟与贪心
华为OD机试有个特色是「模拟题」比例不低——题目描述一个复杂的业务规则，让你按照规则一步步模拟整个过程。这种题不考算法深度，考的是能不能准确理解规则并用代码精确实现。资源里这类题目的解法通常长得像流程图，用循环和条件判断把所有分支覆盖到。
def process_schedule(tasks, cooldown): """ 模拟任务调度：相同任务执行后需等待cooldown时间 输入: tasks = ["A","A","A","B","B","B"], cooldown = 2 输出: 总执行时间 """ from collections import Counter task_counts = Counter(tasks) max_count = max(task_counts.values()) # 出现次数最多的任务 max_size = sum(1 for v in task_counts.values() if v == max_count) # 框架公式：总时间 = (max_count - 1) * (cooldown + 1) + max_size time = (max_count - 1) * (cooldown + 1) + max_size return max(time, len(tasks))这段代码是基于贪心策略的公式解法。核心思想是：出现次数最多的任务决定了最少需要多少个「冷却槽位」，其他任务填充这些槽位。公式中max_count - 1表示有max_count - 1个完整的执行周期，每个周期长度是cooldown + 1（执行一个任务加上等待时间），最后加上与最大次数相同数量的任务种类数max_size，因为这些任务可以排在最后一个周期里。最后用max(time, len(tasks))兜底——如果任务种类足够多，槽位全被填满，实际耗时不会少于任务总数。这就是典型的模拟题套路：找出约束条件最强的因素，用它作为计算基准。
5. 常见避坑与排查：机试环境下最容易翻车的五个细节
5.1 输入读取超时：input()和sys.stdin的性能差距
现象：本地测试一切正常，提交到评测系统后运行超时，但看数据量并不大。 原因：input()每次调用都会做一次系统IO读取并解析，在多次循环调用时（比如读取10000行输入），累积的系统开销会拖慢程序。 解决：统一使用sys.stdin.read()一次性读取全部数据，配合split()切分。机试场景输入数据量一般不超过几MB，一次性读入内存没有问题，换来的速度优势非常明显。这也是我在看这份资源时发现几乎所有AC代码都统一用sys.stdin的原因。
5.2 列表索引越界：边界条件检查的优先级
现象：运行代码时抛出IndexError: list index out of range，但数据明明看起来合法。 原因：有些题目给出的输入格式并不是说你传入的每个参数都有效——比如矩阵题里起点坐标可能落在障碍物上，字符串题里可能有一个超长后缀需要单独处理。代码里对索引访问没有做保护。 解决：在访问grid[nx][ny]这类索引前，先做范围检查0 <= nx < rows and 0 <= ny < cols，再检查内容。顺序反过来，先检查内容后做范围检查会依然越界报错。这类问题最容易出现在图搜索和动态规划的状态转移里，养成「先范围后内容」的编码习惯能规避大部分越界问题。
5.3 深递归导致栈溢出：从递归改迭代
现象：代码逻辑正确，但提交后崩溃，错误信息包含RecursionError或Process finished with exit code -1073741571（栈溢出）。 原因：Python默认递归深度限制为1000层，而某些树形数据结构在最坏情况下深度可能达到数万层级。 解决：机试时优先写迭代版本。如果必须用递归，可以设置sys.setrecursionlimit(10000)来调高限制，但这种方式治标不治本，极端情况下依然会溢出。资源里涉及的树和图的解法都有迭代版实现，建议提前准备几个常用的迭代模板（前中后序遍历、BFS、拓扑排序）。
5.4 输出格式不一致：多空格和缺换行
现象：答案正确但被判错，评测系统提示「输出格式错误」。 原因：机试判题系统对输出做了严格的字符串匹配，多一个空格、少一个换行、末尾多一个空行都算错。 解决：在代码最后用print()输出结果时，使用" ".join(map(str, result))而不是str(result).replace(",", "")之类的取巧写法。另外，列表推导式生成输出内容后，用print(*result)也可以自动用空格分隔，但*解包在结果为空列表时会打印一个空行，需要注意。我习惯最后看一眼题目样例的输出格式——是每个数字一行还是空格分隔成一行。
5.5 全局变量污染：多次调用同一函数结果异常
现象：本地调试时连续执行多次测试用例，第二次的结果和第一次不同。 原因：函数内部使用了全局变量或默认可变参数，导致上一次调用留下的状态污染了后续执行。 解决：所有需要用到的变量都定义在函数内部，不设全局可变变量。特别注意不要用def solve(nums=[])这种写法——Python的默认参数是函数定义时创建的可变对象，多次调用会累积数据。数据结构的初始化（比如visited = [[False]*cols for _ in range(rows)]）必须放在函数内部，每次调用时重新创建。
6. 二次开发：把这份题库变成自己的刷题框架
拿到这份资源后，最值得做的不是按顺序把所有题目刷完，而是把它改造成个人的刷题框架。我的做法是加一个调度脚本，把每个.py文件变成可命令行调用的独立程序，支持传入测试文件和输出比对。这样做的好处是每道题都可以用同一套代码去做回归测试——你改了某个解法后，可以立刻验证没有破坏之前跑通的用例。
import subprocess import sys import os # 扫描目录下所有解题脚本，逐个运行并比对输出 def regress_all(): base_dir = "huawei_od_python" passed, failed = 0, 0 for folder in sorted(os.listdir(base_dir)): for filename in os.listdir(os.path.join(base_dir, folder)): if not filename.endswith(".py"): continue filepath = os.path.join(base_dir, folder, filename) test_file = filepath.replace(".py", "_test.txt") if not os.path.exists(test_file): continue result = subprocess.run( [sys.executable, filepath], stdin=open(test_file, "r", encoding="utf-8"), capture_output=True, text=True, timeout=10 ) expected = open(test_file.replace("_test", "_expected")).read() if result.stdout.strip() == expected.strip(): passed += 1 else: failed += 1 print(f"FAIL: {filename}") print(f"passed={passed}, failed={failed}")改造的过程中特别注意两点。第一，给每个脚本加上argparse或sys.argv参数解析，让它可以接收自定义输入而不是必须依赖标准输入——这样在本地调试时可以直接传参，不必每次拼接输入字符串。第二，把每个解法函数的返回值定义成纯数据（比如只返回int或list），输出逻辑统一放在print层。做到这个分离，后期做题目变体修改时就可以直接复用核心函数，只改输出格式。
另外一个实用的改造方向是按难度给题目打标签。机试刷题是有节奏的，前期以简单题建立信心，中期攻克中等难度的核心题型，后期集中突破自己薄弱的知识点。我建议给资源里每个描述.md增加一行难度: 简单/中等/困难和一个标签: 数组/DP/BFS，然后写个脚本按标签抽取题目，形成每日刷题清单。这个习惯能让你在有限的备考时间里始终练在最薄弱的方向上。
我自己的血泪教训是：千万不要在拿到资源后一头扎进代码里开始刷。先花半天时间把所有题目的标题和标签扫一遍，标注出自己完全不熟悉的知识点，然后逐个模块去攻克。从那以后我每次拿到新的刷题资源，都强制自己先做一次「资源盘点」——看结构、打标签、写调度脚本，再动手刷题。这套流程看起来慢了几天，但后面的效率会翻倍。这份Python代码资源本身的质量已经不低，剩下的就是你怎么把它内化成自己的东西。希望帮到你。
本文还有配套的精品资源，点击获取
