企业官网建设流程全解析

卡在《图灵完备》"无符号小于"这一关的人，绝大多数不是不会接线路，而是压根没想清楚"两个8位字节凭什么能比出大小"。我第一次打这关的时候，凭直觉从最低位开始一级一级往上串比较器，结果测试用例一跑，A=128、B=127 这种最经典的例子直接翻车。后来把逻辑重新捋一遍才发现，二进制比较和十进制比较是同一回事：从权重最高的那一位开始，谁先分出胜负就听谁的。这篇就把8位无符号数比较大小的两条主流路线完整拆一遍——逐位比较链、加法器借位法——顺带把原码、反码、补码这条线讲透，因为等你推进到"有符号小于"那一关，真正卡人的就是这套东西。刚打完8位加法器的新手、想补补码理解的老玩家，下面的内容都能直接抄进自己的沙盒。

1. 无符号比较的判定标准：从最高位开始"定胜负"

1.1 十进制里怎么比，二进制就怎么比

拿两个四位数举例：3721 和 3699。我们会先看千位，都是3，打平；再看百位，7 比 6 大，到此判定 3721 大，后面的十位个位哪怕是 999 也翻不了盘。这个"从高位往低位扫，第一个不相等的位定胜负"的过程，就是字典序比较，二进制只是把位权从 10 的幂换成 2 的幂，规则没有任何变化。

换成 8 位字节：A = 1000 0000，B = 0111 1111。最高位 a7 = 1、b7 = 0，第一位就分出胜负了，A > B。你完全不用管后面 7 位是什么，哪怕 A 剩下的全是 0、B 剩下的全是 1。这一点和十进制里"千位大的数一定大"是同一个道理：高位的权重（128）比所有低位权重之和（127）还要大 1，所以高位一旦领先，低位加起来也追不回来。

1.2 把"比较"写成一段能执行的状态机

人眼扫一眼就出结果，电路不会。我们得把上面那段直觉翻译成一个可以逐位执行的过程。引入两个状态量：

• eq_so_far：到目前为止扫过的所有高位是否全部相等，初始为 1；
• less：当前是否已经判定 A < B，初始为 0。

从最高位 i = 7 往下扫到 i = 0，每一位做两件事：

less = less OR (eq_so_far AND (NOT a_i) AND b_i) eq_so_far = eq_so_far AND (a_i == b_i)

翻译成人话：如果前面所有高位都还相等（eq_so_far = 1），那么这一位上 A 是 0、B 是 1，就说明 A 小，把这个结论记进less；同时更新eq_so_far，一旦这一位不相等，后面所有位的判断全部作废。

这里有个细节值得留意：less一旦被置 1 就永远保持，因为后面eq_so_far已经变成 0，后续的 OR 项都是 0，不会把结论冲掉。反过来说，如果某个高位判定 A > B（即 a_i=1、b_i=0），eq_so_far变 0 而less保持 0，结果就是"不小于"，也是对的。

1.3 从最低位开始串，为什么必错

我用一个反例说明。A = 1000 0000（128），B = 0111 1111（127）。

最低位 a0 = 0、b0 = 1，如果按照"从低位开始比"的逻辑，这一位立刻判定 A < B——可事实恰好相反。问题的根源在于：低位的信息量根本不足以判断整体大小，它只在所有更高位都相等的前提下才有效。而这条"前提"是级联的、单向传递的，只能从高位往低位传。

所以电路里比较链的数据流方向必须是 MSB → LSB，第一位（最高位单元）的判断优先级最高，越往低位优先级越低。接线时把顺序搞反，测试用例里那些高位不同、低位恰好反过来的样本就会集体报错，而且错得很隐蔽。

1.4 换个视角：A < B 等价于"减法产生借位"

除了逐位扫描，还有一条数学味更浓的路子：A < B 当且仅当 A − B 的结果是负数。而无符号数在 8 位里没有"负"这种表示，减出来的负结果会体现为借位（borrow）。

