企业官网建设流程全解析

这两年华为OD机试的题目越来越卷，但本质考的还是那几个老生常谈的东西：逻辑拆解、边界处理、多语言实现能力。C卷的“采样过滤”这道题，乍一看就是个数组遍历加状态标记，但真上手写的时候，不少人在“连续无效数据的起点判定”和“过滤开始时那一条数据到底算不算被丢弃”上翻车。我当初刷这道题的时候也折腾了不少时间，这里把完整的思路、多语言实现和踩坑记录整理出来，希望对正在备考的朋友有帮助。

1. 题目到底在说什么：采样过滤的业务场景还原

先别急着看代码，这个题读不懂题意，写出来的代码基本都是错的。题目说的是传感器在持续采样，每秒采一个样本点，每个样本点包含时间戳和数值。正常来说数据是一条一条记录的，但采样过程中会出现两种异常：数值无效和数据突跳。

数值无效比较好理解，就是采集到的值小于0，比如传感器信号中断、干扰过大，这时候记录下来的数值就是无效的。数据突跳指的是相邻两次采样的数值差不是1，比如时间戳对应的数值本该是84、85、86这样递进，结果突然出现一个88或90，说明中间丢了采样或者数据被污染了。

针对这两类异常，题目给出了一个过滤条件：

• 如果从某个位置开始，连续出现了n个无效数据，那么从该段无效数据结束后的下一条数据开始，进入过滤状态，丢弃后面连续的有效数据，直到出现连续的u个有效数据，才恢复采样。

• 如果从头开始统计，当有效数据累积达到m个时，同样触发过滤状态，丢弃后续数据，直到连续u个有效数据出现再恢复。

过滤状态下，遇到无效数据、突跳数据、以及被丢弃的数据，都不输出。只有当恢复正常采样后输出的数据才是有效的。

这个场景放到真实系统里非常常见。比如工业现场的传感器采集，信号抖动、网络丢包、边缘网关误报，都会造成数据质量下降。过滤算法的作用就是把这些“脏数据”挡在门外，保证进入上层分析系统的序列是干净的。所以这类题考的不是纯语法，而是对“状态机”的理解。

2. 核心逻辑拆解：有效/无效判定与过滤状态切换

我把题目转化成程序逻辑，大致分三步。

第一步：判定每个数据点是否有效。

数据点有效，需要同时满足两个条件：

• data[i] >= 0
• data[i] == data[i-1] + 1（从第二个点开始判断）

也就是说，数值不能是负数，且必须和上一个有效数值保持递增1的关系。注意这里的“上一个”指的是时间上的上一条数据，不是上一个有效数据。题目说的是“如果数值小于0，视为无效；如果数值大于等于0，需要判断是否等于上一个数值+1”，这个上一个指的是原始序列中前一个采样值，这个细节很多人会理解错。

第二步：在未过滤状态下，判断是否触发过滤。

触发过滤有两种情况，满足其一即可：

• 从当前位置往前看，存在一段连续n个无效数据，且当前数据是这段连续无效数据结束后的第一条。也就是data[i-n]到data[i-1]全部无效，且data[i]是有效的（也可能无效，无效则继续累积）。
• 从数组开头到当前数据，累计有效数据个数达到m。

这两种情况是或的关系，谁先触发谁生效。注意第二种情况里的“有效数据”，即使中间有无效数据被跳过，只要累计数量到了就触发。

第三步：过滤状态下，何时恢复采样。

恢复的条件是连续出现u个有效数据。这u个有效数据本身是需要输出的，因为题目说的是“之后才能恢复”，也就是连续u个有效数据之后的那条数据才恢复正常采样。这里有个歧义，我后面细说我的处理方式。

整个逻辑可以用伪代码概括：

过滤状态 = false 实际输出的数据数量 = 0 当前连续有效数量 = 0 当前连续无效数量 = 0 累计有效数量 = 0 遍历每个数据点 i: 判断 data[i] 是否有效 如果 过滤状态 为 false: 如果 data[i] 无效: 连续无效数量++ 连续有效数量 = 0 否则: 连续有效数量++ 累计有效数量++ 如果 连续无效数量 >= n 或者 累计有效数量 >= m: 进入过滤状态 连续无效数量 = 0 累计有效数量 = 0 触发过滤的这条数据按要求处理（见下文） continue 否则: 输出 data[i] 对应的信息 继续下一个数据 否则（过滤状态下）: 如果 data[i] 有效: 连续有效数量++ 如果 连续有效数量 >= u: 退出过滤状态 输出 data[i] 对应的信息 连续有效数量 = 0 否则: 连续有效数量 = 0

