考研复试编程机试真题拆解：五道经典题与备考策略

每年三月初，考研复试的硝烟就冒出来了。3.4这个日子对我来说印象很深——那是我当年参加复试机试的日子，五道编程题，三个小时，白板编辑器，没有自动补全，没有调试器，全靠手写代码和肉眼排错。考完出来手都是抖的，但成绩还算理想。这两年不少学弟学妹来问我复试编程题怎么准备，我觉得与其东一句西一句地聊，不如把当年那五道题整理出来，结合我后来带人备考的经验，做成一份能直接照着练的拆解。

这份内容围绕研究生复试中的编程机试环节展开，适合正在准备复试的考生，也适合想检验自己编程基本功的在校生。题目风格偏向基础算法和语言熟练度考察，用C/C++和Python都能做。我会把五道题的考查点、思路分析、参考代码和易错细节全部展开，同时附上考场上常见问题的排查方法和一套备考复盘方法论。你不需要基础多好，只要会基本的语法和循环，就能跟着一步步走下来。

1. 复试编程题到底在考什么

复试机试和平时写课程作业完全是两个世界。课程作业可以慢慢调、反复改，机试考察的是你在有限时间内、没有辅助工具的情况下，能不能用代码解决一个明确的问题。很多同学平时在IDE里写得飞起，一旦面对白板编辑器就卡壳，原因不是不会写，而是不熟悉这种“一次成型”的答题方式。

复试编程题通常有三个隐藏的考察维度。第一是基本语法和库函数的熟练度，比如字符串处理、数组操作、输入输出格式控制，这些是基本功中的基本功，没有捷径，只能靠多写。第二是算法思维的清晰度，大部分题目不需要复杂的算法，但需要你用正确的思路去组织逻辑，例如循环边界条件的设定、递归终止条件的判断、动态规划的状态转移。第三是代码的健壮性，边界测试能不能过，空输入、单元素输入、最大值输入，这些都得想到。

具体到那五道题，我把它们的类型拆开看你就会发现一个规律：几乎每所学校的复试题目都覆盖了基础IO、循环递推、字符串处理、数组排序、递归分治这几个经典区块。这五个方向基本就是复试编程题的“必修课”，覆盖了绝大多数高校的考察范围。

每次复试前我都会和学生强调一句话：复试编程题不是选拔ACM金牌选手，而是筛选“能读懂题目、能写出代码、能处理边界情况”的合格研究生。搞清楚这个定位，你复习的方向就对了。下面我直接进入那五道题，题目描述做了还原，代码用C语言写，但思路是通用的，用Python写也完全不受影响。

2. 从考场上带回来的五道真题拆解

那天的五道题，从易到难排列，第一题几乎就是送分题，最后一题稍微需要想一想。半年后我跟几个一起参加复试的同学复盘，大家一致认为关键不在于题目本身有多难，而在于你有没有在复习阶段把常见题型练成肌肉记忆。这五道题恰好覆盖了每个区块的代表性问题，我把完整拆解写在下边。

2.1 第一题：计算长方体的体积与表面积

题目要求输入一个长方体的长、宽、高（均为浮点数），输出其体积和表面积，要求结果保留两位小数。这道题本质上就是考察最基本的输入输出处理和浮点数格式化，没有算法难度。

思路分析上没有任何弯弯绕绕，体积公式是长乘宽乘高，表面积公式是 2 乘以（长乘宽加宽乘高加长乘高）。唯一的坑有两个：第一，使用 printf 格式化输出时，%.2f 才能正确保留两位小数，有些同学习惯性写了 %d，结果把浮点数截断成整数输出了；第二，长方体长宽高可能存在精度问题，比如输入 0.1、0.2、0.3，浮点运算结果会有一点点误差，虽然这道题没怎么卡这个点，但后续题目里浮点比较时你会遇到。

参考代码：

c复制#include <stdio.h>

int main() {
    double a, b, c;
    scanf("%lf %lf %lf", &a, &b, &c);
    double volume = a * b * c;
    double area = 2 * (a * b + b * c + a * c);
    printf("%.2f %.2f\n", volume, area);
    return 0;
}

我考场上的心得体会是：送分题更要慢。花了三分钟写完这道题后，我把输出语句重新读了一遍，确认 %lf 和 %.2f 没有写反，然后再做下一题。别小看这一步，很多高分选手栽在最后一秒发现第一题输出格式错了，白白丢分。