只要你能算出 A − B 并观察到借位信号，那么"借位 = 1"就是 A < B。这一条和逐位比较是完全等价的命题，只是实现路径不同：前者靠逻辑链，后者靠加法器。第 3 节会把借位法展开，这里先记住这条等价关系——它是把"比较"问题转化为"算术"问题的关键，也是后面理解有符号比较的基础。

提示：无符号"小于"是严格的<，A = B 时输出必须是 0。这一点在两条实现路线上都会埋坑，后面会专门讲。

2. 逐位比较链：把 8 个 1 位比较单元串起来

2.1 单个比较单元需要几个信号

把 1.2 里的那段代码"切成片"，每一位就是一个独立的小单元。这个小单元需要的输入是：

• a、b：当前位参与比较的两个比特；
• in_eq：所有更高位是否全相等；
• in_less：所有更高位是否已经判定 A < B。

输出两个：

• out_eq：加上当前位之后，是否依然全部相等；
• out_less：加上当前位之后，是否已经判定 A < B。

六种有效情形列成真值表，一目了然：

表里前两行是最容易被忽略的：in_eq = 0之后，不管你这一位是什么，输出都不再受a、b影响。这就是层级优先级的体现——高位的结论一旦产生，低位就只剩"透传"的职责。

2.2 从真值表到布尔表达式

对着上面的真值表化简，两个表达式都很短：

out_less = in_less OR (in_eq AND (NOT a) AND b) out_eq = in_eq AND NOT(a XOR b)

逐条拆解它的电路构成。out_less由两部分做 OR：一部分是in_less直通，另一部分是"高位全等 + 本位 A 是 0 + 本位 B 是 1"这三个条件同时成立。out_eq则是"高位全等"和"本位相等"两个条件的与，而"本位相等"就是NOT(a XOR b)，也就是同或门。

映射到基础门电路上：

• NOT a：1 个非门；
• NOT a AND b：1 个与门；
• in_eq AND (...)：1 个与门；
• in_less OR (...)：1 个或门；
• a XOR b：1 个异或门；
• NOT(a XOR b)：1 个非门；
• in_eq AND NOT(a XOR b)：1 个与门。

满打满算约 7 个基础组件。如果你在搭建时把NOT a的中间结果引出来复用，或者游戏里提供了三输入门、同或门，能压到 4 到 5 个。8 位级联下来大致是 40 到 55 个组件的量级——心里有这个数，遇到关卡限制时才知道该往哪个方向优化。

2.3 级联的接法与首尾两端的特殊处理

8 个单元从高到低排成一列，第 7 位单元吃a7、b7，第 6 位吃a6、b6，依此类推。接线规则是固定的：

1. 最高位单元（i = 7）的in_eq接常量 1，in_less接常量 0——这是整个链的初始状态，"目前还没有任何信息，默认全部相等、尚未判定小于"；
2. 第 i 位单元的out_eq、out_less分别接到第 i−1 位单元的in_eq、in_less；
3. 最低位单元（i = 0）的out_less就是整条链的最终答案。

中间任何一级接错方向，结果都会诡异到让你怀疑元件本身坏了。我建议在搭建时给每一级起名字，比如cmp_bit7、cmp_bit6，出问题时一眼就能定位是哪一级的输入输出接错。

2.4 用"或归并"替代"优先链"，电路更简单

上面这套级联方式需要传递两个信号（eq和less），连线数量翻倍。有一种更省连线的写法，把所有 8 位的判断项直接归并：

less = OR over i in [7..0] of ( prefix_eq(i) AND (NOT a_i) AND b_i )

其中prefix_eq(i)表示"比 i 更高的所有位全部相等"。这样每一级只需要输出一个"前缀是否相等"的信号往下传，最后用一个多输入或门把 8 个判断项汇总。在《图灵完备》里，多输入门往往可以直接用，所以这种写法在组件数量上通常更划算。

两种写法的逻辑等价，差别只在连线和门的复用方式。我的经验是：第一次做这关，用双信号级联版本，因为它和 1.2 节的伪代码一一对应，调试时心智负担最小；等你要控制组件数量了，再改成或归并版本。