有个关键点必须单独说：触发过滤时那个位置的判断。我见过很多AC代码是“如果连续n个无效，从这条数据开始就不输出了”，实际上题目描述通常是“过滤掉该数据之后的连续采样数据”，也就是说触发条件成立的当前数据本身不输出，下一跳开始丢弃。还有一种理解是当前数据是无效段的一部分，本来就不输出。这里需要看具体题面，我建议把触发过滤的当前数据也当作不输出的第一跳，因为它的状态要么是无效、要么是恰好凑够m个有效的那条，这两种情况在题面语境里都应该进入过滤状态而不输出。

第三个细节：过滤开始时数据个数不足n或m时的处理。题目有一条规定，如果采样数据个数小于过滤触发所需的最小值，就不需要过滤，全部输出。这个case也要处理。

3. 五种语言的实现：C++ / Python / Java / JS / Go

我分别给出完整实现思路，每个版本都按同一套状态机逻辑来写。代码不是唯一的，但状态转移一定要对。

3.1 C++实现

C++版本我直接用vector存数据，遍历的时候带索引计算，便于判断连续无效段。核心逻辑封装到一个函数里，输入是采样数列和m、n、u，输出过滤后的结果。

#include <iostream> #include <vector> using namespace std; bool isValid(const vector<int>& data, int i) { if (data[i] < 0) return false; if (i > 0 && data[i] != data[i-1] + 1) return false; return true; } vector<pair<int,int>> filterSamples(const vector<int>& data, int m, int n, int u) { vector<pair<int,int>> res; int len = data.size(); if (len < n && len < m) { for (int i = 0; i < len; i++) res.push_back({i, data[i]}); return res; } bool filtering = false; int invalidStreak = 0; int validCount = 0; int filteredStart = -1; for (int i = 0; i < len; i++) { bool curValid = isValid(data, i); if (!filtering) { if (!curValid) { invalidStreak++; validCount = 0; if (invalidStreak >= n) { filtering = true; invalidStreak = 0; validCount = 0; } } else { // 有效数据，但检查是否突跳(已经由isValid保证与前一值相差1) invalidStreak = 0; validCount++; // 如果累计有效达到m，触发过滤 if (validCount >= m) { filtering = true; validCount = 0; continue; // 当前这条不输出 } else { res.push_back({i, data[i]}); } } } else { if (!curValid) { invalidStreak = 0; // 过滤期间无效数据也清零连续有效，继续过滤 // 注意这里无效数据本身也不输出 continue; } else { invalidStreak = 0; validCount++; if (validCount >= u) { filtering = false; validCount = 0; // 恢复时这条输出 res.push_back({i, data[i]}); } } } } return res; }

需要注意C++判断“连续无效”时，我用的办法是累计invalidStreak，当它第一次达到n时就触发过滤。因为你无法预先知道哪一段是非法的，只能边扫边判断。这样逻辑最线性，也好调试。

3.2 Python实现

Python版本我写得更紧凑一些，用布尔变量维护状态，判断函数直接用lambda也行，但为了可读性还是单独定义。Python的索引操作和切片很方便，但别用切片去截断数组，一是耗内存，二是索引容易乱。

def is_valid(data, i): if data[i] < 0: return False if i > 0 and data[i] != data[i-1] + 1: return False return True def filter_samples(data, m, n, u): if len(data) < n and len(data) < m: return [(i, data[i]) for i in range(len(data))] filtering = False invalid_streak = 0 valid_count = 0 result = [] for i in range(len(data)): cur_valid = is_valid(data, i) if not filtering: if not cur_valid: invalid_streak += 1 valid_count = 0 if invalid_streak >= n: filtering = True invalid_streak = 0 valid_count = 0 else: invalid_streak = 0 valid_count += 1 if valid_count >= m: filtering = True valid_count = 0 continue else: result.append((i, data[i])) else: if not cur_valid: valid_count = 0 continue else: valid_count += 1 if valid_count >= u: filtering = False valid_count = 0 result.append((i, data[i])) return result