2.2 第二题：猴子吃桃与循环递推问题

题目大意是：猴子第一天摘下若干个桃子，当即吃了一半，还不过瘾，又多吃了一个。第二天早上又将剩下的桃子吃掉一半，又多吃了一个。以后每天早上都吃了前一天剩下的一半零一个。到第10天早上想再吃时，见只剩下一个桃子了。求第一天共摘了多少桃子。

这是一道经典的倒推递推题，考察的循环思维正好对应了复试中最常出现的“由最终状态反推初始状态”的逻辑。顺着想很难，因为每天的桃子数量变化关系是已知的，但初始值是要求的，这种时候就需要逆着推回去。

第10天剩下1个桃子，而第9天晚上吃完后剩下的桃子数设为 x，那么第10天早上的1个就是 x 减去 x 的一半加一的结果，反过来就是第9天剩下的桃子数是 (第10天剩下的 + 1) 乘以2。把这个递推关系写成代码，就是一个从第9天循环到第1天的累乘加法过程。

参考代码：

c复制#include <stdio.h>

int main() {
    int remain = 1;
    for (int day = 9; day >= 1; day--) {
        remain = (remain + 1) * 2;
    }
    printf("%d\n", remain);
    return 0;
}

这道题的易错点在于循环次数。从第10天倒推到第1天，需要递推9次而不是10次。很多同学一激动写成了 for (int day = 10; day >= 1; day--)，结果算出来是1534，正确答案是1534吗？不是，那是递推了10次的结果。我当时在草稿纸上先手动推了两天，确认关系后再写循环，这个习惯帮我避开了这类边界错误。实际上用递推公式手算第一轮是 (1+1)*2 = 4，第二轮是 (4+1)*2 = 10，验证了一下这个关系没问题，才放心提交。

2.3 第三题：字符串反转与字符统计

第三题要求输入一个长度不超过100的字符串，输出它的反转结果，并统计其中大写字母、小写字母和数字字符的个数。这道题开始有综合性了，但其实也不难。字符串反转在C语言里最朴素的做法是双指针交换，即定义两个下标 i 和 j，初始分别指向首尾，交换字符后 i 加一、j 减一，直到 i 大于等于 j。统计字符类型则需要注意 ASCII 码的范围判断：大写字母在 'A' 到 'Z' 之间，小写字母在 'a' 到 'z' 之间，数字在 '0' 到 '9' 之间。

参考代码：

c复制#include <stdio.h>
#include <string.h>

int main() {
    char s[105];
    int upper = 0, lower = 0, digit = 0;
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = '\0';

    int len = strlen(s);
    for (int i = 0; i < len; i++) {
        if (s[i] >= 'A' && s[i] <= 'Z') upper++;
        else if (s[i] >= 'a' && s[i] <= 'z') lower++;
        else if (s[i] >= '0' && s[i] <= '9') digit++;
    }

    int i = 0, j = len - 1;
    while (i < j) {
        char temp = s[i];
        s[i] = s[j];
        s[j] = temp;
        i++;
        j--;
    }

    printf("%s\n", s);
    printf("%d %d %d\n", upper, lower, digit);
    return 0;
}

这里有两个考场上最容易翻车的细节。第一，如果用 scanf("%s", s) 读字符串，遇到空格就停止了，而题目明确说输入一个字符串，可能包含空格，比如 "Hello World 123"，这种情况下必须用 fgets 或者 gets（有些系统不推荐 gets 了，可以用 fgets 替代）。第二，fgets 会把换行符也读进来，所以需要在统计前用 s[strcspn(s, "\n")] = '\0' 把末尾换行符去掉。这个细节我当年就见过有同学没处理，统计结果里莫名多了一个字符，大写字母统计始终对不上。

另外关于反转，有同学会用 strrev 函数，但这属于平台自有扩展函数，不是标准库函数，在部分在线评测系统上会编译出错。自己写双指针交换是最稳定的方案，还可以顺手练习下标控制能力。

2.4 第四题：数组去重与升序排序

题目要求输入n个整数，去除重复元素后按升序输出。这是数组操作和排序的综合题，也是复试里最经典的题型之一。我第一次带学生备考时，发现他们普遍有两种思路：一种是用哈希表或者布尔数组标记，另一种是先排序再相邻去重。两种都可以，但在复试环境下，我推荐先排序再相邻去重，因为这类系统通常允许你调用快速排序库函数 qsort，或者自己写冒泡排序。

