项目一 Hog：掷骰游戏ok 267 项通过

0. 这份作业在练什么

Hog 是 CS 61A 的第一个项目。它的题面很长，规则读起来像一份桌游说明书，很容易让人以为「这是一道阅读理解题」。它确实需要认真读题——但真正被考的东西只有两样，而且这两样正好对应课程前四讲：

第一样是控制流（control flow）。Phase 1 的五道题（Problem 1–5）要求你把三条自然语言写的游戏规则，一字不差地翻译成 if、while 和 return。这里的难点不在语法，而在「翻译时不许偷工减料」：题面说「即使中途掷出 1 也要把骰子掷完」，你就不能在发现 1 之后立刻 return；题面说「分数可能超过 100」，你就不能用「除以 10 取余」这种只对两位数成立的写法。这门课的第一个真实教训是：一个只在你想到的输入上正确的程序，不叫正确的程序。

第二样是高阶函数（higher-order function）。Phase 2 的七道题（Problem 6–12）几乎每一道都在做同一件事的不同变奏：函数是值。

• 函数可以被当作参数传进去——play 收下两个策略函数和一个 update 函数；make_averaged 收下任意一个函数。
• 函数可以被当作返回值造出来——always_roll(5) 现场生产一个策略函数，make_averaged(roll_dice, 40) 现场生产一个「平均版 roll_dice」。
• 函数可以被当作数据去检验——is_always_roll 把一个策略当成研究对象，穷举它的所有可能输入，判断它是不是常函数。

把这两样放在一起，你就得到了这个项目真正的形状：先用普通的控制流把「一局游戏」写成一个函数 play，然后把这个函数当成一台实验设备，往里面塞不同的策略，用统计手段比较哪个策略更好。这是从「写代码」跨到「用代码做实验」的第一步。

做之前该掌握什么

如果你对「函数名和函数值的区别」还不踏实——即 six_sided 和 six_sided() 到底差在哪——那正好，Problem 0 就是专门为此设置的。

1. 热身：dice.py 与非纯函数（Problem 0）

题目要什么

Problem 0 不需要写任何代码，它只要求你解锁一组测试，确认你读懂了 dice.py。但它考的东西贯穿整个项目，跳过它你会在 Problem 1 和 Problem 9 上栽跟头。

dice.py 提供两类骰子。第一类是公平骰子（fair dice）：

def make_fair_dice(sides):
    """Return a die that returns 1 to SIDES with equal chance."""
    assert type(sides) == int and sides >= 1, 'Illegal value for sides'
    def dice():
        return randint(1,sides)
    return dice

four_sided = make_fair_dice(4)
six_sided = make_fair_dice(6)

第二类是测试骰子（test dice），它不随机，而是按给定序列循环：

def make_test_dice(*outcomes):
    """Return a die that cycles deterministically through OUTCOMES."""
    assert len(outcomes) > 0, 'You must supply outcomes to make_test_dice'
    for o in outcomes:
        assert type(o) == int and o >= 1, 'Outcome is not a positive integer'
    index = len(outcomes) - 1
    def dice():
        nonlocal index
        index = (index + 1) % len(outcomes)
        return outcomes[index]
    return dice

官方测试里的第一组题是：

>>> test_dice = make_test_dice(4, 1, 2)
>>> test_dice()
4
>>> test_dice() # Second call
1
>>> test_dice() # Third call
2
>>> test_dice() # Fourth call
4

为什么是这个输出

关键在 index 这个名字。make_test_dice(4, 1, 2) 被调用时，会创建一个属于 make_test_dice 的局部帧，帧里有 outcomes = (4, 1, 2) 和 index = 2（即 len(outcomes) - 1）。函数 dice 在这个帧里被 def 出来，所以它的父帧是这个帧，不是全局帧。make_test_dice 返回之后，它的帧并不消失——dice 还指着它。

全局帧 Global
    make_test_dice  -> func make_test_dice(*outcomes)
    test_dice       -> func dice()   [parent = f1]

f1: make_test_dice   [parent = Global]
    outcomes = (4, 1, 2)
    index    = 2      <- 这个数字会被后续每次调用改写

每次调用 test_dice()，都会开一个新的 dice 帧，但 nonlocal index 声明使得帧里的赋值不是在 dice 帧里新建一个 index，而是回到 f1 去改那个已有的 index。

为什么 index 的初值要写成 len(outcomes) - 1 而不是 0？因为自增写在返回之前。若初值为 0，第一次调用就会先变成 1，第一个返回的是 outcomes[1]——序列整体错位一格。把初值设成「最后一个下标」，加 1 取模后正好绕回 0，第一次调用返回第一个元素。这是一个很典型的「off-by-one 用初值补偿」技巧。

概念题：怎样才算「掷一次骰子」

解锁测试里的选择题（tests/00.py，答案已随本仓库解锁）：

为什么这件事重要

dice 是一个非纯函数（non-pure function）：同样的调用表达式 dice()，前后两次的返回值不同。用课程的说法，调用它会产生副作用（side effect）——它改掉了 index，从而改变了「下一次调用会返回什么」。

还有一点值得先记下：make_fair_dice 与 make_test_dice 是这个项目里第一批「返回函数的函数」。你在 Problem 6 和 Problem 8 要亲手写的东西，形状和它们一模一样。项目开头这份「读别人写的高阶函数」，其实是在给结尾的「自己写高阶函数」做示范。

2. Problem 1：roll_dice

题目要什么

实现 roll_dice(num_rolls, dice=six_sided)：掷 num_rolls 次骰子，返回这一回合得到的分数。规则只有一条例外——

Sow Sad. If any of the dice outcomes is a 1, the current player's score for the turn is 1, regardless of the other values rolled.

翻译成人话：把所有点数加起来；但只要出现过哪怕一个 1，整回合就只得 1 分，其他点数一概作废。

题面另外压了一条硬约束，它比规则本身更容易被忽略：

You should call dice() exactly num_rolls times in the body of roll_dice. Remember to call dice() exactly num_rolls times even if Sow Sad happens in the middle of rolling.

官方测试里有一条用例专门抓这一点，注释写得很直白：

>>> counted_dice = make_test_dice(4, 1, 2, 6)
>>> roll_dice(3, counted_dice)
1
>>> # Make sure you call dice exactly num_rolls times!
>>> # Note that a return statement within a loop ends the loop
>>> roll_dice(1, counted_dice)
6

边界情况清单：

怎么想到的

第一反应几乎所有人都一样：「边加边看，遇到 1 就直接返回 1」。写出来是这样：

# 这是错的，别抄
def roll_dice(num_rolls, dice=six_sided):
    total = 0
    k = 0
    while k < num_rolls:
        outcome = dice()
        if outcome == 1:
            return 1          # <-- 问题出在这里
        total = total + outcome
        k = k + 1
    return total

它对不对？就单次调用的返回值而言，完全正确。roll_dice(3, make_test_dice(4, 6, 1)) 照样返回 1。所以很多人写到这里跑了两个测试通过就走了，然后在上面那条 counted_dice 用例上翻车。

翻车的原因是 Problem 0 里说过的那件事：dice 是非纯函数，调用次数会改变世界的状态。return 1 会立刻结束整个函数，当然也就结束了循环——第 3 次的 dice() 根本没被调用。于是：

知道了病根，改法就清楚了：循环内不许 return，只许记账；结算放在循环之后。用一个布尔变量记住「这一回合到底有没有出现过 1」。

还有一个次要选择：既然一旦 Sow Sad 就返回 1，那 total 在这种情况下是多少根本无所谓。所以「发现 1 之后还继续累加」不是错误，只是没用。写成 total = total + outcome 不加判断，比写成「只在没 Sow Sad 时才累加」更短，也更少出错。

代码

def roll_dice(num_rolls, dice=six_sided):
    """Simulate rolling the DICE exactly NUM_ROLLS > 0 times. Return the sum of
    the outcomes unless any of the outcomes is 1. In that case, return 1.

    num_rolls:  The number of dice rolls that will be made.
    dice:       A function that simulates a single dice roll outcome. Defaults to the six sided dice.
    """
    # These assert statements ensure that num_rolls is a positive integer.
    assert type(num_rolls) == int, "num_rolls must be an integer."
    assert num_rolls > 0, "Must roll at least once."
    # BEGIN PROBLEM 1
    total = 0
    sow_sad = False  # True as soon as any roll comes up 1
    k = 0
    # Keep rolling even after a 1 appears, so the dice function is called
    # exactly num_rolls times (the test dice and the UI both rely on this).
    while k < num_rolls:
        outcome = dice()
        if outcome == 1:
            sow_sad = True
        total = total + outcome
        k = k + 1
    if sow_sad:
        return 1
    return total
    # END PROBLEM 1

逐行说明：

• total = 0：累加器的初值必须是 0，因为 0 是加法的单位元——「还没掷任何骰子时的总分」就是 0。
• sow_sad = False：这是一个标志变量（flag）。初值 False 表示「到目前为止还没见过 1」。它只会从 False 变成 True，绝不会反向变回去——这正是我们要的语义：只要出现过一次 1 就算数。
• k = 0 配合 while k < num_rolls：这是最朴素的计数循环。用 k 从 0 数到 num_rolls - 1，循环体恰好执行 num_rolls 次。（Lecture 3 之后你会想用 for k in range(num_rolls)，那也对；while 版本的好处是把「循环恰好跑几次」这件事摊开在眼前。）
• outcome = dice()：必须先存进变量再用。如果写成 if dice() == 1: ... total = total + dice()，那就调用了两次 dice()，一次掷骰变成了两次掷骰，整个测试全崩。这是本题第二常见的错误。
• if outcome == 1: sow_sad = True：注意这里没有 else。不需要写 else: sow_sad = False——那会把之前记住的 1 抹掉，等于只看最后一次掷的结果。
• total = total + outcome：无条件累加。Sow Sad 时这个和用不上，但也不碍事。
• k = k + 1：循环变量的推进。忘了写这一行就是死循环，表现为运行 ok 时程序卡住不动。
• 循环之后的 if sow_sad: return 1 / return total：唯一的两个出口，都在循环外面。这保证了「循环执行次数」与「返回什么值」这两件事被彻底解耦。