2.5 逐位链的实测细节

在游戏里把这条链跑通之后，有几个体感值得记下来。第一，比较电路的输出完全由输入决定，是纯组合逻辑，不涉及时钟，所以你可以把两个字节输入直接接到链上，输出的 1 位信号立刻稳定，不需要额外的时序控制。第二，级联意味着传播延迟会累加，8 级下来延迟比单个门大不少，如果这条链后面还接了一堆组合逻辑，又放在高频率时钟下用，就要留意整条路径的延迟能不能在一个时钟周期内走完。第三，逐位链的最大好处是可扩展：16 位比较，就是把这套单元再串 8 级；32 位，串 24 级，逻辑一个都不用改。

3. 加法器借位法：元件少，但有个必踩的坑

3.1 A − B = A + (~B) + 1 是怎么来的

8 位加法器只能做加法，怎么做减法？靠补码。这里提前用一下第 4 节会详细推导的结论：按位取反加一，等于取相反数。

~B = 255 - B （因为 B + ~B 恒等于 0xFF，即 255） ~B + 1 = 256 - B ≡ -B (mod 256) A + ~B + 1 = A - B (mod 256)

也就是说，把 B 的 8 个比特全部取反，再把最低位的进位输入cin拉成 1，加法器算出来的就是 A − B 在模 256 意义下的结果。这一步不需要额外理解什么新东西，就是把"取反加一"直接搬过来用。

3.2 进位输出代表什么：借位的反相

关键问题来了：加法器的输出里，哪一个信号能告诉我们 A 和 B 谁大？答案是最高位的进位输出cout，而且要反过来看。

设 A 和 B 都是 0 到 255 之间的数。我们算的是A + (256 - B)：

• 如果 A ≥ B，那么结果 ≥ 256，必然产生进位，cout = 1；
• 如果 A < B，那么 A − B ∈ [−255, −1]，加上 256 之后落在 [1, 255]，不到 256，cout = 0。

所以：

A < B ⟺ cout = 0 A ≥ B ⟺ cout = 1

最终输出就是less = NOT cout，一个非门搞定。这条线路的组件消耗非常低：8 个非门把 B 取反，一个现成的 8 位加法器，一个非门取反进位——比逐位链少了一大截。

3.3 忘记"加一"会错在哪：等于情况直接翻车

这是借位法最经典的坑，我在第一次实现时就踩了。假设你图省事，不接那个cin = 1，直接算A + ~B，会发生什么？

取 A = B = 5 试一试。~5 = 1111 1010 = 250，5 + 250 = 255，255 小于 256，没有进位，cout = 0。按照less = NOT cout的判据，你会得到"A < B"，但事实上 A 和 B 相等。

再看极端情况 A = B = 0：~0 = 255，0 + 255 = 255，同样cout = 0，又误判成 A < B。换言之，只要两个数相等，不加一就会全部误判为"小于"。

加上这个一，等于情况就对了：5 + 250 + 1 = 256，产生进位，cout = 1，判定"不小于"，正确。这个+1不只是形式上的补码要求，它实打实地承担了"把相等从小于里排除出去"的职责。

3.4 那个 1 从哪里来：cin 的三种接法

道理清楚了，工程上的问题还在：+1这个 1 接到哪？

如果你是自己用全加器级联搭的 8 位加法器，最低位全加器的cin引脚本来是接地（常量 0）的，那么直接把它改成常量 1 即可，最省事。如果加法器已经被你打包成了自定义组件、引脚封死在内部，那有三个可选做法：

• 在沙盒里另存一个"8位减法器"组件，内部结构照抄加法器，只把最低位的cin拉到 1，之后比较、减法都复用它；
• 放弃cin，改成先算A + ~B，再单独接一个"加一"的小电路（比如把最低位接一个半加器，或者用一个带进位的 8 位加法器把第二个操作数设成常数 1）；
• 直接搭 9 位加法器，多出来的那一位专门用来观察进位，避免进位信息在别处被吞掉——这种做法最稳但最费组件，一般用不上。

