企业官网建设流程全解析

1. 写在最前：这套题到底值不值得刷

网易2018校园招聘编程题，说新不算新，但如果你正在准备大厂校招笔试，我依然建议你把这套题翻出来过一遍。原因很简单：网易笔试的出题风格在这几年里保持得相当稳定——题面不长、看着不难、但总会在某个边界条件或者思维转换上卡你一下。这种风格跟字节、腾讯的偏重工程实现不太一样，网易更看重“你能不能把一个朴素的思路想清楚”，而不只是“你会不会背模板”。

我当年刷这套题的时候还是在校生，第一遍做下来心态有点崩——有几道题明明觉得思路对了，提交就是过不了。后来仔细复盘才发现，问题都出在一些非常基础的细节上，比如数组越界、取模运算的优先级、甚至是没有考虑输入可能带换行符。这些坑，没有真实写过的人很难提前预判到。

所以这篇文章我不打算把每一道题都贴一遍完整代码（题面在网上很容易搜到），而是挑出几类有代表性的题目，讲清楚它们背后的考察点、推导过程、代码实现时的注意点，以及我在实际调试中踩过的坑。无论你是刚开始准备校招的在校生，还是想跳槽但已经有一段时间没刷题的在职开发，这套题的解题思路都值得你花一两个小时过一遍。

1.1 2018年网易笔试的基本盘

先把整体情况说清楚。2018年网易校招的编程题一般是3到4道，限时90分钟左右，难度梯度大致是：

这个结构其实沿用了很多年，2018年的题目里，既有那种“一眼就能写但容易漏情况”的简单题，也有“想通了一行代码就能解决，想不通就绕远路”的思维题。下面我按类别拆开讲。

2. 字符串与数字处理：看似送分，实则暗藏陷阱

2.1 字符串碎片：统计连续相同字符段

有一道题是给一个字符串，要求计算所有“碎片”的平均长度。所谓碎片，就是字符串被连续相同的字符切分后得到的每一段，比如"aaabbaaac"会被切成"aaa"、"bb"、"aaa"、"c"四段，平均长度就是(3 + 2 + 3 + 1) / 4 = 2.25，输出结果要求四舍五入保留两位小数。

这道题本身不难，遍历一次，每遇到相邻字符变化就count++，同时把当前碎片长度累加，最后用总长度除以碎片数就完事了。但有两个细节值得拿出来说：

第一个细节是“碎片数”怎么数。很多人会习惯性用“连续相同字符段的数量”来想，但在实现时，如果从i = 0开始遍历，比较s[i]和s[i + 1]，判断是否不同，那么注意循环终止条件是i < s.length() - 1，否则最后一个字符会越界。我在第一次写的时候用的是i < s.length()，结果数组越界异常，直接整道题挂了——这种低级错误在笔试环境下特别容易犯，因为紧张。

第二个细节是浮点数输出的四舍五入。C++ 里可以用printf("%.2f", avg)，Java 里用String.format("%.2f", avg)，但如果你用 Python，round()的银行家舍入规则可能会让你意外——比如round(2.25, 2)在某些情况下会得到2.2而不是2.3。更稳妥的做法是用DecimalFormat或者f-string的格式化能力，它们的实现更符合日常认知的“四舍五入”。

提示：笔试环境通常不让你试运行，所以一定要在平时养成对浮点数输出格式的敏感度。建议优先使用格式化字符串而非round()函数。

2.2 相反数：数学规律的小考

另外一道基础题是“相反数”：给定一个正整数 n，把它倒过来得到 reversed_n，然后输出n + reversed_n。比如n = 123，倒过来是321，和是444。这道题核心就是考察数字反转的写法。

数字反转有两种常见写法：一种是转字符串reverse再转回整数，另一种是循环取模累加。笔试时我推荐直接用整数方式：

def reverse_num(x): rev = 0 while x > 0: rev = rev * 10 + x % 10 x //= 10 return rev

这个写法简单可靠，不需要考虑字符串反转后可能丢失前导零的问题。但注意：有的题目会要求处理负数的相反数，这个场景下x % 10在 Python 和 C++ 里的结果不同——Python 的取模永远是非负的，C++ 则保留符号。虽然 2018 年这道题没有挖这个坑，但万一以后遇到类似题，这个差异你得心里有数。