参考代码（含 qsort 用法）：

c复制#include <stdio.h>
#include <stdlib.h>

int cmp(const void *a, const void *b) {
    return *(int *)a - *(int *)b;
}

int main() {
    int n;
    scanf("%d", &n);
    int a[1005];
    for (int i = 0; i < n; i++) {
        scanf("%d", &a[i]);
    }
    qsort(a, n, sizeof(int), cmp);

    int idx = 0;
    for (int i = 0; i < n; i++) {
        if (i == 0 || a[i] != a[i - 1]) {
            a[idx++] = a[i];
        }
    }

    for (int i = 0; i < idx; i++) {
        if (i > 0) printf(" ");
        printf("%d", a[i]);
    }
    printf("\n");
    return 0;
}

需要注意的点比较集中。第一，qsort 的比较函数必须是 const void * 参数，内部再强制转换成 int *，返回差值时要小心减法溢出，虽然这个量级的整数一般没事，但如果你输入的数值范围覆盖了 int 上下界，建议改成直接判断大小返回 -1、0、1。第二，去重时遍历数组从下标1开始比较与前一个元素是否相等，这个写法天然处理了第一个元素不重复的情况，比用标记数组更简洁。第三，输出格式要求空格分隔，但最后一个数后面不能有额外空格，这种细节在OJ题目里往往作为输出格式错误来扣分。

如果你忘了 qsort 的用法，也可以用冒泡排序，1000个元素以内两层循环足够。但会用比较函数本身就是基本功，复试考官有时会在面试环节追问你对排序的理解，这时候能说出 qsort 用快速排序实现、平均复杂度是 O(n log n)、最坏情况是 O(n^2)，往往能给考官留下好印象。

2.5 第五题：递归实现斐波那契数列的第n项

第五题要求输入 n（n不超过30），输出斐波那契数列第n项。数列定义是第1项和第2项为1，从第3项开始每项等于前两项之和。这道题考察递归函数的书写和理解，属于递归板块的必考题。

多数同学的直接反应是写一个递归函数：

c复制int fib(int n) {
    if (n == 1 || n == 2) return 1;
    return fib(n - 1) + fib(n - 2);
}

这道题在n不超过30的情况下，这种写法完全能通过，运行效率完全够。但复试的考官往往不会只看你是否提交通过，后面还有面试环节，他会问你：“如果n到50，甚至100，这个写法还行不行？”这时候你就要能答出递归产生大量重复计算的缺陷，并提出用数组做记忆化搜索或者直接用递推。我在实际面试环节就被问到了这个，好在我把递推版也写出来了：

c复制#include <stdio.h>

int main() {
    int n;
    scanf("%d", &n);
    long long fib[55];
    fib[1] = 1;
    fib[2] = 1;
    for (int i = 3; i <= n; i++) {
        fib[i] = fib[i - 1] + fib[i - 2];
    }
    printf("%lld\n", fib[n]);
    return 0;
}

这里还有一个容易忽视的坑：n超过40以后，斐波那契数列的值已经超过了 int 的范围，需要用到 long long 甚至更高精度。虽然题目限定了n不超过30，但如果你养成“根据数据范围推断类型”的习惯，会避免很多后续问题。考场上读题第一步除了理解逻辑，还要下意识地看数据范围，这决定了你定义变量时的类型选择，也决定了你的算法复杂度在哪个级别能被接受。

第五题整体是五道题里最需要“多想一步”的。递归的思路是垂直分解问题，递推的思路是水平累积结果，两者都能解决这道题，但面试官更希望看到你能比较它们的优劣。我在复试前就准备了这道题的多种解法，因为斐波那契数列在教材里太经典了，出现的频率非常高，你有衔接性的知识储备，回答问题的底气就完全不一样。

3. 考场实战中必须警惕的五大扣分细节

代码写完只是第一步，在复试机试环境中，真正让你丢分的往往不是算法本身，而是各种细节。我结合那次考试和后来监考模拟机试的经验，把最容易丢分的点按出现频率排了个序。

第一个细节是输入输出的格式问题。最常见的就是多输出空格、少输出换行、大小写不匹配。解决办法只有一个：先用题目给的样例输入跑一遍，比对输出是否完全一致，包括空格和换行。很多同学在本地IDE里觉得“长得差不多”就提交了，但OJ系统是字符级比对，多一个空格就是格式错误。