注意：如果你选了"另存减法器"这条路，记得把加法器和减法器命名区分清楚。我见过有人把两个组件混着用，测了半天发现是拿加法器当减法器测的。

3.5 两条路线怎么选：一张表说清

我的建议是：先把逐位链做一遍，因为它能让你彻底理解"高位优先"这件事；再用借位法做一遍，体会一下补码带来的组件数量红利。这两条路各自跑通之后，你对"比较"这个操作的理解会比单纯过关深一个层次。

4. 顺手把原码、反码、补码捋顺

4.1 原码：最符合直觉，但最难用

原码的思路最朴素：最高位当符号位，0 表示正、1 表示负，剩下的位存绝对值。−5 就是1000 0101（符号位 1 加上 5 的二进制）。人看着舒服，电路用起来难受，两个致命问题：

第一，零有两个表示。0000 0000是 +0，1000 0000是 −0，同一件事占用了两个编码，判断"是否为零"要多做一次比较。

第二，加减法不能统一。做5 + (−3)时，电路得先看两个符号位：同号做加法、异号做减法，还要比较绝对值谁大来决定结果符号。这意味着你得多做一套减法器、多一层判断逻辑，硬件开销成倍。

4.2 反码：取反就能表示负数，但还差一口气

反码的规则是：正数不变，负数把绝对值部分按位取反（符号位保持 1）。−5 的反码就是1111 1010。

这一步已经比原码进步了：至少"取反"这个操作可以用一排非门直接实现，不用查表。但两个老问题都没彻底解决：

• 零依然有两个表示：+0 是0000 0000，−0 是1111 1111；
• 加法需要循环进位：反码相加时，如果最高位产生进位，这个进位要绕回来加到最低位（end-around carry），电路上就得多一根回环线，控制起来很别扭。

4.3 补码：取反加一为什么成立

补码在反码的基础上再进一步：负数 = 反码 + 1。−5 的补码是1111 1011，也就是十进制的 251。

"取反加一"这四个字被念了太多次，但它的推导其实特别干净。设 x 是一个 8 位数：

x + ~x = 1111 1111 = 255 => ~x = 255 - x => ~x + 1 = 256 - x ≡ -x (mod 256)

因为 8 位运算天然是模 256 的运算（超过 255 就"绕回来"），所以~x + 1和−x在模 256 意义下完全等价。这不是什么约定俗成的技巧，而是模运算下的恒等式。"取反加一"之所以有效，是因为它恰好构造出了 256 的补数。

补码带来的三个好处：

• 零是唯一的：0000 0000表示 0，1111 1111（即 −1）不再是零，天然没有 −0 这个概念；
• 减法统一成加法：A − B直接算A + (~B) + 1，电路上不需要减法器，第 3 节已经用过了；
• 范围不对称：8 位补码能表示 −128 到 127，因为1000 0000被分配给 −128，没有对应的 +128。

顺便把"从补码求原码"的路径也说清：既然−x的补码是~x + 1，那么对补码再取反加一就回到原数。所以看到1111 1011想还原成十进制，先取反得0000 0100，加一得0000 0101，是 5，前面符号位是 1，所以是 −5。这套来回转换的路径在调试有符号比较电路时天天要用。

4.4 有符号比较的核心技巧：把最高位翻过来

现在进入真正有意思的部分。"有符号小于"这一关，如果照着无符号的思路硬做，会遇到一堆麻烦：负数在补码里是"看起来很大"的数值（比如 −1 是 255），逐位比较的结果全乱套。

但有一个极其优雅的技巧：把两个数的最高位都翻转，然后按无符号方式比较。

signed_less(A, B) = unsigned_less(A XOR 0x80, B XOR 0x80)

为什么？有符号数的顺序是：

-128, -127, ..., -2, -1, 0, 1, 2, ..., 126, 127

给每个数加上 128（在 8 位里，加 128 等价于翻转最高位），顺序变成：

0, 1, 2, ..., 126, 127, 128, 129, ..., 254, 255