Python写这类题的优势是代码量少，但你要特别小心continue的位置。我在触发过滤时加了continue，这个continue跳过了后续的result.append，说明触发过滤的那条数据不输出。题目如果要求“过滤开始位置的前一条正常输出”，那这里的判别逻辑又不一样，考场上一定要反复读题。

3.3 Java实现

Java版本用ArrayList存结果，思路一样。Java的强类型有时候会让代码看起来啰嗦，但逻辑表达更清晰。

import java.util.ArrayList; import java.util.List; public class SampleFilter { public static boolean isValid(int[] data, int i) { if (data[i] < 0) return false; if (i > 0 && data[i] != data[i-1] + 1) return false; return true; } public static List<int[]> filterSamples(int[] data, int m, int n, int u) { List<int[]> result = new ArrayList<>(); int len = data.length; if (len < n && len < m) { for (int i = 0; i < len; i++) result.add(new int[]{i, data[i]}); return result; } boolean filtering = false; int invalidStreak = 0; int validCount = 0; for (int i = 0; i < len; i++) { boolean curValid = isValid(data, i); if (!filtering) { if (!curValid) { invalidStreak++; validCount = 0; if (invalidStreak >= n) { filtering = true; invalidStreak = 0; validCount = 0; } } else { invalidStreak = 0; validCount++; if (validCount >= m) { filtering = true; validCount = 0; continue; } else { result.add(new int[]{i, data[i]}); } } } else { if (!curValid) { validCount = 0; continue; } else { validCount++; if (validCount >= u) { filtering = false; validCount = 0; result.add(new int[]{i, data[i]}); } } } } return result; } }

Java版本的数组和列表转换比较麻烦，刷题时我一般直接用ArrayList，最后再转int[][]。如果你在OJ上提交，记得把类名改成Main，方法签名改成public static void main，输入输出用Scanner。

3.4 JavaScript实现

JS版本我用数组模拟，判断函数也是一样的。JS没有元组，我用对象{index, value}存储输出项。注意JS的Number类型对整数运算没坑，但比较时用严格等于===。

function isValid(data, i) { if (data[i] < 0) return false; if (i > 0 && data[i] !== data[i-1] + 1) return false; return true; } function filterSamples(data, m, n, u) { const result = []; const len = data.length; if (len < n && len < m) { for (let i = 0; i < len; i++) result.push({ index: i, value: data[i] }); return result; } let filtering = false; let invalidStreak = 0; let validCount = 0; for (let i = 0; i < len; i++) { const curValid = isValid(data, i); if (!filtering) { if (!curValid) { invalidStreak++; validCount = 0; if (invalidStreak >= n) { filtering = true; invalidStreak = 0; validCount = 0; } } else { invalidStreak = 0; validCount++; if (validCount >= m) { filtering = true; validCount = 0; continue; } else { result.push({ index: i, value: data[i] }); } } } else { if (!curValid) { validCount = 0; continue; } else { validCount++; if (validCount >= u) { filtering = false; validCount = 0; result.push({ index: i, value: data[i] }); } } } } return result; }

JS在牛客网、华为OD的机考环境里跑Node.js，注意输入用readline或者fs.readFileSync，数据格式处理要小心。输出的时候把result map成字符串再join。

3.5 Go实现

Go是我后面补的版本，写起来最像C++，但语法更简洁。Go没有while循环，只有for循环变体，遍历时用索引。

package main import "fmt" func isValid(data []int, i int) bool { if data[i] < 0 { return false } if i > 0 && data[i] != data[i-1]+1 { return false } return true } func filterSamples(data []int, m, n, u int) [][2]int { result := [][2]int{} length := len(data) if length < n && length < m { for i := 0; i < length; i++ { result = append(result, [2]int{i, data[i]}) } return result } filtering := false invalidStreak := 0 validCount := 0 for i := 0; i < length; i++ { curValid := isValid(data, i) if !filtering { if !curValid { invalidStreak++ validCount = 0 if invalidStreak >= n { filtering = true invalidStreak = 0 validCount = 0 } } else { invalidStreak = 0 validCount++ if validCount >= m { filtering = true validCount = 0 continue } else { result = append(result, [2]int{i, data[i]}) } } } else { if !curValid { validCount = 0 continue } else { validCount++ if validCount >= u { filtering = false validCount = 0 result = append(result, [2]int{i, data[i]}) } } } } return result } func main() { data := []int{1, 2, 3, -1, -1, -1, 4, 5, 6, 7, 8} res := filterSamples(data, 4, 3, 2) fmt.Println(res) }