这两道题放在一起说，是因为它们代表了一类“基础但必须零失误”的题目。它们的共同特点是：代码量不大、算法复杂度要求低，但如果你在细节上掉链子，就会白白丢分。所以我的建议是，这类题在笔试时应该用最快的速度写完，但写完不要急着交，用一两分钟把边界情况过一遍——空字符串、单个字符、全是相同字符、含有前导零的数字、最大整数。

3. 思维转换题：想清楚了代码就简单

3.1 魔法币：逆向思维和二进制视角

2018年网易有一道“魔法币”的题，题面是：你有两种魔法机器，机器一输入 x 会输出2x + 1，机器二输入 x 会输出2x + 2。现在给一个目标数字 n，要求输出一个由1和2组成的操作序列，表示从 0 开始依次使用哪些机器可以得到 n。

刚看到这道题，我第一反应是正向搜索，从 0 开始 BFS，直到找到 n 为止。数据量小的时候没问题，但题面没有给出 n 的上限，如果 n 很大，BFS 就完全不可行了。这就是网易出题的一个特点：题面不会直接提示你复杂度要求，但实际上需要你先做数学分析。

我们来推一下：机器一的输出是2x + 1，永远是奇数；机器二的输出是2x + 2，永远是偶数。所以给定目标 n，我们可以反推最后一步用了哪个机器：

• 如果 n 是奇数，最后一步一定是机器一，那么上一步的值是(n - 1) / 2；
• 如果 n 是偶数，最后一步可能是机器二，那么上一步的值是(n - 2) / 2 = n/2 - 1。

从 n 一路反推到 0，再把每一步的机器序号反过来输出，就是答案。这个思路的本质是：每个机器操作都是可逆的，从结果倒推过程比从过程推到结果要简单得多。

代码大概长这样：

def magic_machine(n): ops = [] while n > 0: if n % 2 == 1: # 奇数，最后一步是机器1 ops.append('1') n = (n - 1) // 2 else: # 偶数，最后一步是机器2 ops.append('2') n = (n - 2) // 2 return ''.join(reversed(ops))

写完之后你可能会发现，这个反推过程和“把一个数转成二进制”几乎一模一样——奇数对应二进制位为 1，偶数对应二进制位为 0。事实上，如果你把机器一视为“在二进制末尾追加 1”，机器二视为“在二进制末尾追加 0”，那么从 0 到 n 的过程本质上就是在二进制上从高位到低位写 n 的二进制表示，只是 0 和 1 的映射关系需要转换一下。这就是这道题最有意思的地方——表面上是模拟题，实际上是二进制题。

实操心得：做题时如果发现正向搜索复杂度太高，先停下来想想能不能反向操作。很多“操作不可逆”的题，其实只是你没有找到逆运算；一旦找到，问题通常会变得非常简单。

3.2 操作序列中的规律：循环节思想

还有一类题在2018年出现过，是给定两个数 a 和 b，以及一个操作序列（比如交替加乘），要求输出经过 n 次操作后的结果。这类题的关键在于：n 可能很大，不可能真的循环 n 次，需要找到规律或循环节。

比如有一道题是给一个初始值 x，然后循环执行“先乘以 p 再加上 q”，执行 n 次，求最终结果。直接模拟的复杂度是 O(n)，如果 n 是 10 的 9 次方级别，那就完全不可行。这种时候要先推导数学公式。

设f(x) = px + q，那么执行两次：

f(f(x)) = p(px + q) + q = p^2x + pq + q

执行 n 次就是：

p^n * x + q * (p^(n-1) + p^(n-2) + ... + p + 1)

后面的等比数列求和可以用等比数列公式算，也可以用快速幂配合模运算来做。如果题目还要求对某个数取模，那就需要用到模逆元或者矩阵快速幂。这道题把范围限制得比较小，所以简单模拟也能过，但一旦你理解了公式推导的思路，遇到类似题就会从容很多。

我建议你把这个推导过程当成模板记下来：线性递推（形如 f(x) = ax + b ）经过 n 次迭代的通项公式、如何用快速幂计算、如何取模。网易出题喜欢在这个基础上变花样，但核心始终是“找到重复结构的数学表达”。

4. 序列与排列问题：分类讨论是核心能力

4.1 重排数组：相邻乘积被4整除

2018年有一道“重排数组”的题，要求判断能否把一个数组重新排列，使得任意相邻两个数的乘积都能被 4 整除。当时我第一反应是排序后处理，后来发现排序完全不管用——这道题的正确做法是分类讨论。

先把数按模 4 的余数分类：