正好就是从 0 到 255 的自然顺序。翻转最高位本质上是一次"顺序重排"，把有符号的序映射成无符号的序，然后用你已经搭好的无符号比较器就行了。

用表格验证几个关键点：

跨越零点、跨到极值、负数之间比较，三种情况都对。这个技巧在硬件里实现起来只需要 8 个异或门（其中 7 个可以省掉，只翻转最高位那一根线）。

4.5 另一条路：符号位异或溢出位

如果你执意要走"减法判符号"这条路线，会撞上一个陷阱：在有符号运算里，减法结果的符号位并不能直接反映大小关系，因为结果可能溢出。

举个例子：A = 127，B = −1。A − B = 128，超出 8 位有符号范围，结果变成1000 0000（即 −128），符号位是 1，看起来像"A < B"，但事实是 A > B。

正确的判据是符号位 SF 与溢出位 OF 的异或：

signed_less(A, B) ⟺ (SF XOR OF) = 1

其中溢出位OF可以用最高位的进位来判断：

OF = c7 XOR c8

c7是最高位全加器的进位输入，c8是它输出的进位。两个不相等就说明发生了有符号溢出。这套判据是通用处理器的标准做法，但在《图灵完备》里，用 4.4 节的翻转最高位技巧显然更省组件——多搭一条溢出判断链，纯粹是给自己找事。

5. 在游戏里调通比较器：我踩过的几个坑

5.1 先确认关卡要的是"小于"还是"小于等于"

这关的输出定义必须在动手前确认清楚。无符号小于是严格的<：A 和 B 相等时输出 0。而有些场景（比如判断"是否需要进位"）用的是<=，两者差一个非门。我在测试时出过一次乌龙：逐位链本身没问题，是关卡输出的定义我记错了，白调试半小时。

判断方法很简单：拿两个相等的输入试一次，看关卡提示要求的输出应该是什么。这一步花 10 秒钟，能省掉半小时。

5.2 字节内部的位序要看清楚

《图灵完备》里的字节输入通常按"低位在右、高位在左"排列，也就是 bit0 在最右边。级联比较链的时候，最左边的位（MSB）必须接第一个比较单元，依次往右传。如果你按直觉把最左边的位接到链条末尾，结果会系统性地出错，而且只在两个数的高位不同时才暴露，低位数相同的用例全是"通过"的假象。

我的做法是：先用两根线把最高位单独引出来，接到第一个单元，确认无误后再批量接剩下的位。

5.3 用穷举的思路设计测试用例

关卡自带的测试用例覆盖不全，我习惯自己过一遍关键样本。下面这张表是我每次做比较电路都会跑的清单：

这 10 个样本把"相等、相邻、跨界、极值"四类边界全盖住了。如果这 10 个都过，剩下 6 万多个组合基本不会出问题——因为比较电路是纯组合逻辑，没有状态残留，不存在"跑一会儿才出错"这种情况。

5.4 组件数量超限时，先压非门

有些关卡会对组件数量设上限，这时候优化顺序很重要。我的优先次序是：

1. 先去复用。把重复的 1 位比较单元打包成自定义组件，8 份实例共用一套定义，数量统计通常直接降下来；
2. 再压非门。逐位链里NOT a、NOT(a XOR b)各用一个非门，如果游戏里提供了带反相输出的门，或者能把a XOR b换成同或门，能省 8 个左右；
3. 最后考虑换方案。如果数量还是超，直接切到加法器借位法，那条路天生就省一半以上组件。

提示：不要在组件数量上死磕到牺牲可读性。电路搭得一团乱，后面改 16 位、32 位的时候会付出更大的代价。

5.5 组合逻辑的稳定性与"看起来像时序问题"的假象

比较电路本身不涉及时钟，但它经常被放进更大的系统里，和寄存器、时钟一起工作。这时候出现的"偶发错误"往往不是比较电路算错了，而是整条路径延迟太长，数据还没算完就被时钟采样走了。