Go版本的[2]int在append时注意类型，[][2]int等价于“二元组数组”，输出格式你自己定义。整体逻辑跟C++几乎一一对应，花不了多少时间。

4. 边界条件与隐藏大坑：为什么你的代码总是差一点点

这道题在华为OD机试里不算难，但通过率不高，主要就是边界细节多。我把常见的坑和容易误判的地方列一下，基本都是真实考场上会踩的。

4.1 连续无效的起点判定

第一种触发条件是“连续n个无效数据”，这里说的是净连续，不含有效数据夹杂。我最开始写的时候惯性思维用了window滑窗，后来发现自己搞复杂了。直接线性累积invalidStreak就行，关键是触发之后怎么处理。当invalidStreak第一次达到n时，说明当前遍历到的位置恰好是连续第n个无效，此时从这一条开始进入过滤状态，并且这条数据本身不输出。如果你用的是“先收集连续无效数据段，再判断段尾后一条”的思路，就要小心段尾后一条不存在的情况，比如数据末尾刚好是n个无效连续，那后面没数据可滤了，收尾也要处理好。

4.2 m个有效数据触发过滤的数据算不算输出

前面我提到这个细节，再展开说。累计有效数据达到m时，那第m条有效数据本身到底输不输出？我按不输出来写，理由是这样：题目说“当有效采样个数达到m时，将从下一个有效采样开始过滤”，这个“从下一个有效采样开始”明确把当前这条排除在过滤之外，但当前这条是第m条，逻辑上它已经完成了“达到m”的使命，继续保留会破坏过滤的纯粹性。所以各大题解和我的测试统一为：达到m的这条不输出，从它后面的数据开始丢弃。如果你的题面描述刚好相反，输出就要对应调整，考场上要仔细看。

4.3 过滤状态下连续有效u个之后，恢复采样的那条算不算输出

这个和4.2是镜像问题。我按“恢复采样的第一条数据输出”来写，因为连续u个有效数据这段区间里的数据是被过滤掉的（否则就不算过滤），当u个有效数据凑满后，恢复采样的标志是从下一条正常数据开始输出。但有些题解把连续u个有效数据的最后一条当作恢复后第一条输出，两种理解对结果有影响。我的处理方式在代码里是：validCount达到u时，立即清除过滤状态并输出当前这条数据，这里其实隐含了“当前这第u个有效数据是恢复后的第一条”。如果题目语意是“连续u个之后恢复”，那这u个也不输出，代码改成把result.append挪到下一轮循环里即可。

4.4 数据个数小于n和m时的“免过滤”规则

题目通常会有一句“如果采样个数小于n和m，则无需过滤”，这个我直接在最开始做了长度判断。但要注意，这里的小于是“同时小于n和m”，不是“或”。如果一个满足一个不满足，还是要走完整逻辑。上个月我帮朋友看代码，他就漏了这个，导致特定case全错。

4.5 有效数据的递进判断基准

data[i] == data[i-1] + 1这个条件，基准是原始数组中的前一个位置，不是前一个有效输出。比如[1, 2, -1, 4]，4的有效性判断是看它是否等于-1 + 1，也就是是否等于0，显然4不等于0，所以4无效。这一点很容易被误解成“跳过无效值后做递进判断”，千万别搞混。因为题目描述里强调的是采样数值的连续递增关系，如果中途出现无效值，递进关系就被打破了。

4.6 过滤期间无效数据的处理

过滤状态下，如果遇到无效数据，我代码里是validCount = 0然后continue，不输出。这里有个隐含逻辑：无效数据不会帮助恢复采样，也不会延长过滤时长，它只是被打断的“连续有效”计数。有些新手会在过滤状态下无效数据触发新的“连续无效n”判断，造成状态叠加，完全没有必要。过滤状态已经把所有数据都拦截了，不需要再判断是否进入新的过滤。

4.7 相邻差值判断的边界