• 余 0 的数：它们是 4 的倍数，放在任何位置都不影响相邻乘积被 4 整除，因为它们自己就提供了因子 4；
• 余 2 的数：它们只贡献一个因子 2，所以需要相邻的另一个数也是偶数（即余 0 或余 2），才能凑出因子 4；
• 余 1 和余 3 的数：它们是奇数，没有任何因子 2，所以它们两边必须有“足够强”的偶数来弥补。

然后分情况讨论：

• 如果余 2 的数存在，那么它两侧必须是偶数，也就是说整个序列中偶数的数量要足够“覆盖”这些位置；
• 对于余 1 和余 3 的数（奇数），它们不能相邻，除非中间夹一个余 0 的数。

实际上更简洁的判断方法是统计三个量：cnt0（能被4整除的个数）、cnt2（余2的个数）、cnt1（奇数的个数），然后看：

• 如果cnt2 == 0，那么只需要cnt0 >= cnt1 - 1即可（用 4 的倍数隔开所有奇数）；
• 如果cnt2 > 0，那么第一个放了余 2 的数后，它的两侧都必须是偶数，这等价于要求cnt0 >= cnt1（因为余 2 的数不能用来隔开两个奇数，它自己还需要别的偶数来救）。

这个分类讨论的逻辑，我当年第一次做的时候完全没想明白，看了题解才意识到：这类题考的不是算法，而是“能否把一个看似复杂的问题拆成有限种清晰的场景”。这种能力在后续面试里非常吃香，因为面试官特别爱问“你觉得有哪些边界情况需要处理”。

避坑指南：这种题最常见的错误是试图用排序或贪心一把梭，结果总有一两个 case 过不了。正确姿势是先列出所有可能的“类型组合”，再逐个验证。这个思维方式比任何算法模板都重要。

4.2 统计序列的题目：计数方式决定复杂度

另一类高频题是“给一个排列或序列，要求统计满足某条件的子序列数量”，比如等差数列子序列、递增三元组等。2018年网易也出了类似的题——给定一个序列，统计所有长度为 3 的递增子序列个数。

暴力的做法是三重循环，O(n^3)，n 稍大就爆。优化思路是：枚举中间元素，统计左边比它小的个数 left，右边比它大的个数 right，答案累加 left * right。这个思路在“递增三元组”“逆序对”这类题目里反复出现，本质是“以中间元素为基准，把问题拆成左右两个独立子问题”。

以中间元素为基准的这个思想非常通用。以它为中心的很多变体题——比如“统计有多少个三元组，中间元素是两边元素的最小公倍数”之类——都可以套这个框架。你可以先得出一个朴素但正确的版本，再根据数据范围去优化。

def count_increasing_triplets(nums): n = len(nums) ans = 0 for j in range(1, n - 1): left = sum(1 for i in range(j) if nums[i] < nums[j]) right = sum(1 for k in range(j + 1, n) if nums[k] > nums[j]) ans += left * right return ans

这个版本是 O(n^2) 的，如果 n 在 1000 左右可以直接过。如果 n 更大，那就需要配合树状数组或线段树把 left 和 right 的统计优化到 O(logn)，总体 O(nlogn)。但笔试时不要一上来就写树状数组——先看数据范围，如果 O(n^2) 能过，就不要给自己加戏，写复杂结构反而容易出 bug。

5. 模拟与搜索题：代码实现力的试金石

5.1 时钟问题：把时间拆成数字再处理

有一道题是给定一个时间戳（比如"12:34"），要求输出下一个“回文时间”——就是倒过来读也一样的合法时间，比如"12:21"。这个题第一眼觉得简单，但实际上有几个坑：时间的合法性（小时不超过 23、分钟不超过 59）、进位问题（比如"23:32"之后没有回文时间，需要回到第二天）、以及把字符串和整数互转的细节。

我的写法是先把时间转成分钟数，然后从下一秒开始逐个检查是否是回文：

def next_palindrome_time(t): h, m = map(int, t.split(':')) cur = h * 60 + m while True: cur += 1 if cur >= 24 * 60: cur = 0 hh, mm = cur // 60, cur % 60 s = f"{hh:02d}{mm:02d}" if s == s[::-1]: return f"{hh:02d}:{mm:02d}"

这个解法是 O(24 * 60) 的，最多循环 1440 次，完全没问题。有更数学的解法——直接构造回文串再判断合法性——但没必要，时间复杂度的余量足够大，简单的暴力更不容易出错。