第二个细节是数组越界和下标错位。比如 for 循环里用 <= 还是 <，边界情况没有输出。我见过最多的错误是数组开小了，题目说输入不超过100个字符，有些同学定义了 char s[100]，结果存字符串时还要预留一个位置给结尾的 \0，实际最多只能装99个字符，输入100个字符就溢出了。复试机试不像平时开发，越界不会崩溃但会读到脏数据，排查起来极其痛苦。

第三个细节是变量类型选择不当。整数用 int，大整数用 long long，浮点数用 double 而不是 float。浮点数比较时不要直接 a == b，而是看两者差值的绝对值是否小于一个很小的阈值，比如 1e-6。这些习惯在平时写业务代码时可能无所谓，但机试题目往往刻意卡这些边界。

第四个细节是递归函数缺少终止条件导致的栈溢出。写递归时先问自己三个问题：终止条件是什么？递归参数如何向终止条件逼近？返回值如何累加或传递？这三个问题任何一个答不上来，递归代码基本就是错的。

第五个细节其实跟技术无关，是时间分配策略。三小时五道题，正确的节奏是先花五分钟把五道题全看一遍，评估难易程度，先做送分题，再做中等题，最后啃难题。有些同学第一题写得很顺利就飘了，结果在第五题上死磕了四十分钟，最后没时间检查前四题的边界条件，导致送分题反而因为格式问题扣了分。我当年做第五题花的时间最多，但做之前已经把前四题全部提交并检查过一遍了。

我把这些细节总结成一个表格方便你考前快速翻阅：

4. 一套能直接复用的刷题方法论

光做完上面五道题还远远不够，你需要一套可持续复用的刷题方法论。这些年我帮别人做复试辅导，最常被问到的问题是“刷多少题才够”。我的答案是：数量不是关键，关键是覆盖率和复盘深度。

先说覆盖率。复试编程题的范围就那么大，基础IO、循环递推、字符串、数组、排序、递归、简单模拟、简单动态规划。你不需要刷几百道LeetCode，就算把LeetCode刷穿了也未必对口，因为复试题目更像OJ上的基础题。建议按专题刷，每个专题刷十到十五道题，刷到自己看到题目就能条件反射地写出框架为止。专题之间可以穿插做综合题，检验知识的串联能力。

再说复盘深度。很多人刷题只看AC没有，AC了就下一题，没AC就看题解。这个习惯效率很低。一道题做完后哪怕AC了，也值得问问自己：有没有第二种解法？哪种更优？边界条件有没有可能漏掉？我的代码在最坏数据下会不会超时？把这些想明白，这道题才算真正内化了。我当年刷题时准备了一个错题本，每道错题记录三样东西：错误原因、正确思路、一句话总结的避坑技巧。考前翻一遍错题本比再刷几十道新题都有用。

刷题时的练习环境也是一个影响因素。建议用本地编译器加上一个OJ平台结合的方式，本地写代码可以开着调试器慢慢调，但限定时间内要切换到OJ风格的环境，适应没有调试信息的输出比对。复试前至少模拟三次完整的机试流程：三小时、五道题、不允许上网查资料。第一次模拟你可能手忙脚乱，到第三次基本就能摸清自己的节奏了。

另外要特别练习“手写代码”。复试机试对代码格式的要求比平时开发严格，没有自动补全和格式化，也没有智能提示，所以你要能做到裸写常见代码模板。比如 qsort 的比较函数、字符串反转的双指针写法、递归函数的标准结构，这些高频代码段最好能直接默写出来。我在复试前把排序、反转、素数判断、求最大公约数这几个基本模板写到肌肉记忆，上考场后完全不用思考就直接敲出来，节省了大量时间用于检查边界情况。

现在有一些AI编程助手可以用来辅助学习，比如用大模型分析你的代码哪里有Bug、为什么超时，这会让你的刷题效率上升不少。但要注意两点：第一，考场上不要指望AI，白板环境普遍禁止联网；第二，不要直接用AI生成的代码提交，你要自己逐行走通逻辑，否则面试环节考官一追问就穿帮了。AI适合当陪练教练，不适合当枪手。