第一个数据点没有前驱，所以只看它是否小于0。如果第一个点就是负数，直接无效并启动无效累积；如果第一个点非负，无条件算有效。这个细节在测试用例里经常用[0, 2, 3]这类数据来卡，2不等于0+1，所以从2开始就是突跳，需要被丢弃。

4.8 连续无效的区间跨越多个阶段

比如数据是[1, -1, -2, -3, 5, 6]，n=3，这里-1、-2、-3是连续无效，5开始进入过滤，6也被滤掉。但注意如果n=2，那-1、-2就触发过滤了，-3也顺带被滤掉，5、6也一样。不同n导致过滤起点不同，结果差异很大。测试时建议把n变小验证边界是否正确触发。

5. 测试用例设计与验证思路：模拟华为OD的判题逻辑

刷这类题最重要的不是背代码，而是会构造测试用例自测。这里弄一组覆盖主要场景的测试数据，你们拿到代码后可以直接跑。

用例1：正常数据，无过滤触发

数据：[1, 2, 3, 4, 5]，m=6，n=3，u=2 结果：数据个数小于m且小于n，全部输出。

用例2：连续无效过滤

数据：[1, 2, -1, -2, -3, 5, 6, 7]，m=10，n=3，u=2 预期：

• 1、2正常输出
• -1、-2无效，不输出
• 到-3时连续无效满3，触发过滤，-3不输出
• 5、6过滤中，不输出
• 7有效，连续有效u=2还需要一个，所以7先不输出
• 如果后面还有8，则8恢复后输出

用例3：m触发过滤

数据：[1, 2, 3, 4, 5, 6, 7]，m=4，n=5，u=2 预期：

• 1、2、3正常输出
• 4是第4个有效数据，累满m，触发过滤，4不输出
• 5、6过滤中，5不输出，6有效，开始计数1
• 7有效，计数2，达到u，恢复，7输出

这个case网上经常能搜到，本质是考察m触发边界的。

用例4：多个过滤区间连续出现

数据：[1, -1, -2, 3, 4, -3, -4, 5, 6, 7]，m=10，n=2，u=2 预期：

• 1正常
• -1无效，连续无效1，不输出
• -2无效，连续无效2，触发过滤，不输出
• 3有效，过滤状态，计数1，不输出
• 4有效，计数2，恢复，4输出
• -3无效，未过滤状态下无效，计数1
• -4无效，计数2，触发过滤
• 5、6过滤中，5计数1，6计数2，6恢复？这里注意6满足连续有效2，所以6输出
• 7未过滤状态，正常输出

这个用例能测出连续两个过滤区间能否正确衔接。

用例5：开头就是无效段

数据：[-1, -2, -3, 1, 2, 3]，m=5，n=3，u=2 预期：

• -1、-2无效
• -3触发过滤
• 1、2过滤中，2有效计数1，3有效计数2，恢复，3输出

如果开始时过滤没有触发过，要考虑数组头部连续无效段直接启动过滤的情况。代码里的逻辑是遍历到-3自动进入过滤，不需要额外初始化，我的实现已经处理。

用例6：m和n在同一位置同时满足

数据：[1, 2, -1, -2, 3, 4, 5]，m=3，n=2，u=1 预期：

• 1有效，有效计数1，输出
• 2有效，有效计数2，输出
• -1无效，无效1
• -2无效，无效2，触发过滤（同时有效计数还是2，未到3，所以n先触发）
• 3过滤中，有效计数1，u=1，恢复，3输出
• 4正常状态，有效计数1，输出
• 5正常状态，有效计数2，输出

注意m和n同时满足时，边界顺序很重要。我的代码是先判断无效触发再判断有效触发，也就是n优先。如果题目要求m优先，结果可能不同，这也是题目描述里容易隐藏的一个点。

6. 如何调试和优化：从30分钟到10分钟的思路转变

我刚开始写这道题用了滑窗+辅助数组，把每个位置之前的连续无效数和累计有效数都预处理出来，写了大几十行，各种 index 错位。后来发现这道题根本不需要预处理，直接在线性遍历过程中维护两个计数器就行。

关于滑窗的错误直觉：很多人一看到“连续”两个字就想滑窗，但这题没有窗口求和的需求，只需要“是否达到阈值”。线性计数器够用，维护成本低。滑窗反而要处理窗口出界和触发后的重置，增加了不必要的复杂度。