排查方法是：把时钟调慢，看错误是否消失。如果消失，就是时序余量不够，需要在比较结果输出后加一级寄存器打拍，或者优化关键路径。这个经验在游戏后期搭 CPU 的时候特别有用，我在做跳转指令的条件判断时就是靠这个方法定位到问题的。

6. 这套比较逻辑还能迁移到哪

6.1 日期比较：年月日就是多级"高位优先"

"日期比较大小"是日常开发里的高频需求，它的逻辑和 8 位比较一模一样。年月日三个字段的权重依次递减，比较规则就是逐级向下：

先比年 → 年相同再比月 → 月相同再比日

发现没有？这就是 1.2 节那个状态机的翻版：eq_so_far在年是"是否同年"，然后传递到月、传递到日。如果再加上时分秒，就是六级级联，对应电路里的六级比较单元。很多人在写日期比较时习惯把所有字段转成一个时间戳再比大小，从结果上看是对的，但从原理上看，逐字段比较才是更本源的做法——时间戳只是把逐级比较的结果预先编码成了一个数值。

这也解释了为什么时间戳能这么设计：它本质上就是把多维的"高位优先"顺序编码成了一维的数值顺序，和补码把有符号顺序映射成无符号顺序是同一种思路。

6.2 字符串的字典序：字符就是"位"

字符串按字典序比较，同样是"从第一个字符开始比，遇到不相等的就定胜负"。C 语言里比较浮点数要用专门的判断方式，但字符串比较反而简单，因为它天然是逐元素的。这里的"元素"是字符的编码值，两个字符比大小就是两个数值比大小，本质上是同一套逻辑换了个容器。

有意思的是字符串比较里也有"提前终止"的概念——一旦某一位分出胜负，后面的字符完全不用看。这和电路里in_eq变成 0 之后低位直接透传，是同一个优化思路。

6.3 浮点数为什么不能直接按位比

浮点数是"符号 + 指数 + 尾数"的分段表示，不具备"高位权重比所有低位之和还大"这个性质。指数部分增加 1，数值直接翻倍，而尾数部分全部拉满也才接近 2 倍。所以浮点数的位序和数值序不对应，直接按位比较会得出完全错误的结果。

正确的做法是分情况处理：先看符号，两个都是正数时按"指数优先、尾数次之"比较，两个都是负数时结果要反过来，一正一负则正数大。这个流程和 4.4 节里"先把有符号序映射成无符号序"的思路是一致的——遇到表示形式和数值顺序不一致的情况，先做一次映射，再比较。

顺带一提，浮点数里还有个容易被忽略的问题：NaN和所有值比较都不相等，包括它自己。这也是"表示形式决定比较语义"的典型例子。

6.4 从 8 位扩到 16 位、32 位

游戏里的"16位无符号小于"关卡，其实就是把 8 位比较器当成一个单元再往上搭一层：

• 逐位链的方案，直接再串两个 8 位单元，把低 8 位的in_eq、in_less接到高 8 位对应输出上，逻辑一行不改；
• 借位法方案，需要 16 位加法器，或者把高 8 位和低 8 位分开算，低 8 位的进位输出接到高 8 位的cin上，再取最高位的进位取反。

两种扩展路径的共同点是分层复用：先把 8 位做扎实，再用它拼更大的。这也是《图灵完备》这款游戏真正想教的东西——从与非门开始，一层一层往上抽象，最后搭出一个能跑程序的处理器。8 位比较器只是这条路上的一小步，但"高位优先、一旦决定就锁死"这个思想，会一直跟着你走到指令译码、跳转判断、甚至操作系统的调度逻辑里。

提示：如果你打算继续往 CPU 方向搭，建议把比较器封装成带明确命名引脚（A、B、Less）的独立组件，后面写条件跳转指令时直接拖进来用，别再重搭一遍。

我个人的习惯是每做完一个组件就在沙盒里存一份，起个能一眼看懂的名字。因为等你搭到十几层抽象的时候，回头翻"这个模块到底是干嘛的"所花的时间，往往比重新搭一个还长。比较器这种基础件，值得在最开始就把它做干净。