验证

手动追踪 roll_dice(4, make_test_dice(2, 2, 3))，doctest 期望 9。测试骰子按 2, 2, 3, 2, 2, 3, … 循环。

sow_sad 是 False，跳过第一个 return，执行 return total，得到 9。✓

再追一个带 Sow Sad 的：roll_dice(7, make_test_dice(2, 2, 2, 2, 2, 2, 1))，期望 1。前 6 轮各取到 2，total 累到 12，sow_sad 一直是 False；第 7 轮（k = 6）取到 1，sow_sad 变 True，total 变成 13。循环结束，sow_sad 为真，return 1。注意 total 最终是 13 这个值被完全丢弃了——这正是「先记账后结算」的样子。✓

最后验证那条最刁钻的连续调用用例，它同时检查返回值和骰子指针：

>>> dice = make_test_dice(5, 4, 3, 2, 1)
>>> roll_dice(1, dice)    # Roll 1 (5)
5
>>> roll_dice(4, dice)    # Reset (4, 3, 2, 1)
1
>>> roll_dice(2, dice)    # Roll 2 (5, 4)
9

第一次调用消耗掉 5；第二次调用消耗掉 4、3、2、1 —— 因为一次不落地掷完了 4 次，指针正好回到序列开头，第三次才能拿到 5 和 4 得到 9。如果第二次调用在遇到 1 时提前返回，那第二次只会消耗 4、3、2 三次（末尾的 1 还没掷到），第三次拿到的就是 1 和 5，返回 1 而不是 9。这条用例的设计非常精准：它用「下一次调用的返回值」来测量「上一次调用掷了几次骰子」。

3. Problem 2：boar_brawl

题目要什么

实现 boar_brawl(player_score, opponent_score)，返回玩家选择「掷 0 个骰子」时按 Boar Brawl 规则得到的分数。

Boar Brawl. A player who chooses to roll zero dice scores three times the absolute difference between the tens digit of the opponent's score and the ones digit of the current player's score, or 1, whichever is greater.

把这句英文拆成四步，就是这道题的全部：

注意第 1、2 步取的东西是交叉的：十位取对手的，个位取自己的。读题时看反了会得到一个到处差一点点的函数。题面还补了两条约束：

If a player's score is a single digit (less than 10), the tens digit of that player's score is 0.

Don't assume that scores are below 100. Write your boar_brawl function so that it works correctly for any non-negative score.

Important: Your implementation should not use str, lists, or contain square brackets [ ]. The test cases will check if those have been used.

最后这条不是建议，是会被机器检查的。tests/02.py 的最后一条用例长这样：

>>> boar_brawl(727, 939)
12
>>> # ban str and indexing (lists)
>>> test.check('hog.py', 'boar_brawl', ['Slice', 'List', 'ListComp', 'Index', 'Subscript', 'For'])
True

它会去解析你的源码语法树，一旦发现方括号取下标、列表、列表推导式或 for 循环就判失败。也就是说，「把数字转成字符串再取字符」这条路被彻底封死了。

怎么想到的

没学过位运算和取模技巧的人，第一反应通常是：

# 被明令禁止的写法
def boar_brawl(player_score, opponent_score):
    opponent_tens = int(str(opponent_score)[-2])   # 用了 str 和 [ ]
    ...

这个写法除了违规，本身还有两个 bug：分数是个位数（如 5）时 str(5)[-2] 直接 IndexError: string index out of range；而且它对负下标的理解要非常小心。既然被禁，就得回到算术。

取个位很容易，几乎人人都知道：n % 10。因为 n = 10 * q + r，余数 r 就是个位。

取十位呢？自然的想法是「先把个位切掉，再取新的个位」。「切掉个位」就是整除 10：n // 10。于是十位是 (n // 10) % 10。

但很多人会写成 n // 10 就收手。对不对？对两位数是对的，对三位数就错了。比如 n = 115：115 // 10 = 11，而十位应该是 1。缺的正是外面那层 % 10——它把「十位以上的所有位」再截掉。这就是题面反复强调「Don't assume that scores are below 100」的原因，官方测试也确实给了 boar_brawl(82, 115)、boar_brawl(99, 121)、boar_brawl(109, 99) 这三条专门打脸的用例。