5.2 射击游戏 / 地图模拟：状态设计的细节

还有一道题涉及在一个二维网格上模拟某种射击或移动规则，类似“小游戏”的感觉。这类题目考察的不是算法复杂度，而是你能否准确地把题面规则翻译成代码逻辑，尤其是边界处理和状态同步。

这类题在实现时最容易犯的错是“一边遍历一边修改”。比如你要判断某个格子是否会被射中，却同时更新了地图，那就可能影响后续判断。正确做法是先基于当前状态做完整判断，再统一更新，否则很容易出现“连锁反应”没有被规则允许的情况。

我当时在这道题上卡了很久，因为我的实现里，一个角色的移动会立刻改变地图状态，导致另一个角色的判断依赖了更新后的地图，最后结果多了好几个错误 case。后来把“移动”和“判断”拆成两个阶段，问题就解决了。

这类模拟题的通用模板大概是：

1. 读入输入，建立初始状态；
2. 在一个 while 或 for 循环里，先根据当前状态计算所有操作的结果；
3. 一次性提交所有状态更新；
4. 判断终止条件，输出结果。

只要守住“当前状态”和“更新后状态”之间的边界，大部分模拟题都能稳拿分。

6. 备考策略：从真题中提炼可复用的能力

6.1 网易出题的“三类考察点”

刷完这套题，我总结出网易笔试的三大考察点，这在其他大厂笔试里也有参考价值：

一是代码基本功。字符串处理、数字反转、数组遍历这些操作要写到“不用过脑子”的熟练度。这不是说你不思考，而是这些基础操作不应该消耗你的认知资源——你的脑力应该留给更复杂的逻辑判断。平时可以刻意练习一些高频的基础代码片段，比如反转字符串、判断回文、数组去重、二分查找，把它们练成肌肉记忆。

二是数学模型的敏感度。很多看起来像模拟题的题目，本质是数学题。比如反推机器操作、二进制与操作序列的对应关系、线性递推的通项公式。具备“先把问题抽象成数学模型”的意识，比刷题数量更重要。

三是边界条件的完备性。网易特别喜欢考“看起来简单、但边界情况很多”的题。对付这种题，唯一有效的办法是多写测试用例，尤其是极端用例——空输入、单个元素、最大值、最小值、重复元素、负值、溢出值。在笔试时，如果你能提前在草稿纸上列出这些 case，再逐行审视代码，基本能解决 80% 的隐藏 bug。

6.2 刷题节奏：三轮复习法

如果你时间还比较充裕，我建议你用三轮来刷这套题：

第一轮：按照题目顺序做一遍，不限时，重点是把每道题的思路写清楚，代码能跑通就行。遇到卡住的题，允许看题解，但看完之后必须自己重新写一遍，不能照着题解抄。

第二轮：限时模拟，整套题在一个半小时内完成，模拟真实笔试氛围。这轮结束后，把做错的题、超时的题、以及“看了题解才做出来”的题，单独标记出来。

第三轮：针对标记过的题目做专项突破。每道题至少用两种不同的解法实现一遍——比如暴力 + 优化、递归 + 迭代、正向 + 逆向。这样做的目的是让你对同一道题形成多角度的理解，考试时就算遇到变体也能快速找到思路。

这套方法不仅适用于网易的题，对其他公司的笔试同样有效。关键是不要为了“刷完”而刷，而是为了“理解”而刷。

6.3 千万别忽略：环境差异与输入输出

最后再强调一个很多人会忽略的点：练习时用的本地 IDE 和笔试平台的环境是有差异的。尤其是输入输出格式、换行符、空格处理、浮点数精度、标准库版本的差异，这些小问题在笔试时可能让你白白丢分。

我的建议是，考前至少去目标公司的笔试模拟平台做一次全套模拟，提前熟悉代码编辑器的补全功能是否可用、是否支持自动保存、编译报错信息是否清晰。另外，笔试时合理安排时间——遇到一道题 20 分钟没有思路，果断标记跳过，先把后面能拿的分拿到，再回头处理难题。

我在实际刷题过程中体会很深的一件事是：笔试考的不只是你会不会做这道题，更是你在有限时间和压力环境下的稳定发挥能力。这种稳定，只有靠大量限时练习和刻意总结才能获得。希望你也能从这套 2018 年的真题里，找到自己的薄弱点，然后一个个补上。