最后分享一个我自己的复盘框架：每天刷完题后，用十五分钟做一次闪电回顾，把当天做过的题按“掌握熟练”“有思路但没写顺”“完全没思路”三个档归类。第二天优先重做“有思路但没写顺”的档，因为这部分提升空间最大。“完全没思路”的题说明知识盲区，需要回到教材找对应章节补充原理。而“掌握熟练”的题一周后快速浏览一遍思路即可，不用反复写。

为了让你更直观地理解刷题训练计划怎么排，我列出一张参考课表：

这个课表不需要严格照搬，但节奏可以参考。核心是把复习拆成“输入知识”和“输出验证”两个环节，输入靠专题刷题，输出靠模拟机试，两者交替进行才能稳步提升。

5. 从错题里提升的三个小技巧

这一节带着你从错误中挖掘提升空间。我在给学弟学妹做模拟时发现一个普遍现象：他们看到错误提示后能很快改对，但不知道为什么错了，也不总结成经验。结果考试时换个包装，同一类错误再犯一遍。复盘不是为了“把题改对”，而是为了“把这个坑记住”。这里分享三个我做错题整理时用的小技巧。

第一个技巧叫“错误归因法”。拿到一个错题时，先别急着改代码，花30秒判断错误类型到底是逻辑错误、语法错误还是边界条件遗漏。逻辑错误说明思路有漏洞，语法错误说明代码熟练度不够，边界条件遗漏说明审题不仔细。把错误类型记在错题本上，每周统计一次哪类错误最多，下周就针对性地补哪一块。比如统计发现边界条件遗漏出现五次以上，下一步刷题时就强制自己在写代码前先列出三个边界测试用例。

第二个技巧叫“伪代码先行”。遇到中等以上难度的题，先在草稿纸上写伪代码，理清流程再誊成正式代码。复试机试里最浪费时间的不是写代码，而是写了删、删了写，思路没理顺就动手，写到一半发现逻辑不对只能推倒重来。伪代码可以先不管语法细节，比如只写“如果当前字符是大写字母，计数加一”，翻译成代码时再处理 'A' 到 'Z' 的范围判断。这个习惯说实话很多人觉得多此一举，但它在考场上能有效降低逻辑混乱的概率。

第三个技巧叫“多解对比法”。同一道题至少尝试两种解法，对比它们的代码量和运行效率。比如第二题的猴子吃桃问题，既可以从第10天倒推到第1天，也可以通过数学推导直接算通项公式。多解对比可以加深你对题目的理解，面试时也能给出不同的思路，这往往能成为加分项。我在辅导时坚持让学生每道题至少想一个备选方案，哪怕备选方案相对笨拙，也比只有一个方案强得多。

错题整理还有一个容易被忽略的小环节：阶段性的重新回看。我的做法是每周把错题本从头翻一遍，每道题遮住正确思路，凭记忆写出核心代码骨架。如果写不出来，说明这道题还没内化，下周继续复习。如果三秒内能写出骨架，说明这个知识点已经具备了条件反射的能力，可以划掉了。这个做法的好处是每次都只关注“还不会的”，复习效率很高。

6. 写在最后的一些心里话

复试编程题从来都不只是考编程。它考的是你在有限资源下解决问题的能力，是你平时有没有养成严谨编码的习惯，更是你面对陌生问题时是否具备拆解它的框架。五道题看着不多，但三道小时里你的代码风格、边界意识、时间管理，全部暴露在阅卷系统面前。

我个人在实际操作中的最大体会是：把那五道高频类型的基础题练到肌肉记忆，远比去追难题偏题划算得多。每年都有同学四处搜集偏难怪题，结果复试考场上的题目简单到让人意外，反倒是输出了。编程基本功就像练字，天天写，写熟了，考场上自然就流畅了。如果你时间紧张，优先保证基础题型的熟练度，再有余力再去扩展复杂解法。

最后再分享一个考场上的实用小技巧：每做完一道题，先停下来花10秒钟完整读一遍自己的代码，用草稿纸模拟一遍样例数据的执行过程。听起来费时间，实际上能拦截掉大部分粗心错误。当年我就是靠这个习惯，在第一题上发现了自己 %lf 写成了 %f 的隐患——虽然很多编译器对这两个格式符的处理一致，但严格来说是存在平台差异的。这种检查习惯不只在考试中管用，放在工作中写任何重要的代码片段，也同样能帮你避免不必要的返工。编程这场修行，很多时候赢的不是思路，而是细节。