再看「个位数分数的十位是 0」这条特殊说明。需要写一个 if score < 10: tens = 0 吗？不需要——公式已经自动满足它了：(5 // 10) % 10 = 0 % 10 = 0。题面特意点出的「特殊情况」，在正确的实现下往往根本不特殊。这是判断自己写法是否自然的一个好信号：如果你为它写了 if，多半说明主路径的写法不够干净。

最后是「or 1, whichever is greater」。两种写法都行：

points = 3 * abs(opponent_tens - player_ones)
if points < 1:
    return 1
return points

或者直接用内置的 max。后者短且更贴近题面的措辞——题面说的就是「取较大者」。

代码

def boar_brawl(player_score, opponent_score):
    """Return the points scored when the current player rolls 0 dice according to Boar Brawl.

    player_score:     The total score of the current player.
    opponent_score:   The total score of the other player.

    """
    # BEGIN PROBLEM 2
    # Digits are extracted with arithmetic only (no str / indexing allowed).
    opponent_tens = (opponent_score // 10) % 10
    player_ones = player_score % 10
    return max(3 * abs(opponent_tens - player_ones), 1)
    # END PROBLEM 2

逐行说明：

• opponent_tens = (opponent_score // 10) % 10：opponent 的十位。// 10 把个位丢掉，% 10 把百位及以上丢掉。两个括号不能省：opponent_score // 10 % 10 虽然因为 // 和 % 同优先级、从左到右结合而恰好等价，但写上括号能让「先整除后取余」的意图一眼可见。
• player_ones = player_score % 10：player 的个位。这里不需要 //，因为个位本来就在最右边。
• 把两个中间量各取一个名字，而不是塞进一个大表达式里，是有意为之：这两个名字直接对应题面里的 "the tens digit of the opponent's score" 和 "the ones digit of the current player's score"。名字是防止读反题目的最好办法。
• abs(...)：题面说的是 absolute difference。少了它，当自己的个位比对手的十位大时会算出负数，最后被 max(..., 1) 一律压成 1，症状是「有时候莫名其妙只得 1 分」。
• 3 * ...：题面的 "three times"。
• max(..., 1)：实现 "or 1, whichever is greater"。它同时兜住了差为 0 的情况（题面 Example 2）。
• 整个函数只有三行、没有循环、没有分支。当题面描述里有一堆「如果……那么……」而你的代码里一个 if 都不需要时，通常说明你找对了表达方式。

验证

逐条追踪官方用例，看每一步取到的数字：

特别看 boar_brawl(82, 115) 这一行：如果十位写成 opponent_score // 10，会得到 11，算出 3 * abs(11 - 2) = 27，而正确答案是 3。这一条用例的存在就是为了区分「写了外层 % 10」和「没写」的两种实现。

再看 boar_brawl(5, 0) 与 boar_brawl(0, 5) 这一对：参数只是交换了位置，结果一个是 15 一个是 1。如果你把十位和个位取反了，这两条用例的答案会正好互换——这是检查自己有没有读反题的最快办法。

4. Problem 3：take_turn

题目要什么

实现 take_turn(num_rolls, player_score, opponent_score, dice=six_sided)：返回玩家这一回合得到的分数（不是新的总分）。题面只有两句要求：

Implement the take_turn function, which returns the number of points scored for a turn by rolling the given dice num_rolls times.

Your implementation of take_turn should call both the roll_dice and boar_brawl functions rather than repeating their implementations.

逻辑其实前两题已经写完了，这道题要做的只是把两条规则接起来：掷 0 个骰子走 Boar Brawl，掷 1 个以上走 Sow Sad 求和。函数顶部的 assert 已经把合法范围划好了：

assert type(num_rolls) == int, "num_rolls must be an integer."
assert num_rolls >= 0, "Cannot roll a negative number of dice in take_turn."
assert num_rolls <= 10, "Cannot roll more than 10 dice."

对比 roll_dice 里的 assert num_rolls > 0：take_turn 允许 0，roll_dice 不允许。这个差别不是随意的，它正是本题的全部内容——0 这个值必须在到达 roll_dice 之前就被拦下来，否则会撞上断言错误 AssertionError: Must roll at least once.。

边界情况：

注意后两条根本没传 dice 参数——因为掷 0 个骰子时压根不需要骰子。这也从侧面说明了：Boar Brawl 分支里绝对不能调用 dice()。

怎么想到的

这道题的「想」不在算法，在抽象的边界该划在哪。

一个很自然但错误的冲动是：既然 roll_dice 已经会掷骰子了，那 take_turn 干脆把 Boar Brawl 的算式也抄进来算了，反正就三行。为什么不行？

• 规则一改就要改两处。假如助教把 Boar Brawl 从「乘 3」改成「乘 4」，你得同时改 boar_brawl 和 take_turn，漏一处就是 bug。
• Problem 10 会直接调用 boar_brawl。如果逻辑被复制到两个地方，两处将来一定会不一致。
• 官方会检查你有没有真的调用 roll_dice。tests/03.py 的第二个 suite 玩了一个很有意思的把戏：

>>> import hog
>>> def roll_dice(num_rolls, dice):
...     print("Called roll dice!")
...     return 9002
...
>>> hog.roll_dice, old_roll_dice = roll_dice, hog.roll_dice
>>> hog.take_turn(5, 0, 0) # Make sure you call roll_dice!
Called roll dice!
9002

它把 hog 模块里的 roll_dice 这个名字重新绑定到一个假函数上，然后调用 take_turn。如果你的 take_turn 真的是通过 roll_dice 这个名字去查找函数的，它就会调到假货，打印出 "Called roll dice!" 并返回 9002。如果你把求和逻辑抄进了 take_turn，这条测试会失败。

确定了要调用两个已有函数之后，剩下的只是选择分支写法。两种都可以：

# 写法 A：早返回
if num_rolls == 0:
    return boar_brawl(player_score, opponent_score)
return roll_dice(num_rolls, dice)

# 写法 B：if/else 对称
if num_rolls == 0:
    return boar_brawl(player_score, opponent_score)
else:
    return roll_dice(num_rolls, dice)

两者行为完全一致。写法 A 少一层缩进，且强调了「0 是需要特殊处理的例外情况，处理掉就走主路径」这个含义。

代码

def take_turn(num_rolls, player_score, opponent_score, dice=six_sided):
    """Return the points scored on a turn rolling NUM_ROLLS dice when the
    current player has PLAYER_SCORE points and the opponent has OPPONENT_SCORE points.

    num_rolls:       The number of dice rolls that will be made.
    player_score:    The total score of the current player.
    opponent_score:  The total score of the other player.
    dice:            A function that simulates a single dice roll outcome.
    """
    # Leave these assert statements here; they help check for errors.
    assert type(num_rolls) == int, "num_rolls must be an integer."
    assert num_rolls >= 0, "Cannot roll a negative number of dice in take_turn."
    assert num_rolls <= 10, "Cannot roll more than 10 dice."
    # BEGIN PROBLEM 3
    if num_rolls == 0:
        return boar_brawl(player_score, opponent_score)
    return roll_dice(num_rolls, dice)
    # END PROBLEM 3

逐行说明：

• if num_rolls == 0：唯一的判断。用 == 0 而不是 < 1 或 not num_rolls——前者精确表达题意，后者虽然等价但把「数值 0」和「假值」混为一谈，可读性差。
• return boar_brawl(player_score, opponent_score)：参数顺序是「先自己后对手」，和 boar_brawl 的形参顺序一致。这里传反了不会报错——两个参数都是整数，Python 照单全收——只会算出错误的分数。take_turn(0, 12, 41) 传反后会得到 3*abs(1-1) = 0 → max(0,1) = 1 而不是 6。
• return roll_dice(num_rolls, dice)：把 dice 原样往下传。这一步很容易漏：如果写成 return roll_dice(num_rolls)，那么 roll_dice 会用自己的默认参数 six_sided，测试传进来的测试骰子被无声地忽略掉，结果变成真随机——症状是「测试结果每次都不一样，而且都不对」。
• 返回的是本回合得分，不是总分。simple_update 里那句 score = player_score + take_turn(...) 说明了这个约定：加总分是 update 函数的责任，不是 take_turn 的。

验证

追踪 take_turn(0, 37, 15)，doctest 期望 18。

再追一个走另一条路的：take_turn(2, 7, 27, make_test_dice(4, 5, 1))，期望 9。num_rolls 是 2，不等于 0，于是调用 roll_dice(2, dice)。roll_dice 里循环两次，取到 4 和 5，sow_sad 保持 False，返回 9。注意 player_score = 7 和 opponent_score = 27 这两个参数在这条路径上完全没被用到——掷骰子时双方的分数是无关的。这解释了一个初学者常有的困惑：「为什么 take_turn 要收下两个用不上的参数？」因为它可能用得上（num_rolls == 0 时就用上了），函数签名必须覆盖所有分支的需要。

还可以观察一个有意思的现象：take_turn(0, ...) 的返回值是确定的，完全由两个分数决定，没有任何随机性。这一点会在 Problem 10 和 11 里被策略函数利用——策略可以在真正掷骰之前，先算出「如果掷 0 个能得多少分」，再决定要不要这么做。掷骰子的结果没法预知，但 Boar Brawl 的结果可以。

5. Problem 4：num_factors、sus_points 与 sus_update

题目要什么

这一题一次要写三个函数，它们层层叠上去：

规则是：

Sus Fuss. We call a number sus if it has exactly 3 or 4 factors, including 1 and the number itself. If, after rolling, the current player's score is a sus number, their score instantly increases to the closest prime number greater than their current score.

三个要点必须抠准：

题面给的三个例子正好覆盖了「触发 / 不触发（因数太多）/ 不触发（因数太少）」：

官方另外给的关键用例：sus_points(1) 返回 1（1 只有一个因数）、sus_points(100) 返回 100（100 有 9 个因数）、sus_points(86) 返回 89（86 = 1·2·43·86 共 4 个因数，往上找质数：87 = 3×29 不是，88 不是，89 是）。

怎么想到的

num_factors：把定义直接翻译成循环

「n 有几个因数」这个问题，定义本身就是算法：从 1 数到 n，每个数试一下能不能整除 n，能就计数加一。没有任何技巧。

确实有更快的写法——只需要枚举到 sqrt(n)，每找到一个因数 k 就同时记下 n // k。但这需要处理「完全平方数时 k 和 n // k 重复」的边界，而项目里 n 最多也就一两百，朴素写法完全够用。在还没被效率逼到墙角之前，选那个「一眼就能看出正确」的写法。（真正需要关心增长阶的时候会到来——那是 HW 5 的内容。）

唯一要小心的是循环边界：必须写 while k <= n，不是 k < n。因为 n 本身也是自己的因数。写成 < 会让每个数的因数个数都少 1，于是「4 个因数」的数被误判成「3 个」——恰好还是落在 sus 范围里，所以 sus_points 可能碰巧还对，但 num_factors(1) 会返回 0 而不是 1，num_factors(2) 返回 1 而不是 2。官方专门给了 num_factors(1) 这条用例来抓它。

sus_points：先判定，再往上找

拆成两个独立的问题：

第 2 步为什么从 score + 1 而不是 score 开始？因为题面说 "the closest prime number greater than their current score"。这里有个微妙之处值得想一想：如果从 score 开始会怎样？会不会出现「score 本身就是质数，于是原地不动」的情况？不会——因为能进到这个分支的数一定有 3 或 4 个因数，而质数只有 2 个因数，二者互斥。所以即使写成从 score 开始，结果也碰巧一样。但这属于「碰巧对」，不是「按题意对」，还是照题面写 score + 1 更稳妥。

这个「往上找」的循环会不会永远找不到而死循环？不会——质数有无穷多个，欧几里得两千年前就证明了。任何有限的起点往上走，总会撞到质数。

sus_update：抄 simple_update 再加一层

题面直接给了提示：

You can look at the implementation of simple_update provided in hog.py and use that as a starting point for your sus_update function.

Recall that take_turn already took the Boar Brawl rule into consideration!

simple_update 是现成的：

def simple_update(num_rolls, player_score, opponent_score, dice=six_sided):
    """Return the total score of a player who starts their turn with
    PLAYER_SCORE and then rolls NUM_ROLLS DICE, ignoring Sus Fuss.
    """
    score = player_score + take_turn(num_rolls, player_score, opponent_score, dice)
    return score

那 sus_update 就是同一句话，只是最后 return sus_points(score) 而不是 return score。第二条提示则提醒你不要重复劳动：Sow Sad 和 Boar Brawl 已经在 take_turn 里处理完了，sus_update 只需要在上面加 Sus Fuss 这最后一层。

顺序绝对不能颠倒。必须是「先算完这回合的总分，再对总分做 Sus Fuss 判定」。如果你写成 player_score + sus_points(take_turn(...))，那就是拿回合得分去判 sus，完全是另一个游戏。举例：sus_update(0, 15, 37) 的回合得分是 6，而 6 的因数是 1、2、3、6 共 4 个，sus_points(6) 会把它顶到 7，最后算出 15 + 7 = 22，而正确答案是 23。这种错误产生的数字看起来「差不多对」，最难查。

代码

先看题目提供的、不用改的 is_prime：

def is_prime(n):
    """Return whether N is prime."""
    if n == 1:
        return False
    k = 2
    while k < n:
        if n % k == 0:
            return False
        k += 1
    return True

它单独把 1 挑出来判 False（1 不是质数），然后用 2 到 n−1 逐个试除。注意 n = 2 时循环一次都不执行，直接返回 True——这正好是对的。

我们要写的三个函数：

def num_factors(n):
    """Return the number of factors of N, including 1 and N itself."""
    # BEGIN PROBLEM 4
    count = 0
    k = 1
    while k <= n:
        if n % k == 0:
            count = count + 1
        k = k + 1
    return count
    # END PROBLEM 4


def sus_points(score):
    """Return the new score of a player taking into account the Sus Fuss rule."""
    # BEGIN PROBLEM 4
    # A score is "sus" when it has exactly 3 or 4 factors.
    factors = num_factors(score)
    if factors == 3 or factors == 4:
        # Jump up to the smallest prime strictly greater than the score.
        next_score = score + 1
        while not is_prime(next_score):
            next_score = next_score + 1
        return next_score
    return score
    # END PROBLEM 4


def sus_update(num_rolls, player_score, opponent_score, dice=six_sided):
    """Return the total score of a player who starts their turn with
    PLAYER_SCORE and then rolls NUM_ROLLS DICE, *including* Sus Fuss.
    """
    # BEGIN PROBLEM 4
    # take_turn already handles Sow Sad and Boar Brawl; Sus Fuss applies after.
    score = player_score + take_turn(num_rolls, player_score, opponent_score, dice)
    return sus_points(score)
    # END PROBLEM 4

逐行说明：

• num_factors 里 k 从 1 起（不是 2），因为 1 是因数；while k <= n 用 <=（不是 <），因为 n 也是因数。这两个边界都写对，num_factors(1) 才会返回 1。
• if n % k == 0：整除判定。n % k 是余数，为 0 就说明 k 整除 n。
• factors = num_factors(score)：只调用一次并存起来。如果写成 if num_factors(score) == 3 or num_factors(score) == 4，同样的循环会被跑两遍。这在这道题里只是浪费，但养成「结果存变量」的习惯，在 Problem 11 里会救你一命——那里被调用的函数是有副作用的。
• factors == 3 or factors == 4：不能写成 3 <= factors <= 4 之外的任何近似形式。特别不能写成 factors == 3 or 4——这在 Python 里合法但意思完全不同：or 的左边 factors == 3 若为假，整个表达式的值就是 4，而 4 是真值，于是所有分数都会被判成 sus。这是 Python 初学者最经典的陷阱之一，而且不报错。
• next_score = score + 1：搜索起点，严格大于当前分数。
• while not is_prime(next_score)：只要还不是质数就继续加 1。退出时 next_score 就是答案。
• return next_score 在 if 内部，return score 在外部：不是 sus 的分数原样返回。题面强调「even if the score remains unchanged」——这个函数总要返回一个分数，不能在非 sus 时什么都不返回（那会隐式返回 None，后面 None < goal 会报 TypeError）。
• sus_update 里 score = player_score + take_turn(...)：先得到新总分。
• return sus_points(score)：再对新总分应用 Sus Fuss。这两步的顺序就是这道题的全部。

验证

追踪官方用例 sus_update(0, 15, 37)，期望 23；同一组还给了 simple_update(0, 15, 37) 期望 21，正好可以对照。

再追一个不触发的：sus_update(2, 5, 7, make_test_dice(2, 4))，期望 11。take_turn(2, 5, 7, dice) → roll_dice(2, dice) 取到 2 和 4，和为 6。score = 5 + 6 = 11。num_factors(11)：11 是质数，因数只有 1 和 11，共 2 个。2 不在 {3, 4} 里，sus_points 直接 return score。答案 11，和 simple_update 一致。✓

还有一条很有教育意义的：sus_points(64) 期望 64。64 = 2⁶，因数是 1、2、4、8、16、32、64 共 7 个。7 不是 3 也不是 4，不触发。这条用例专治「以为因数多就一定 sus」的误解——sus 的定义是恰好 3 或 4 个，是一个很窄的区间。

6. Problem 5：play

题目要什么

把前面四道题拼成一局完整的游戏。play 的签名很长，但每个参数的含义都很干净：

def play(strategy0, strategy1, update, score0=0, score1=0, dice=six_sided, goal=GOAL):

行为要求：两位玩家从 Player 0 开始轮流行动，直到某一方的分数达到或超过 goal，然后返回 (score0, score1) 这个二元组。题面还压了一条硬要求：

Important: For the user interface to work, a strategy function should be called only once per turn. Only call strategy0 when it is Player 0's turn and only call strategy1 when it is Player 1's turn.

这条要求和 Problem 1 的「恰好掷 num_rolls 次」是同一类约束：策略函数可能是非纯的（hog_ui.py 里的 printing_strategy 会打印，interactive_strategy 会等用户输入），多调一次就多打印一行、多要一次输入。

四道概念题

tests/05.py 的第一个 suite 是四道选择题。它们不是走过场——每一道都对应一个具体的实现陷阱。

((y % 10) * (x % 10)) % 10
= ((22 % 10) * (55 % 10)) % 10
= (2 * 5) % 10
= 10 % 10
= 0

怎么想到的

先把要素列清楚，会发现 play 需要维护三样状态：两个分数，加上「现在轮到谁」。前两个已经是参数了，第三个需要一个新变量——起手代码里已经给好了：

who = 0  # Who is about to take a turn, 0 (first) or 1 (second)

然后是循环骨架。循环条件由概念题 1 定下：while score0 < goal and score1 < goal。循环体做四件事：

第 4 步的换人，题面给了个漂亮的提示：who = 1 - who。因为 1 - 0 = 1，1 - 1 = 0，一个算术式就实现了在两个值之间来回切换，比 if who == 0: who = 1 else: who = 0 短得多。这个技巧在任何「两方轮流」的场景里都能用。

剩下的问题是：怎么处理「当前玩家是谁」带来的分支？两个玩家的代码结构完全一样，只是变量名和参数顺序对调。有人会想写得更「聪明」，比如把两个分数放进一个列表用 who 做下标——但这道题在课程的第 4 讲，列表还没教，而且那样做反而会让参数顺序更难看清。老老实实写一个 if/else，两个分支各四行，是最好的选择。

# 错的
num_rolls0 = strategy0(score0, score1)
num_rolls1 = strategy1(score1, score0)
if who == 0:
    score0 = update(num_rolls0, score0, score1, dice)
else:
    score1 = update(num_rolls1, score1, score0, dice)

代码

def play(strategy0, strategy1, update, score0=0, score1=0, dice=six_sided, goal=GOAL):
    """Simulate a game and return the final scores of both players, with
    Player 0's score first and Player 1's score second.

    E.g., play(always_roll_5, always_roll_5, sus_update) simulates a game in
    which both players always choose to roll 5 dice on every turn and the Sus
    Fuss rule is in effect.

    A strategy function, such as always_roll_5, takes the current player's
    score and their opponent's score and returns the number of dice the current
    player chooses to roll.

    An update function, such as sus_update or simple_update, takes the number
    of dice to roll, the current player's score, the opponent's score, and the
    dice function used to simulate rolling dice. It returns the updated score
    of the current player after they take their turn.

    strategy0: The strategy for player0.
    strategy1: The strategy for player1.
    update:    The update function (used for both players).
    score0:    Starting score for Player 0
    score1:    Starting score for Player 1
    dice:      A function of zero arguments that simulates a dice roll.
    goal:      The game ends and someone wins when this score is reached.
    """
    who = 0  # Who is about to take a turn, 0 (first) or 1 (second)
    # BEGIN PROBLEM 5
    while score0 < goal and score1 < goal:
        if who == 0:
            # Ask the current player's strategy exactly once per turn.
            num_rolls = strategy0(score0, score1)
            score0 = update(num_rolls, score0, score1, dice)
        else:
            num_rolls = strategy1(score1, score0)
            score1 = update(num_rolls, score1, score0, dice)
        who = 1 - who  # Hand the turn to the other player.
    # END PROBLEM 5
    return score0, score1

逐行说明：

• while score0 < goal and score1 < goal：and 而不是 or（见概念题 1）。用 < goal 而不是 <= goal，因为题面说的是「达到或超过 goal 就结束」，所以「继续」的条件是严格小于。
• if who == 0: / else:：两个对称的分支。who 只可能是 0 或 1，所以 else 就是 Player 1。
• num_rolls = strategy0(score0, score1)：Player 0 视角，自己在前。结果存进变量再用——这不只是风格问题，它保证了策略函数恰好被调用一次。如果写成 score0 = update(strategy0(score0, score1), score0, score1, dice)，虽然也只调了一次，但可读性差，而且很容易在改代码时不小心变成两次。
• score0 = update(num_rolls, score0, score1, dice)：赋值给 score0。update 返回的是新总分（不是增量），所以是直接覆盖，不是 score0 += ...。写成 += 会让分数以平方级别爆炸。
• Player 1 分支的两行，两处参数顺序都要反过来：strategy1(score1, score0) 和 update(num_rolls, score1, score0, dice)。前者见概念题 3；后者同理，update 的第二个形参叫 player_score，对 Player 1 来说就是 score1。
• dice 必须原样传下去。漏了会静默改用默认的真随机六面骰，所有确定性测试全挂。
• who = 1 - who 放在 if/else 外面，缩进与 if 齐平。放进任一分支里就只有一个玩家会换手，导致同一个人一直行动。
• return score0, score1 在循环外面。放进循环里会让游戏只跑一回合就返回。返回的是一个元组（tuple），Python 的 a, b = play(...) 可以直接拆包。

验证

手动跑一局。为了能笔算，用固定骰子：play(always_roll_5, always_roll_5, simple_update, dice=make_test_dice(3), goal=20)。这个骰子永远返回 3，两个玩家都固定掷 5 个。

实际运行 python3 -i hog.py 验证，输出正是 (30, 15)。注意第 3 回合结束时 who 仍然会被翻成 1，但循环条件已经不成立，Player 1 没有「补一回合」的机会——先到线者立刻终止游戏，这正是题面要的行为。

把 update 换成 sus_update，同样的骰子和 goal，结果会变成 (32, 17)。为什么？

这个对照很能说明 play 的设计价值：游戏主循环一个字都没改，只是换了一个传进来的 update 函数，规则集就整个变了。这就是把函数当参数的威力——play 不知道也不需要知道 Sus Fuss 是什么，它只负责「轮流、更新、判胜负」这个骨架。同一个 play 之后还会被 hog_ui.py 拿去做打印版、被 hog_gui.py 拿去做图形版、被 winner 拿去做策略对战实验。

7. Problem 6：always_roll

题目要什么

Implement always_roll, a higher-order function that takes a number of dice n and returns a strategy function that always rolls n dice. Thus, always_roll(5) would be equivalent to always_roll_5.

注意这句话里出现了两个函数：always_roll 本身，和它造出来的那个策略函数。docstring 的 doctest 把这个两步过程写得很清楚：

>>> strategy = always_roll(3)
>>> strategy(0, 0)
3
>>> strategy(99, 99)
3

第一行调用 always_roll，得到的不是数字，是函数；第二、三行才是调用那个函数。测试里也有紧凑写法 always_roll(3)(10, 20)——两对括号，两次调用，从左到右依次发生。

参照物已经写在 hog.py 里：

def always_roll_5(score, opponent_score):
    """A strategy of always rolling 5 dice, regardless of the player's score or
    the opponent's score.
    """
    return 5

我们要做的，就是把这个函数里写死的 5 变成可配置的 n——但不是通过给它加一个参数（那会破坏策略函数「必须恰好收两个参数」的约定），而是通过造一个工厂。

怎么想到的

这里的思维卡点非常具体：策略函数的签名被 play 锁死了。play 里写的是 strategy0(score0, score1)，两个参数，不多不少。所以「掷几个」这个信息不可能作为第三个参数传进来。

那 n 从哪来？三个候选答案，前两个都不行：

第三个方案就是 Lecture 3 讲的环境模型给出的答案：函数被 def 出来时，会记住「自己是在哪个帧里被定义的」（这个帧成为它的父帧）。以后在它体内查找一个名字，先看自己的局部帧，找不到就去父帧找，再找不到去父帧的父帧……直到全局帧。

n 是 always_roll 的形参，住在 always_roll 的帧里。strategy 的父帧正是这个帧，所以 strategy 体内写 return n 能找到它。

代码

def always_roll(n):
    """Return a player strategy that always rolls N dice.

    A player strategy is a function that takes two total scores as arguments
    (the current player's score, and the opponent's score), and returns a
    number of dice that the current player will roll this turn.

    >>> strategy = always_roll(3)
    >>> strategy(0, 0)
    3
    >>> strategy(99, 99)
    3
    """
    assert n >= 0 and n <= 10

    # BEGIN PROBLEM 6
    def strategy(score, opponent_score):
        return n  # n is looked up in the enclosing always_roll frame

    return strategy
    # END PROBLEM 6

逐行说明：

• def strategy(score, opponent_score):：形参名字叫什么无所谓（叫 a, b 也能过测试），但个数必须是 2，因为 play 会传两个进来。这两个参数在函数体里一次都没被用到——这是完全正常的：always_roll 造出来的策略就是「无论比分如何都掷 n 个」，它必须接受这两个参数只是为了满足接口约定。
• return n：注意不是 return score，也不是 return 5。n 在这个函数的局部帧里找不到，Python 于是去它的父帧（always_roll 的帧）里找，找到了。
• return strategy：没有括号。这是整道题唯一真正的语法陷阱。写成 return strategy() 会立刻调用它——但此时没有传参，报 TypeError: strategy() missing 2 required positional arguments: 'score' and 'opponent_score'。always_roll 要返回的是「函数这个东西本身」，不是「调用它的结果」。
• return strategy 的缩进：与 def strategy 齐平，在 always_roll 的函数体里，不在 strategy 里面。多缩进一级的话，always_roll 就没有 return 了，返回 None。
• assert n >= 0 and n <= 10 是题目给的，注意它在造策略的时候就检查，而不是在策略被调用的时候。这是个不错的设计：错误尽早暴露。

验证

用环境图追踪 strategy = always_roll(3) 然后 strategy(0, 0)。

全局帧 Global
    always_roll -> func always_roll(n)          [parent = Global]
    strategy    -> func strategy(score, opponent_score)  [parent = f1]

f1: always_roll   [parent = Global]
    n        = 3
    strategy -> func strategy(score, opponent_score)  [parent = f1]
    返回值    -> 上面那个函数对象

f2: strategy      [parent = f1]        <- 调用 strategy(0, 0) 时创建
    score          = 0
    opponent_score = 0
    执行 return n：f2 里没有 n
                 -> 去父帧 f1 找：n = 3 ✓
    返回值    = 3

关键在第 4 帧（f2）里的那条查找路径。strategy 的父帧是 f1，不是 Global——这正是它能记住 n = 3 的原因。如果 strategy 是在全局帧里定义的（比如你把它写在 always_roll 外面），那 return n 会去 Global 找 n，找不到就报 NameError: name 'n' is not defined。

再看为什么两个不同的策略互不干扰：

>>> three = always_roll(3)
>>> six = always_roll(6)
>>> three(50, 50)
3
>>> six(50, 50)
6

两次调用 always_roll 创建了两个不同的帧，一个里面 n = 3，另一个里面 n = 6。three 和 six 各自指向不同的父帧，所以查到的 n 不同。这正是「用全局变量」方案做不到的事——全局只有一份，两个策略会打架。

最后验证官方测试的两条：always_roll(3)(10, 20) —— 先调 always_roll(3) 造出策略，再立刻用 (10, 20) 调它，返回 3 ✓。always_roll(0)(99, 99) —— n = 0 通过 assert（0 >= 0 成立），返回 0 ✓。返回 0 是合法的：它表示「这个策略永远选择 Boar Brawl」。

8. Problem 7：is_always_roll

题目要什么

Implement is_always_roll, which takes a strategy and returns whether that strategy always rolls the same number of dice for every possible argument combination, where each score is up to goal points.

换句话说：给你一个策略函数，判断它是不是常函数（constant function）。

>>> is_always_roll(always_roll_5)
True
>>> is_always_roll(always_roll(3))
True
>>> is_always_roll(catch_up)
False

「every possible argument combination」的范围由题面精确划定：

in a game with a goal of 100, there are only 100 possible score values (0-99) and 100 possible opponent_score values (0-99), resulting in 10,000 possible argument combinations

Reminder: The game continues until one player reaches goal points. Ensure your solution considers every possible combination of score and opponent_score for the specified goal.

为什么上限是 goal - 1 而不是 goal？因为一旦有人达到 goal，游戏就结束了，策略函数不会再被调用。分数为 goal 的局面在真实游戏里不存在，不需要检查。所以两层循环都是 0 到 goal - 1，共 goal² 个组合。

关键边界：goal 不一定是 100。官方测试里有一条明晃晃写着注释的用例：

>>> def s(x, y):
...    if x == 150 and y == 125:
...        return 0
...    else:
...        return 1
>>> is_always_roll(s, 200) # GOAL is not always 100!
False

如果你把上限写死成 100，这条测试会返回 True（因为 150 和 125 都超出了你的检查范围），直接挂掉。

怎么想到的

这道题的形状是「穷举验证一个全称命题」：命题是「对所有 (score, opponent_score)，策略返回同一个值」。

验证全称命题只有一条通用路子：逐个检查，一旦找到反例立刻宣告为假；全部查完没找到反例，才宣告为真。这个「找反例」的结构决定了代码的骨架——

基准值取哪个？strategy(0, 0) 是最自然的选择——它一定在遍历范围内（因为 goal > 0）。也可以不预先取基准，改成「记住第一次见到的返回值」，但那要多一个「是不是第一次」的标志变量，不如直接调一次 strategy(0, 0) 干脆。

接下来是「双层循环怎么写」。两个变量各自从 0 走到 goal - 1，用 while 写就是嵌套的两个计数循环。这里有一个每次都会被踩的坑：内层循环变量的重置必须放在外层循环体的开头。如果把 opponent_score = 0 写在两个循环之外，那么外层第二次迭代时 opponent_score 已经是 goal 了，内层循环一次都不会执行——结果只检查了 score = 0 那一行的 100 个组合。

顺带说一句效率：这个函数会调用策略 10001 次（1 次基准 + 10000 次遍历）。对本项目这个规模完全无所谓，一秒都不到。但值得注意的是，如果传进来的策略是非纯的（比如会打印、会掷骰子），这一万次调用会产生一万次副作用——这也是为什么策略函数应该被写成纯函数。

代码

def is_always_roll(strategy, goal=GOAL):
    """Return whether STRATEGY always chooses the same number of dice to roll
    for every possible combination of score and opponent_score
    given a game that goes to GOAL points.

    >>> is_always_roll(always_roll_5)
    True
    >>> is_always_roll(always_roll(3))
    True
    >>> is_always_roll(catch_up)
    False
    """
    # BEGIN PROBLEM 7
    # Compare every reachable (score, opponent_score) pair against the choice
    # the strategy makes at (0, 0).
    first_choice = strategy(0, 0)
    score = 0
    while score < goal:
        opponent_score = 0
        while opponent_score < goal:
            if strategy(score, opponent_score) != first_choice:
                return False
            opponent_score = opponent_score + 1
        score = score + 1
    return True
    # END PROBLEM 7

逐行说明：

• first_choice = strategy(0, 0)：基准值。只算一次并存起来——如果写成在循环里每次都调 strategy(0, 0) 做比较，会白白多出一万次调用。
• score = 0 / while score < goal：外层循环，score 取 0 到 goal - 1。用 < 而不是 <=，正是因为分数等于 goal 的局面在游戏中不存在。
• opponent_score = 0 在外层循环体内：每次换一个 score，内层都要从 0 重新走一遍。这一行的位置是本题最容易错的地方。
• while opponent_score < goal：内层循环。
• if strategy(score, opponent_score) != first_choice: return False：找到反例立刻退出。这个 return 会同时跳出两层循环并结束整个函数——return 比 break 强的地方就在这里，break 只能跳出一层。
• opponent_score = opponent_score + 1 和 score = score + 1：两个循环变量各自的推进。内层的推进必须在内层循环体末尾，缩进错一级就是死循环。
• return True 在两层循环之外，与最外层 while 齐平。只有一万个组合全部通过检查才会执行到这里。
• 参数 goal=GOAL 是题目给的默认值。函数体里必须用 goal 而不是 GOAL——用后者的话，is_always_roll(s, 200) 传进来的 200 就被忽略了。

验证

先追一个返回 False 的：is_always_roll(catch_up)。catch_up 的定义是：

def catch_up(score, opponent_score):
    if score < opponent_score:
        return 6  # Roll one more to catch up
    else:
        return 5

再追一个返回 True 的：is_always_roll(always_roll(3))。always_roll(3) 造出的策略无论收到什么参数都返回 3（见上一题的环境图），所以 first_choice = 3，接下来一万次比较全部是 3 != 3 为假，一次都不触发 return False。两层循环跑完，执行 return True。✓

最有价值的是那几条「针尖式反例」用例。它们各自把唯一的不同点藏在遍历范围的不同角落，正好把常见的边界错误全都覆盖了：

第一条特别值得展开。策略是「(0,0) 返回 0，其余返回 1」，first_choice = strategy(0, 0) = 0。遍历到 (0, 0) 时 0 != 0 为假，通过；到 (0, 1) 时 1 != 0 为真，return False ✓。基准点自己永远不会成为反例，所以判定完全依赖「除基准点外还有别的点」——这就是为什么 goal 至少是 1 时也不会出问题，以及为什么不能只检查基准点。

>>> catch_up(9, 4)
5
>>> strategy(17, 18)
6

9. Problem 8：make_averaged

题目要什么

Implement make_averaged, which is a higher-order function that takes a function original_function as an argument. The return value of make_averaged is a function that takes in the same arguments as original_function. When called with specific arguments, this function should repeatedly call original_function on those same arguments times_called times, and return the average of the results.

这是整个项目最抽象的一道题。它的输入是一个任意函数，输出是「同一个函数的平均版」。docstring 的 doctest 是理解它的钥匙：

>>> dice = make_test_dice(4, 2, 5, 1)
>>> averaged_dice = make_averaged(roll_dice, 40)
>>> averaged_dice(1, dice)  # The avg of 10 4's, 10 2's, 10 5's, and 10 1's
3.0

读懂这三行需要把「谁是谁」摆清楚：

难点在于：make_averaged 不知道 original_function 需要几个参数。roll_dice 要两个；但测试里还会传一个零参数的骰子函数进来：

>>> dice = make_test_dice(3, 1, 5, 6)
>>> averaged_dice = make_averaged(dice, 1000)
>>> averaged_dice()
3.75

还会传 winner（两个参数，都是函数）：average_win_rate 里写着 make_averaged(winner)(strategy, baseline)。所以内层函数必须能吞下任意个参数。

两道概念题

怎么想到的

先假装参数个数是已知的，把主干写出来。如果我只需要支持 roll_dice，代码是这样：

# 只能用于两个参数的函数
def make_averaged(original_function, times_called=1000):
    def averaged(num_rolls, dice):
        total = 0
        k = 0
        while k < times_called:
            total = total + original_function(num_rolls, dice)
            k = k + 1
        return total / times_called
    return averaged

骨架完全正确：累加器 + 计数循环 + 除以次数。剩下的唯一问题是把 (num_rolls, dice) 换成「不管来几个都行」。

题面给了答案，而且给了一个可以直接照着改的例子：

>>> def printed(f):
...     def print_and_return(*args):
...         result = f(*args)
...         print('Result:', result)
...         return result
...     return print_and_return
>>> printed_pow = printed(pow)
>>> printed_pow(2, 8)  # *args represents the arguments (2, 8)
Result: 256
256
>>> printed_abs = printed(abs)
>>> printed_abs(-10)  # *args represents one argument (-10)
Result: 10
10

*args 在两个位置出现，含义是对称的两半：

最后一个细节：返回值必须是浮点数。测试期望的是 3.0 而不是 3，还专门加了注释「Enter a float (e.g. 1.0) instead of an integer」。用 /（真除法）而不是 //（地板除）就自动满足了——Python 3 里 120 / 40 得到 3.0，而 120 // 40 得到 3。ok 的 doctest 比较的是字符串表示，3 和 3.0 不相等。

代码

def make_averaged(original_function, times_called=1000):
    """Return a function that returns the average value of ORIGINAL_FUNCTION
    called TIMES_CALLED times.

    To implement this function, you will have to use *args syntax.

    >>> dice = make_test_dice(4, 2, 5, 1)
    >>> averaged_dice = make_averaged(roll_dice, 40)
    >>> averaged_dice(1, dice)  # The avg of 10 4's, 10 2's, 10 5's, and 10 1's
    3.0
    """

    # BEGIN PROBLEM 8
    def averaged(*args):
        """Call ORIGINAL_FUNCTION on ARGS repeatedly and average the results."""
        total = 0
        k = 0
        while k < times_called:
            total = total + original_function(*args)
            k = k + 1
        return total / times_called

    return averaged
    # END PROBLEM 8

逐行说明：

• def averaged(*args):：内层函数。形参表里只有 *args，没有别的——因为它不知道也不需要知道 original_function 要什么。
• total = 0 / k = 0：累加器和计数器，和 roll_dice 里是同一个模式。
• while k < times_called：循环恰好 times_called 次。times_called 是 make_averaged 的形参，averaged 通过闭包在父帧里找到它——和 always_roll 里的 n 完全同理。original_function 也一样。
• total = total + original_function(*args)：每次循环都重新调用一次。这一点至关重要——如果你写成在循环外先算一次 result = original_function(*args)，然后循环里累加 result，那就等于把同一个值加了 times_called 遍，平均值恒等于那一次的结果。对纯函数来说这两种写法结果一样，但 roll_dice 是非纯的，平均的意义正来自于每次调用结果不同。
• return total / times_called：真除法，得到浮点数。这一行在循环外面，写进去的话第一次循环就返回了。
• return averaged：返回函数本身，不带括号——和 Problem 6 一样。

验证

手动追踪 docstring 里的 doctest：make_averaged(roll_dice, 40) 然后 averaged_dice(1, dice)，其中 dice = make_test_dice(4, 2, 5, 1)。

全局帧 Global
    dice          -> func dice()      [闭包记着 outcomes = (4, 2, 5, 1)]
    averaged_dice -> func averaged(*args)  [parent = f1]

f1: make_averaged   [parent = Global]
    original_function -> func roll_dice(num_rolls, dice=six_sided)
    times_called      = 40
    averaged          -> func averaged(*args)   [parent = f1]

f2: averaged        [parent = f1]     <- 调用 averaged_dice(1, dice) 时创建
    args  = (1, dice)                 <- 打包
    total, k 在循环中不断改写
    执行 original_function(*args)：
        original_function 在 f2 里没有 -> 去 f1 找到 roll_dice ✓
        times_called      在 f2 里没有 -> 去 f1 找到 40 ✓
        *args 拆包成 roll_dice(1, dice)

第 1 次: dice() = 4 -> 没有 1，roll_dice 返回 4
第 2 次: dice() = 2 -> 返回 2
第 3 次: dice() = 5 -> 返回 5
第 4 次: dice() = 1 -> Sow Sad！roll_dice 返回 1
第 5 次: dice() = 4 -> 返回 4   （序列绕回开头）
...

再验证一条能真正区分 Sow Sad 的用例：

>>> dice = make_test_dice(3, 1, 5, 6)
>>> averaged_roll_dice = make_averaged(roll_dice, 1000)
>>> averaged_roll_dice(2, dice)
6.0

这次每轮掷 2 次。骰子序列 3, 1, 5, 6 循环，每次 roll_dice(2, dice) 消耗两个数：

total = 500 × 1 + 500 × 11 = 6000，6000 / 1000 = 6.0 ✓。同一组测试还有一条 make_averaged(roll_dice, 5)，只调 5 次：返回值序列是 1, 11, 1, 11, 1，total = 25，25 / 5 = 5.0 ✓——这条用例专门检查你有没有真的用上 times_called，而不是写死 1000。

最后是零参数的那条：make_averaged(dice, 1000) 然后 averaged_dice()。这次 original_function 就是骰子函数本身，args = ()，original_function(*args) 拆包成 dice()。1000 次调用里 3、1、5、6 各出现 250 次，total = 250 × 15 = 3750，3750 / 1000 = 3.75 ✓。注意这里没有 Sow Sad——因为调的是 dice 而不是 roll_dice，那个 1 就老老实实按 1 计入平均。这条用例正好证明了 make_averaged 对传进来的函数一无所知，也不需要知道。

10. Problem 9：max_scoring_num_rolls

题目要什么

Implement max_scoring_num_rolls, which runs an experiment using a die with a fixed number of sides to determine the number of rolls (from 1 to 10) that gives the maximum average score for a turn. Your implementation should use make_averaged and roll_dice.

If two numbers of rolls are tied for the maximum average score, return the lower number.

Important: In order to pass all of our tests, please make sure that you are testing dice rolls starting from 1 going up to 10, rather than from 10 to 1.

这是项目里第一道用程序做实验的题：把 1 到 10 每个掷法都试很多次，看哪个的平均回合分最高。返回的是掷几个骰子（1–10 的整数），不是那个平均分。

>>> dice = make_test_dice(1, 6)
>>> max_scoring_num_rolls(dice)
1

两条边界规则要抠准：

怎么想到的

算法本身是最基础的「打擂台求最大值」：设一个当前冠军，依次比较，谁大谁上位。真正需要想的是三件容易被忽略的事。

第一件：make_averaged 应该在循环外还是循环里调用？

两种写法在纯函数意义下等价，但在这里不等价：

# 写法 A（正确）：造一次，反复用
averaged_roll_dice = make_averaged(roll_dice, times_called)
while num_rolls <= 10:
    average = averaged_roll_dice(num_rolls, dice)
    ...

# 写法 B：每轮都重新造
while num_rolls <= 10:
    average = make_averaged(roll_dice, times_called)(num_rolls, dice)
    ...

写法 B 每轮新建一个 averaged 函数。这本身不算错——新函数的行为完全一样，dice 的指针也不会被重置（指针存在 dice 自己的闭包里，跟 make_averaged 无关）。所以 B 其实也能过测试，只是每次重建一个闭包纯属浪费。写法 A 更好的理由是意图更清楚：「平均版的 roll_dice」是一个固定的工具，造一次就够了。

第二件：骰子调用次数是全局共享的

这条比上一条重要得多。看这个专门设计的测试用例：

>>> dice = make_test_dice(*([2] * 55 + [1, 2] * 500)) # test that you are not rolling the dice more than necessary
>>> max_scoring_num_rolls(dice, times_called=1) # dice is 2 for the first 55 rolls, then is 1 followed by 2 for 1000 rolls
10

这个骰子的前 55 次调用全返回 2，之后开始出现 1。为什么恰好是 55？因为 times_called = 1 时，整个 max_scoring_num_rolls 一共需要掷：

也就是说，如果你的实现一次骰子都不多掷，那么这 55 次全部取到 2，于是 num_rolls = n 的平均分正好是 2n，单调递增，最大值在 10。答案就是 10。

但只要你多掷了一次（比如为了「热身」先调了一下，或者在某处重复计算了平均值），第 56 次开始就会摸到 1，触发 Sow Sad，后面的平均分全乱，答案不再是 10。这条用例用「刚好够用的 55」把「有没有多掷」变成了一个可观测的现象。这也是为什么题面强调必须从 1 升序扫到 10——降序扫描消耗骰子的顺序不同，同样过不了这条测试。

第三件：擂台的初值设成多少？

best_average 的初值必须小于任何可能的实际平均分，否则第一个候选就上不了台。题面提示「Assume that the dice always return positive outcomes」——点数至少是 1，所以任何平均分都 > 0。把初值设成 0 就够了。

best_num_rolls 的初值设成 1：万一所有平均分都是 0（实际不会发生），也能返回一个合法的值，而不是 None。

代码

def max_scoring_num_rolls(dice=six_sided, times_called=1000):
    """Return the number of dice (1 to 10) that gives the maximum average score for a turn.
    Assume that the dice always return positive outcomes.

    >>> dice = make_test_dice(1, 6)
    >>> max_scoring_num_rolls(dice)
    1
    """
    # BEGIN PROBLEM 9
    averaged_roll_dice = make_averaged(roll_dice, times_called)
    best_num_rolls, best_average = 1, 0
    num_rolls = 1
    # Scan 1 through 10 in increasing order so ties keep the lower number.
    while num_rolls <= 10:
        average = averaged_roll_dice(num_rolls, dice)
        if average > best_average:
            best_num_rolls, best_average = num_rolls, average
        num_rolls = num_rolls + 1
    return best_num_rolls
    # END PROBLEM 9

逐行说明：

• averaged_roll_dice = make_averaged(roll_dice, times_called)：造一次工具。注意 times_called 是形参，必须原样传进去，写死 1000 会让那条 times_called=1 的用例挂掉。
• best_num_rolls, best_average = 1, 0：多重赋值（multiple assignment），一行初始化两个擂台变量。Python 会先把右边两个表达式都求值完，再同时绑定左边两个名字。
• num_rolls = 1 与 while num_rolls <= 10：从 1 扫到 10（含 10）。<= 不能写成 <，否则漏掉 10——而 10 恰恰经常是答案。
• average = averaged_roll_dice(num_rolls, dice)：把结果存进变量。这一步不只是风格：每调用一次就会真的掷 times_called × num_rolls 次骰子。如果写成 if averaged_roll_dice(num_rolls, dice) > best_average: best_average = averaged_roll_dice(num_rolls, dice)，同一轮里调了两次，骰子被多消耗一倍，那条 55 次的用例必挂。
• if average > best_average：严格大于，实现「平局取小」。
• best_num_rolls, best_average = num_rolls, average：新冠军上位，两个变量必须同时更新。分成两行写也可以，但一定要两个都写——只更新 best_average 忘了 best_num_rolls 是很常见的手滑。
• num_rolls = num_rolls + 1 在 if 外面。写进 if 里的话，一旦某轮没刷新纪录就不再推进，死循环。
• return best_num_rolls：返回掷几个，不是 best_average。这个混淆很常见，报错会是「期望 1 得到 3.5」这类。

验证

手动追踪 docstring 的 doctest：dice = make_test_dice(1, 6)，max_scoring_num_rolls(dice)，times_called 用默认的 1000，期望返回 1。

这个骰子交替返回 1, 6, 1, 6, …。关键观察：只要一轮里掷了 2 次或更多，就必然会摸到至少一个 1（因为序列里每两个数就有一个 1），必定 Sow Sad。

再追一条能考出「平局取小」的：

>>> dice = make_test_dice(1, 2, 3, 4, 5)  # dice sweeps from 1 through 5
>>> max_scoring_num_rolls(dice, times_called=1000)
3

以及一条考「times_called 有没有真的用上」的：

>>> dice = make_test_dice(6, 5, 4, 3, 2, 1)  # dice sweeps from 1 through 6
>>> max_scoring_num_rolls(dice, times_called=1) # ensure times_called is being used
4

第二条可以完全笔算。times_called = 1 意味着每个 num_rolls 只试一轮，骰子按 6, 5, 4, 3, 2, 1 循环，从头开始一路消耗下去：

这张表把整道题的所有要点都摊开了：骰子的指针在十轮之间是连续的（第 2 行结束在「4」，第 3 行紧接着从「3」开始），所以每一行消耗多少、下一行从哪开始，完全由前面的行决定。任何一次多余的调用都会让整张表往后错位。这道题真正在考的，不是求最大值，而是「你有没有把每一次副作用都算清楚」。

11. Problem 10：boar_strategy

题目要什么

A strategy can try to take advantage of the Boar Brawl rule by rolling 0 when it is most beneficial to do so. Implement boar_strategy, which returns 0 whenever rolling 0 would give at least threshold points and returns num_rolls otherwise. This strategy should not also take into account the Sus Fuss rule.

签名是 boar_strategy(score, opponent_score, threshold=11, num_rolls=6)。虽然多了两个参数，但它仍然是一个合法的策略函数——因为后两个有默认值，play 用两个参数调用它时照样能工作。这是默认参数的一个漂亮用法：让同一个函数既能被自动调用（用默认配置），又能被人工调参（做实验）。

翻译成人话，就一句判断：如果掷 0 个骰子能拿到不少于 threshold 分，就掷 0 个；否则掷 num_rolls 个。

题面的提示直接给出了实现路径：「You can use the boar_brawl function you defined in Problem 2.」

「at least threshold」是大于等于，不是大于。这个边界被官方测试盯得很死，每个 threshold 都成对出现：

>>> boar_strategy(40, 51, threshold=15, num_rolls=7)
0
>>> boar_strategy(40, 51, threshold=16, num_rolls=7)
7

boar_brawl(40, 51) 恰好是 15。threshold = 15 时因为「至少」包含等于，所以掷 0；threshold = 16 时 15 不够，掷 7。写成 > 的话，第一条会返回 7 而不是 0。

怎么想到的

这道题的思维价值不在代码（只有三行），而在为什么这个策略会赢。

先看基线：always_roll(6) 每回合的期望得分大约是 8 分左右（六面骰掷 6 个，不出 1 的概率是 (5/6)^6 ≈ 0.335，此时期望和是 6 × 4 = 24；出 1 时只得 1 分。粗算 0.335 × 24 + 0.665 × 1 ≈ 8.7）。

再看 Boar Brawl：它的取值范围是 1 到 3 × 9 = 27。而且它是完全确定的——不掷骰子，没有 Sow Sad 风险。当 boar_brawl 算出来的分数超过 8 或 9 时，掷 0 个骰子就是稳赚不赔的买卖。

实现上唯一需要想清楚的是：怎么在不掷骰子的情况下知道掷 0 个能拿多少分？答案在 Problem 3 的验证里已经点过了——boar_brawl 是纯函数，输入两个分数就能算出确定的结果，不需要掷任何骰子。所以策略可以「先算一遍看看划不划算，再决定」。这在掷 1 个以上骰子的情况下是做不到的：你没法预知随机骰子的结果。

代码

def boar_strategy(score, opponent_score, threshold=11, num_rolls=6):
    """This strategy returns 0 dice if Boar Brawl gives at least THRESHOLD
    points, and returns NUM_ROLLS otherwise. Ignore the Sus Fuss rule.
    """
    # BEGIN PROBLEM 10
    if boar_brawl(score, opponent_score) >= threshold:
        return 0
    return num_rolls
    # END PROBLEM 10

逐行说明：

• boar_brawl(score, opponent_score)：参数顺序仍然是「自己在前，对手在后」，和 boar_brawl 的形参一致。策略函数的 score 就是当前玩家自己的分数（回忆 Problem 5 的概念题 3：play 负责把参数摆成主角视角）。
• >= threshold：大于等于，对应题面的 "at least"。
• return 0：掷 0 个骰子，即主动选择 Boar Brawl。
• return num_rolls：否则按配置的数量掷。注意返回的是形参 num_rolls，不是写死的 6——测试会传各种值进来（num_rolls=7、num_rolls=2、num_rolls=5、num_rolls=3）。
• 返回值必须是 int：0 到 10 之间。这两个返回值都满足。

验证

把官方测试逐条算一遍。先把每组分数对应的 boar_brawl 值算出来，剩下的就是比大小：

注意这些用例的组织方式：每一对都把 threshold 卡在 boar_brawl 的值上下各一格。这是测试边界条件的标准做法——只要你把 >= 写成 >，每一对里的第二条（临界那条）就会翻车。

最后一条测试更狠，它用循环覆盖了对手的所有可能分数：

>>> s = 0
>>> while s < 100:
...     if boar_brawl(90, s) >= 10:
...         assert boar_strategy(90, s, threshold=10, num_rolls=3) == 0
...     else:
...         assert boar_strategy(90, s, threshold=10, num_rolls=3) == 3
...     s += 1

这条测试等于直接把「策略必须与 boar_brawl 的判断一致」写成了断言，对 100 个对手分数逐一验证。它无法被投机取巧地通过——除非你的实现真的就是「算 boar_brawl，和 threshold 比大小」。

拿一个具体的 s 手算：s = 7 时，boar_brawl(90, 7) 中对手十位是 (7 // 10) % 10 = 0，自己个位是 90 % 10 = 0，得 max(3 × abs(0 - 0), 1) = 1。1 >= 10 为假，所以断言要求返回 3。我们的实现走 return num_rolls，返回 3 ✓。再看 s = 45：对手十位 4，自己个位 0，得 12。12 >= 10 为真，两边都要求 0 ✓。

12. Problem 11：sus_strategy

题目要什么

A better strategy would take advantage of both Boar Brawl and Sus Fuss in combination. For example, if a player has 53 points and their opponent has 60, rolling 0 would bring them to 62, which is a sus number, and so they would end the turn with 67 points: a gain of 67 − 53 = 14!

The sus_strategy returns 0 whenever rolling 0 would result in a score that is at least threshold points more than the player's score at the start of turn.

和上一题只差一个词，但这个词改变了计算方式：上一题看的是「Boar Brawl 直接给多少分」，这一题看的是「回合结束时总分比开局时多了多少」——中间可能被 Sus Fuss 白送一大截。

题面给的提示是「You can use the sus_update function you defined in Problem 4.」

怎么想到的

先把上一题的例子改造一下，看看差别有多大。score = 53，opponent_score = 60：

所以判断依据必须换成「净增量」。怎么算净增量？不用自己重算一遍规则——sus_update 已经把整条链路（Boar Brawl → 加总分 → Sus Fuss）走完了。它返回的是回合结束时的总分，减去开局的 score 就是净增量：

gain = sus_update(0, score, opponent_score) - score

第一个参数写 0，因为我们要评估的正是「掷 0 个骰子会怎样」。

sus_update(0, score, opponent_score)
  -> take_turn(0, score, opponent_score, dice)
       -> num_rolls == 0，走 boar_brawl 分支，dice 完全没被碰
  -> sus_points(score + boar_brawl(...))
       -> 纯算术，无随机

注意 sus_update 的第四个参数 dice 我们没传，用的是默认值 six_sided。这不要紧：这条路径上它根本不会被调用。

代码

def sus_strategy(score, opponent_score, threshold=11, num_rolls=6):
    """This strategy returns 0 dice when rolling 0 increases the score by at least
    THRESHOLD points, and returns NUM_ROLLS otherwise. Consider both the Boar Brawl and
    Suss Fuss rules."""
    # BEGIN PROBLEM 11
    # sus_update(0, ...) is the score we would end the turn with after both
    # Boar Brawl and Sus Fuss are applied.
    if sus_update(0, score, opponent_score) - score >= threshold:
        return 0
    return num_rolls
    # END PROBLEM 11

逐行说明：

• sus_update(0, score, opponent_score)：第一个参数是 0（掷 0 个骰子），后两个是当前比分。得到的是回合结束后的总分。
• - score：减去开局分数，得到净增量。这是本题与上一题唯一的结构性差异，也是最容易漏的一步——忘了减就是拿「总分」跟 threshold 比，几乎所有用例都会返回 0。
• >= threshold：仍然是「at least」，大于等于。
• return 0 / return num_rolls：和上一题一样。
• 整个判断写成一个表达式而没有拆成中间变量，是因为这条路径无副作用、只调用一次。但如果你想拆成 gain = sus_update(...) - score 再判断，那也完全可以，可读性还更好一点。唯一要避免的是在 if 和 return 里各调一次 sus_update——虽然这里无害（纯函数），但养成坏习惯迟早出事。

验证

逐条追踪官方用例。每一条都要走完「Boar Brawl → 加分 → 判 sus → 可能跳质数 → 算增量」这条完整链路：

第一行最有教育意义：Boar Brawl 只给了 3 分，但 Sus Fuss 又送了 3 分，净增量翻倍到 6。如果这道题错误地用了 boar_brawl（也就是抄了上一题），算出来的是 3 而不是 6——虽然这一行的答案碰巧还是 2（因为 3 和 6 都够不到 10），但换个 threshold 就会露馅。第三、四行那对卡在 14 上的用例则是把 >= 和净增量算法一起考了。

最后同样有一条循环式的全覆盖断言：

>>> s = 0
>>> while s < 100:
...     if sus_update(0, 20, s) - 20 >= 10:
...         assert sus_strategy(20, s, threshold=10, num_rolls=3) == 0
...     else:
...         assert sus_strategy(20, s, threshold=10, num_rolls=3) == 3
...     s += 1

它把「策略必须与 sus_update(0, ...) - score 的判断一致」变成了 100 条断言。注意它连计算式都和标准实现一模一样——这条测试实际上是在说：「这道题的唯一正确解法就是这个式子」。

13. Problem 12（选做）：final_strategy

题目要什么

Implement final_strategy, which combines these ideas and any other ideas you have to achieve a high win rate against the baseline strategy. Some suggestions:

• If you know the goal score (by default it is 100), there's no benefit to scoring more than the goal. Check whether you can win by rolling 0, 1 or 2 dice. If you are in the lead, you might decide to take fewer risks.
• Instead of using a threshold, roll 0 whenever it would give you more points on average than rolling 6.

这道题是选做，ok 也不给分（tests/12.py 的 points 是 0）。它的评分方式和前面所有题都不一样：没有标准答案，只检查合法性。

>>> def check_strategy(strat):
...     for score in range(100):
...         for opp in range(100):
...             num_rolls = strat(score, opp)
...             if not isinstance(num_rolls, int):
...                 raise ValueError("final_strategy({0}, {1}) returned {2}, not an int.".format(score, opp, num_rolls))
>>> def max_scoring_num_rolls(dice=lambda: 1):
...     raise RuntimeError("Your final strategy should not call max_scoring_num_rolls.")
>>> old_max_scoring_num_rolls = hog.max_scoring_num_rolls
>>> hog.max_scoring_num_rolls = max_scoring_num_rolls
>>> check_strategy(hog.final_strategy)

两条约束：

第 2 条为什么要禁？因为 max_scoring_num_rolls 每次调用要掷上万次骰子。策略函数每回合都被调用一次，如果它内部去跑一遍实验，一局游戏要掷几十万次骰子——评测会慢到超时。这是「不要在热路径上做昂贵计算」的一个具体教训。

怎么想到的

题面已经给了两个方向的提示，把它们排成一条优先级链就是本实现的思路：

第 3 条的分档怎么定的？纯粹是用「期望得分够不够填上缺口」倒推的：

核心权衡是：掷得越多，期望分越高，但「整回合只得 1 分」的概率也越高。当你只需要几分就能赢时，「稳」比「多」重要得多——掷 1 个有 83% 的概率拿到 2–6 分，而掷 6 个有 67% 的概率只拿到 1 分。终局阶段应该切换到低方差模式。

代码

def final_strategy(score, opponent_score):
    """Roll 0 dice whenever that is enough to win or gains a lot of points,
    and otherwise roll 6 dice (the number that maximizes the average turn
    score with six-sided dice), rolling fewer dice when we only need a few
    more points to reach the goal.
    """
    # BEGIN PROBLEM 12
    # 1. If rolling 0 already wins the game, take the free win.
    if sus_update(0, score, opponent_score) >= GOAL:
        return 0
    # 2. Rolling 0 is worth it when Boar Brawl + Sus Fuss beat the ~8 points
    #    that 6 dice earn on average.
    if sus_update(0, score, opponent_score) - score >= 9:
        return 0
    # 3. Near the goal, roll just enough dice to get there and no more, which
    #    lowers the chance of Sow Sad ruining the turn.
    points_needed = GOAL - score
    if points_needed <= 6:
        return 1
    if points_needed <= 12:
        return 2
    return 6
    # END PROBLEM 12

逐行说明：

• if sus_update(0, score, opponent_score) >= GOAL: return 0：比较的是总分，不减 score。这一条问的是「掷 0 个之后我的总分够不够 100」，和第二条问的「涨了多少」是两个不同的问题，所以一个减 score 一个不减。
• 第二条 - score >= 9：净增量判断，形状和 sus_strategy 完全一样，只是门槛从 11 降到 9。这个数字是可调的——把它调到 8 或 10 也能跑，胜率差别在噪声范围内。
• points_needed = GOAL - score：还差多少分。取名比直接写 100 - score 清楚得多。
• if points_needed <= 6: return 1 / <= 12: return 2：两级降档。顺序不能反——如果先判 <= 12，那么 points_needed = 3 也会走到 return 2，第一档形同虚设。「从最窄的条件开始判」是写多分支的通用规则。
• return 6：兜底。每条路径都有 return，且返回的都是整数——这正是 check_strategy 要检查的。
• 没有调用 max_scoring_num_rolls：6 这个数字是写死的，来自 Problem 9 的实验结论，而不是运行时算出来的。这就是那条禁令想让你做的事——实验在开发时跑一次，结论固化进代码。
• 这个策略调用了两次 sus_update(0, ...)，重复计算了一遍。因为这条路径是纯的（不掷骰子），重复调用无副作用，只是略微浪费。想优化的话可以存成一个变量 zero_score = sus_update(0, score, opponent_score) 再用两次。

验证

先用几个具体局面手动追一遍决策：

第四行值得多看一眼：(20, 20) 这个局面下，Boar Brawl 只给 6 分，够不到门槛 9；但加完变成 26 之后触发 Sus Fuss 跳到 29，净增量正好是 9，刚刚好卡在门槛上，于是掷 0。如果这里错用了 boar_brawl 而不是 sus_update，就会看到 6 分而放弃这次机会。

实测胜率

hog.py 里的 run_experiments() 会拿各种策略去和 always_roll(6) 对打。在本仓库跑（每个策略作为先手和后手各打 4000 局，共 8000 局）得到：

整份作业回顾

如果只从这个项目里带走一样东西，应该是这句话：先把「规则」写成一堆互不知情的小函数，再用另一层函数把它们组装成实验设备。

回头看这十三道题的依赖图，它是一棵很整齐的树：

play(strategy0, strategy1, update, ..., dice, goal)
 ├── strategy0 / strategy1   <- 由 always_roll / boar_strategy / sus_strategy / final_strategy 提供
 └── update                  <- simple_update 或 sus_update
       └── take_turn
             ├── roll_dice   <- Sow Sad
             │     └── dice()
             └── boar_brawl  <- Boar Brawl
       └── sus_points        <- Sus Fuss
             ├── num_factors
             └── is_prime

评价层（把 play 当成实验设备）：
    average_win_rate -> make_averaged(winner) -> play
    max_scoring_num_rolls -> make_averaged(roll_dice) -> roll_dice

每一层都只知道它下面那一层的接口，不知道实现。play 不知道 Sus Fuss 存在；make_averaged 不知道它在平均什么；sus_strategy 不知道下一个质数怎么找。正因为如此，换掉任何一块都不需要改其他地方——这就是「函数抽象」这四个字的实际含义。

三个母题在这个项目里的答案

(a) 一个表达式被求值时到底发生了什么？Problem 0 的 test_dice() 给了最直白的演示：同一个表达式，第一次求值得到 4，第二次得到 1。因为求值不只是「查出一个值」，它还可能改变环境。Problem 3 的那条 monkey-patch 测试则展示了另一半：roll_dice(...) 里的 roll_dice 是在调用发生的那一刻才去查的名字，不是写代码时就钉死的。

(b) 名字和值怎么绑定？作用域为什么长这样？Problem 6 和 8 是标准答案。always_roll(3) 返回的函数之所以记得 3，是因为它的父帧是 always_roll 的那个帧，而那个帧因为被引用着所以不会消失。两次调用 always_roll 产生两个独立的帧，于是两个策略互不干扰——这是「用全局变量」永远做不到的。

(c) 怎么把大问题拆成同构的小问题？这个项目的答案不是递归，而是分层：把「一局游戏」拆成「一个回合」，把「一个回合」拆成「掷骰 + 规则修正」，再把「掷骰」拆成「重复调用骰子函数」。每一层都只处理自己那一层的事。递归会在下一个阶段（链表、树）成为主角，但分层抽象的思维在这里就已经完整登场了。