不吃章鱼烧Day24 的编程复盘，我盯着一道“雉兔同笼”用三种方法反复写；Day17 的计算机英语翻译练习本上，抄的正是一段 ArrayIndexOutOfBoundsException 的完整报错。别人问我在折腾什么，我说这是自己设计的双线并行学习项目：每天拿一道编程题练逻辑，再拿一段计算机英语练阅读，让中文题目和英文文本互相解释。目前编程题卡在 Day24，英语翻译卡在 Day17，虽然没有做到完全同步，但两个进度都稳定往前走。
如果你正在刷 Java 基础编程题，或者被 C 语言经典 100 例里某个边界条件绕晕，又或者每次看到英文报错只能下意识复制粘贴到搜索框，这篇复盘值得花几分钟读完。我会把 Day24 当天的题目选型、解法复盘和 Day17 的翻译素材全部拆开给你看，重点不是“我又坚持了多少天”，而是这套组合练习为什么越到后面越不吃力。
1. 双线任务的设计逻辑：为什么编程题练到第 24 天还要搭上英语翻译
1.1 我给自己设的规则：代码和英文必须“互相解释”
最早我只刷编程题，打卡到第十天左右就发现一个问题：很多题目我中文读得懂、代码也写得出来，但只要换成英文文档、英文报错，整个人就反应慢半拍。典型的场景是我用 Java 写数组遍历，明明知道“下标越界”是怎么回事，可一看到 ArrayIndexOutOfBoundsException 还是会先愣一下，然后才去检查 for 循环的边界。
后来我把练习结构调整成“一道编程题 + 一段计算机英语翻译”，而且不是独立进行，是让两件事产生关联。比如当天编程题写的是数组去重，那英语翻译就去读 Java 官方文档里讲数组的那一段；当天编程题写的是循环求值，那英语翻译就找一段包含 iteration、loop、condition 的说明。这样做的原因很简单：编程题里的逻辑是骨架，英文术语是肌肉，每次都在同一个话题里碰面，记忆负担比单独背单词低很多。
所谓“互释”，是我给自己定的验收标准：拿到一道题，能用自己的话把中文思路讲清楚；拿到同一主题的英文句子，也能把英文术语映射到代码运行过程中的具体对象上。这比单纯记满一页单词表有用。
1.2 打卡节奏设计：为什么编程题是 Day24，英语翻译却只有 Day17
很多人会把“Day24 + Day17”理解成同一个进度的两个项目，其实并不是。编程题我从第 1 天开始就没有断过，哪怕出差也会找碎片时间写一道简单题。英语翻译则中途停过几次，比如有一周连续加班到很晚，我果断把当天任务降级成只翻译一句报错，可后来还是因为状态太差断了两天，于是两边天数慢慢拉开了差距。
这个不同步其实是合理的。编程题是主项目，英语翻译是辅助项目，只要两个方向都在前进，就不必强求日历上的数字完全一致。我给自己设计的每日时间盒是这样的：
- 18:30-19:00：编程题 1-2 道，写完必须跑测试，编译报错先自己读，不许立刻搜中文翻译。
- 19:00-19:15：用刚才代码里出现过的术语做英语翻译，素材可以是一句报错、一段官方文档，或者一个概念定义。
- 19:15-19:20：把今天的题目、代码关键词、英文生词写进复盘表，预计明天要验证的一件事。
实际执行中，如果某天特别忙，我允许把时间盒拆成“早上 10 分钟 + 晚上 15 分钟”。但只要当天还有力气打开编辑器，就至少要完成一道最简单的基础题，或者翻译一段关于数组和指针的英文描述。保持每天跟代码和英文打一个照面，比偶尔猛学三小时重要得多。
我用一个极简表格记录进度，字段只有五个：
| 字段 | 说明 |
|---|---|
| 日期 | 当天日历日期 |
| 项目名 | 编程题练习 或 计算机英语翻译 |
| 当天序号 | 例如 Day24 / Day17 |
| 内容摘要 | 题目名称、英文片段主题 |
| 复盘备注 | 遇到的问题、需要明天验证的点 |
这五栏看起来朴素，但配合“今天到底学会了什么”的追问，足以支撑我把一个必须动脑的练习坚持到三个星期以上。
需要模型API调用？ 免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. Day24 编程题复盘：从“会做”到“出题人视角”，我挑题的口味变了
2.1 雉兔同笼怎么做才算“计算机解法”：三种实现横向对比
Day24 当天我重新做了一道很多人在高一信息技术课上都见过的题目：鸡兔同笼，也叫雉兔同笼。笼子里有若干只鸡和兔，从上面数共有 35 个头，从下面数共有 94 只脚，问鸡和兔各有多少只。
如果只是应付数学作业，二元一次方程组是最快的。设鸡有 x 只，兔子有 y 只，那么 x + y = 35，2x + 4y = 94。解出来 x = 23，y = 12。这道题放在编程题里，意义就变了，它考察的是怎么把一个现实问题转成计算机能执行的条件判断和循环逻辑。
第一种解是穷举法。把鸡的数量从 0 到 35 逐个试，兔子数量就是 35 减去鸡的数量。每试一次，检查总脚数是不是 94。C 语言实现很朴素：
c复制#include <stdio.h>
int main() {
int heads = 35;
int feet = 94;
for (int chickens = 0; chickens <= heads; chickens++) {
int rabbits = heads - chickens;
if (2 * chickens + 4 * rabbits == feet) {
printf("chickens = %d, rabbits = %d\n", chickens, rabbits);
break;
}
}
return 0;
}
这个写法最容易理解，也最接近“计算机暴力搜索”的本能。只要头的数量不大，循环几十次根本无所谓，时间复杂度是 O(heads)，空间复杂度是 O(1)。但它有个潜在问题：如果题目给的数据本身无解，程序会静默地不输出任何结果。很多初学者会漏掉这个分支。
第二种解是只用一个变量的数学推导。既然兔子数量等于总头数减鸡数量，脚数条件就变成关于鸡的方程。Java 写法可以这样：
java复制public class ChickensAndRabbits {
public static void main(String[] args) {
int heads = 35;
int feet = 94;
if (feet < 2 * heads || feet > 4 * heads || (feet - 2 * heads) % 2 != 0) {
System.out.println("No valid solution");
return;
}
int rabbits = (feet - 2 * heads) / 2;
int chickens = heads - rabbits;
System.out.println("chickens = " + chickens + ", rabbits = " + rabbits);
}
}
核心思路是：先把所有头都当成鸡，那么脚数应该是 2 × heads。现在脚数比这个值多出来的部分，必然是因为每只兔子比鸡多两只脚，所以多出来的脚数除以 2 就是兔子数量。注意先做合法性判断：总脚数不能小于全是鸡的情况，也不能大于全是兔子的情况，而且多出来的脚必须是偶数。
第三种思路叫“抬腿法”，其实和第二种本质相同，只是在叙述上更适合讲给零基础的人听。假设所有鸡和兔子都被命令抬起两只脚，那么一共抬起 2 × heads 只脚，剩下站着的脚全是兔子的后脚，每只兔子还剩两只脚着地，所以兔子数等于剩余脚数的一半。这个思路写成代码和第二种几乎一样，但它能帮你直观理解为什么公式长那样。
把三种方法放在一起看，你会发现一件事：穷举法适合验证答案，数学推导法适合 O(1) 求解，而“抬腿法”是用来跟别人讲清楚原理的方式。真正的编程思维不是只知道一种答案，而是知道哪种方法在什么场景下最稳最快。
顺便说一句，经典 C 语言编程题 100 例里通常也会收录这类问题。我的看法是，这类题不要做一遍就扔，可以改几个条件再练一次。比如把鸡兔改成三轮车和汽车，共有 vehicles 辆，轮子有 wheels 个。三轮车 3 个轮子，汽车 4 个轮子，那么汽车数量就是 wheels - 3 * vehicles，三轮车数量是 vehicles - cars，前提是 wheels 不小于 3 * vehicles 且多出来的轮子数能被 1 整除。这种变式能帮你把“硬编码数字”的毛病改掉，让代码里的常数变成参数。
2.2 数组去重：一道 Java 基础题暴露了我“只背 API 不读源码”的毛病
当天第二道题来自很常见的 Java 基础编程题：给定一个已经排好序的整数数组 nums，原地删除重复出现的元素，返回删除后数组的新长度。要求不能使用额外数组空间，必须原地修改，空间复杂度为 O(1)。
很多第一反应是：去重嘛，用 LinkedHashSet 或者 HashSet 就行，遍历一遍把元素丢进集合，最后再倒回数组。但如果题目明确要求原地修改且不能用额外数组空间，Set 方案就不达标，因为 HashSet 的空间复杂度是 O(n)，面试和考试里很容易被追问。
正确做法是双指针覆盖。既然数组已经排序，重复元素一定连续出现。一个慢指针指向已经去重部分的末尾，一个快指针从前往后扫描。每当快指针发现一个和慢指针位置元素不同的新值，就把它往前覆盖。Java 写法如下：
java复制public static int removeDuplicates(int[] nums) {
if (nums.length == 0) {
return 0;
}
int writeIndex = 1;
for (int readIndex = 1; readIndex < nums.length; readIndex++) {
if (nums[readIndex] != nums[writeIndex - 1]) {
nums[writeIndex] = nums[readIndex];
writeIndex++;
}
}
return writeIndex;
}
这里 writeIndex 表示下一个应该写入的位置，writeIndex - 1 表示去重后数组的最后一个元素。快指针每次读到一个新值，就覆盖到 writeIndex 上，再把 writeIndex 向右移动。如果数组为空，直接返回 0，否则 writeIndex 初始值必须设为 1，因为第一个元素天然保留，不需要检查自己和自己是否重复。
我写这道题时踩过一个很小的坑：第一版把 if (nums[readIndex] != nums[writeIndex - 1]) 写成了 if (nums[readIndex] != nums[readIndex - 1])。看起来差不多，实际上后者比较的是原始数组中相邻两个元素是否相等。对于已经排序的数组，这两者在大多数情况下结果相同，可一旦发生过覆盖，前者的语义才是“当前去重结果里的最后一个值”，后者却可能因为数组已经被改成不连续而误判。这个细节如果不跑测试，很难靠肉眼发现。
如果把同样的逻辑改成 C 语言，代码结构会更明显：
c复制int removeDuplicates(int* nums, int numsSize) {
if (numsSize == 0) {
return 0;
}
int writeIndex = 1;
for (int readIndex = 1; readIndex < numsSize; readIndex++) {
if (nums[readIndex] != nums[writeIndex - 1]) {
nums[writeIndex] = nums[readIndex];
writeIndex++;
}
}
return writeIndex;
}
C 语言里没有数组长度的内置属性，必须把 numsSize 作为参数传进来，这要求你写代码前就检查空数组边界；而 Java 里虽然能用 nums.length，但同样要先判断长度为 0 的情况。这道题的价值不在于代码有多难，而在于它让你经历一次“用双指针维护语义”的思考过程，同时也让你对 ArrayIndexOutOfBoundsException 产生警觉。writeIndex - 1 这个表达式只有在 writeIndex 大于 0 时才安全，一旦初始值设置错误，第一天代码就崩。
2.3 Day24 复盘：每当题做完了，我会强制自己继续追问三个问题
打卡到第 24 天，我开始意识到一个很现实的问题：如果每天只是机械地从题库里抓一道题来做，正确率再高也只是低水平重复。真正有效的复盘不是再看一眼答案，而是把自己切换到出题人视角，给同一道题设计变体。我现在每做完一道题，都会强制追问自己三个问题。
问题一：如果输入规模放大 1000 倍，现在的算法还扛得住吗？雉兔同笼用穷举法，当头的数量是 35 时没影响，但如果是 10 亿个头，就必须用 O(1) 的推导公式。数组去重如果一开始用了 Set，数据量一大，额外内存就会成为瓶颈，所以必须想清楚原地双指针的做法。
问题二：如果不用任何封装好的 API，我能不能从底层把逻辑实现出来？Java 的 Set、Arrays.sort 都是好东西，但刷基础题的目的不是炫技，而是理解底层。把 HashSet 拿掉之后，你自然会被迫思考：重复值靠什么判重？有序数组可以双指针，无序数组是不是要先排序？排序的时间复杂度是多少？
问题三：这道题里的关键操作，用英语怎么表达？雉兔同笼循环里的 condition，数组去重里的 removeDuplicates、writeIndex、iterate over the array，这些词如果在英文文档里出现，我能不能立刻看懂？我把这三个问题写成了一个简单的检查表，每天夹在复盘笔记里。第 24 天检查时发现，这样练下来，做题数量虽然比第一周少了，但每个题型的记忆深度反而明显增强了。
3. 第 17 天计算机英语翻译：我为什么盯上报错信息和官方文档
3.1 当天的翻译素材：数组主题的两段英文文本
计算机英语翻译练到第 17 天，我已经不太去翻那种按字母排序的术语表了，因为那种材料脱离上下文，背完就忘。我现在用的是和 Day24 编程题配对的两段文本。
第一段来自 Java 官方文档里对数组的介绍，标题是 Arrays，原文大意是：
An array is a container object that holds a fixed number of values of a single type. The length of an array is established when the array is created. After creation, its length is fixed.
我的翻译练习分三步。第一步是口头直译：数组是一个容器对象，持有固定数量的单一类型的值。数组长度在创建时被确定。创建之后，长度固定。第二步是检查术语：container object 要翻成“容器对象”，不能只看成一个普通的“对象”，因为它强调的是能存放其他元素的盒子。single type 是“单一类型”，说明一个数组里不能混着整数和字符串。established 在这里不是“建立”那么简单，更准确的理解是“被确定下来”。第三步是润色成中文技术表达：数组是一种容器对象，用于保存固定数量的单一类型元素。数组在创建时确定容量，之后长度不可改变。
第二段素材来自我当天代码的注释版本，我想用英文说清楚 writeIndex 的含义：
Invariant: at the start of each iteration of the for loop, the subarray nums[0..writeIndex-1] contains the elements that have been kept so far, and no duplicate values appear in that subarray.
这段的翻译可以拆开处理。Invariant 是算法里常用的“不变量”，意思是程序执行过程中始终保持为真的性质。at the start of each iteration 表示在每次循环开始前，注意不是结束后。the subarray nums[0..writeIndex-1] 描述的是数组的一个区间。把整句连起来就是：循环不变量：在 for 循环的每次迭代开始时，子数组 nums[0..writeIndex-1] 包含了到目前为止保留的元素，且该子数组中不出现重复值。
为什么第二段比第一段更难却更有用？因为它直接逼我理解双指针算法的本质。写代码的时候，我知道 writeIndex 是“下一个写入位置”，但如果没有用“不变量”去描述它的语义，下次换个场景我一定还是会出错。英文学术语不只是为了应付考试，它会逼你用更精确的方式思考代码的运行状态。
3.2 真正需要抠的不是词汇量，而是英文句子里的“主谓宾”和技术语境
很多人学计算机英语有一个误区：把精力放在背单词上，结果单词都认识，句子还是看不懂。我前 16 天也有这个毛病，Day17 终于想明白，问题出在句子结构和技术语境上。举个我自己翻车的例子。
out of bounds 这个词组，直译是“在边界之外”。单独看，你认识 out、of、bounds，但中文技术语境说“下标越界”，对应英文是 index out of bounds。Index 5 out of bounds for length 5 的意思是“索引 5 超出了长度为 5 的数组的有效范围”。结合数组索引从 0 开始计数的规则，长度为 5 的数组最远只能用到索引 4，所以索引 5 是非法的。
再看几个高频词的常见翻译差异：
| 英文术语 | 常见翻译 | 实际技术语境 |
|---|---|---|
| bound | 边界、范围 | 数组下标允许的边界，越界叫 out of bounds |
| overflow | 溢出 | 数值超过上限或缓冲区长度不够 |
| invoke | 调用 | 调用方法，比 call 更正式 |
| reference | 引用 | 指向对象的变量，不是“参考” |
| iterate | 迭代 | 反复执行并每次取下一个元素 |
表面上看是单词翻译，实际上每个词背后都对应一个具体的代码场景。reference 在 Java 和 C++ 里的语义还不完全一样，Java 里的引用可以理解成对象的遥控器；overflow 在整数计算中代表值太大无法表示，在数组中则可能是缓冲区溢出。所以翻译练习绝对不能只看单句，要带着代码去还原上下文。
3.3 计算机英语翻译 Day17 的训练流程：从“查完就忘”到“定位问题”
那一天我给自己设置的任务是翻译一条完整的 Java 报错：
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 5
at Demo.main(Demo.java:6)
很多人看到这种信息会感到头大，但翻译它其实只需三步。第一步，先读异常类型：ArrayIndexOutOfBoundsException，拆开就是 array + index + out of bounds + exception，含义是数组索引越界异常。第二步，读详细信息：Index 5 out of bounds for length 5，索引 5 超出长度 5 的数组边界，说明代码尝试访问数组的第 6 个元素，但数组只包含 5 个可访问位置。第三步，看堆栈位置：at Demo.main(Demo.java:6)，意思是问题发生在 Demo.java 的第 6 行。按这个顺序去读，十秒之内就能定位到出错的代码。
这个流程看起来很简单，但需要每天练几次才能形成条件反射。我建议初学者不要急着把英文报错丢给翻译软件，先用“谁在什么位置做了什么导致什么异常”这个框架试着翻译出来，再对照标准中文。翻译报错还有一个附加好处：中文技术社区里很多答案也是对报错的解读，能看懂英文原文意味着你可以直接去看官方 release note 和原始 issue 记录，而不是依赖二手转述。
从 Day17 的翻译练习里，我最大的收获是“不变量”这个英文词。以前写数组去重只靠直觉，觉得双指针好像是对的，但说不清为什么对。当我把循环不变量翻译出来之后，我才真正理解：为什么 writeIndex - 1 这个位置可以安全地代表去重后数组的最后一个元素。因为循环开始前它没有重复，每次有新元素覆盖后，重复性质仍然保持。英文句子逼我把这个性质用文字固定下来，这个收获远超单纯记住几个单词。
4. 坚持到 Day24 之后，我发现真正的门槛不是题难，而是“中断羞耻”
4.1 中断是正常的，但我给自己设了一个“最小可完成单元”
很多学习打卡计划说断就断，不是因为某天题目太难，而是因为中断后会产生“反正已经断了，干脆放弃”的羞耻感。我自己在编程题练到第 8 天时差点断掉。那天晚上从外地赶回家，身心俱疲，打开编辑器脑子里全是浆糊。最后我把目标临时下调，只做了一道最简单的输出题，并且用英语翻译了一句三秒钟就能读完的报错。打卡虽然很水，但日历没有断。
这个“最小可完成单元”的原则帮了大忙。正常日子的标准可以高，比如两道扎实的编程题加一段文档翻译；但累到不行的时候，标准可以降到“一道基础概念题 + 一句英文术语”。这样做的好处是：你始终保持着和编程语言以及英文的接触频率，哪怕接触得很浅，也好过完全断开。状态恢复后，再把难度升回来，不用花太多时间“重启”。
到了 Day24，我越来越意识到，坚持的本质不是每天都精神饱满，而是允许自己有不精神饱满的时候，同时仍能找到一个很小的、可以完成的动作。这个动作不需要多复杂，它只是给明天一个继续的接口。
4.2 错题卡和术语卡合并：真正该记录的是“同一个概念在不同语言里的样子”
打卡进入第三个星期之后，我的复盘慢慢从“今天做了什么”转向“今天暴露了什么”。我发现一个很有意思的现象：很多代码错误和英文翻译的困难来自同一个根源。数组越界这个错误，中文叫“下标越界”，Java 异常叫 ArrayIndexOutOfBoundsException，C 语言里可能根本不报错而是产生未定义行为，英文文档里的描述又是 out of bounds。如果我把这些分别记在“错题本”和“单词本”里，就错过了一个极好的串联学习机会。
所以我索性把“代码错因”和“英文翻车词”合并到一张表里。比如：
| 概念 | 中文说法 | 英文关键术语 | 代码场景 | 易错点 |
|---|---|---|---|---|
| 数组越界 | 下标越界 | out of bounds, index | 访问 nums[5] 但数组长度为 5 |
Java 会抛异常，C 不报错 |
| 空指针 | 空对象调用方法 | null pointer | str.length() 但 str 为 null |
先判空再做方法调用 |
| 原地算法 | 不占额外空间 | in-place | 双指针对数组原地去重 | 误用 Set 违反空间限制 |
| 迭代遍历 | 循环处理 | iterate over | for 循环遍历数组 | 分不清 iteration 和 recursion |
这张表的好处是让我用一种“跨语言视角”去看待同一个编程概念。以后在英文文档里再看到 in-place，我会立刻想到双指针、想到空间复杂度 O(1)、想到那些一看到题目就默认用 HashSet 的新手。这个概念被从多个维度绑在一起，比单独背十个单词牢固得多。
4.3 极简记录工具与复盘节奏：别让笔记美化吃掉真正用来练习的时间
最后聊一下记录工具。Day24 的编程题和 Day17 的计算机英语翻译，我全程没有用复杂的项目管理软件，就是一个本地 Markdown 文件加几个文件夹。代码放在按日期命名的目录里，英语笔记和每日学习记录放在同一份文档里。我不建议新手花太多时间研究笔记模板、彩色标签、导入导出功能，因为笔记做得越复杂，你越想逃避。记录只要满足三个条件就够了：当天能回看、问题能定位、明天能行动。
我的每日复盘模板长这样：
- 今天的任务是什么？
- 卡住的点是什么，卡了多久？
- 解决问题的关键是什么？
- 这个关键点用中文和英文分别怎么表达？
- 明天的唯一任务是什么？
第五点尤为重要。比如 Day24 晚上写下的“明天唯一任务”是：给雉兔同笼的代码增加非法输入测试，并且把英文版解题思路中的 feasible 和 head count 复习一遍。这个任务足够小，第二天基本不存在找不到入口的问题。
关于节奏，我的体会是编程题适合放在精力最好的时段，英语翻译可以放在饭后或者通勤的碎片时间，但不建议反过来。因为编程题需要进入心流状态，一旦被打断重新进入的成本很高；而英语翻译哪怕只做一句，也可以在十分钟内完成。两者交叉安排，能让大脑的不同区域轮流休息，反而不容易累。
最后分享一个我自己最近才悟到的小技巧
编程题练到 Day24、计算机英语翻译练到 Day17，真正改变我的不是日程表上的数字，而是我学会用双语去“解释”一段代码。以前做数组去重，我只知道要用双指针，但说不清为什么 writeIndex 能保证正确。当我在英文文本里看到 invariant 这个单词，并把它翻译成“循环不变量”之后，我突然觉得代码里那个指针不再是一个舞动的数字，而是一个有明确语义的标记。翻译练习不是编程的附属任务，它反过来让我对代码精度的理解提高了。
如果你也想复制这套打法，我的建议是先别急着每天做两道编程题加一整段英文翻译，那太容易崩塌。不如先坚持“一道编程题 + 一句英文报错”的小组合，持续七天，再把难度加上去。重点不是第 24 天和第 17 天有多漂亮，而是这 41 次微小练习有没有在某个瞬间连成一条线。就我目前的情况来看，这条线已经慢慢在成形了。