关于递归：完全没必要。状态只依赖当前数据和上一数据，是典型的迭代场景。用递归反而要自己管理栈帧和参数传递，容易爆栈。

代码优化的方向：

• 尽量减少分支嵌套。我现在的写法是“非过滤状态”和“过滤状态”两个主分支，每个分支内部再细分有效无效，逻辑已经比较扁了。
• 把isValid单独抽出来，不管是C++、Python还是Java，都能让主流程更清晰，也方便单独测试每个数据点的有效性。
• m和n的判断统一用>=而不是==，因为触发条件理论上可以重复，用>=防止特殊情况漏判。
• 过滤状态下invalidStreak要不要维护？答案是不要。过滤期间所有数据都不放行，无效数据只是打断连续有效计数，至于无效了几个、够不够n，完全没有意义，因为已经在过滤状态里了。很多超时的代码就是在这里做重复维护。

还有一点：输出格式。华为OD机试对输出格式要求非常严格，时间戳和数值之间用分号还是空格、每条数据之间怎么隔开，都要和题目完全一致。我在本地调试时写了个小的打印函数：

def print_result(res): if not res: print("empty") else: print("; ".join(f"{idx}:{val}" for idx, val in res))

真实考试里不要自己发明格式，看清楚样例输出再写打印逻辑。

7. 从这道题看华为OD机试的评分逻辑与答题策略

华为OD机试不是只看最终答案正确率，还会看代码可读性、变量命名、边界覆盖情况和运行时间。尤其是C卷，越来越接近实际工作场景，考察的不仅是编码能力，更是逻辑完备性。

我总结了一下几类人在这道题上的典型丢分点：

1. 不读题直接上手写代码，导致过滤触发时机错误，这是最大的失分来源。
2. 边界条件没人肉测试，像数据个数小于n和m的免过滤分支经常被漏掉。
3. 多语言实现时，语法特性影响逻辑，比如JS的隐式类型转换导致比较出错，Java的数组越界问题没处理好。
4. 时间空间复杂度超标，比如用递归或者反复截断数组，在大数据量下超时。

我给备考的人一个建议：在硬刷题之前，先画状态转移图。不需要多专业，就画两个圆圈，一个叫“正常采样”，一个叫“过滤采样”，然后标出什么条件下从正常到过滤、什么条件下从过滤回正常。能不能把这张图画对，基本决定了你代码能不能一次写对。我画这个图大概用了两分钟，后来看别人总结的“状态机”方法，才发现自己无意中走对了路。

状态转移其实很简单：

• 正常状态：遇到无效数据累积够n -> 过滤；有效数据累积够m -> 过滤
• 过滤状态：连续有效数据够u -> 恢复正常

除此之外，一切数据都不输出。这张图就是整道题的灵魂。

8. 总结之外的一点私货：这类题目在工作里真的有用吗

最后说点题外话。采样过滤这个模型，和我在实际工作中见过的时序数据清洗逻辑几乎一摸一样。有个项目是接工业设备传感器数据，设备会上报温度、压力、转速等指标，经常出现负值或者数值跳变，我们当时写的过滤规则就是类似的连续无效阈值和跳变判定。只不过真实系统里还会加上阈值上下限、限幅滤波、中值滤波这些组合策略，但核心的“状态机过滤”思想没变。

所以不要觉得这只是一道面试题，它背后的“数据质量判断”“异常窗口处理”“恢复正常采样”这些设计，放在数据管道、监控告警、物联网平台上都是基础技能。把一道机试题吃透，作用不仅是过考试，后期做项目也会更顺手。

回到题目本身，如果你在手写代码前能先确认那几个模糊细节——触发过滤的当前数据是否输出、u个有效数据后恢复时怎么算、数据个数小于阈值时怎么处理，你的代码大概率一遍就能过。剩下的无非是把状态机用你熟悉的语言翻译一遍。

我花在调试这道题上的时间，大部分是浪费在对“连续无效段结束后的下一条数据”和二义性文字的理解上。等到把题目用自己的话复述清楚、画出状态图之后，编码基本十分钟搞定。所以如果你现在卡在代码上，先把题目放一边，写清楚输入输出和状态变化，再回来写代码，效果会好很多。