CSP-J2024题目答案解析：计算机常识与算法考点梳理

简介：这份PDF资料面向备战CSP-J（信息学奥赛入门级）的考生与指导教师，聚焦2024年真题与逐题解析，可用于日常刷题自测、赛前查漏补缺，也可作为教师讲评时的参考底稿。内容分为单项选择题与阅读程序两大板块：前者覆盖int类型存储范围、格雷码、存储单位换算、C++基本数据类型与循环语句、ASCII码运算、二分查找比较次数、无向图度数和、二叉树遍历互推、栈的出栈序列、排列组合计数以及编译器作用等基础考点；后者结合质数判断、函数封装调用、数组与字符串输入输出、位运算等程序片段，逐条分析判断题与选择题的判断依据。压缩包共1个PDF文件，体积约797KB，单文件集中排布，题解紧随题目，便于对照阅读与打印。已有7555人学习下载，热度较高，适合需要系统过一遍真题、理清易错概念并提升编程基本功的入门级选手使用。

1. 什么是 CSP-J2024 题目+答案解析：一份把「计算机常识」集中摊开的资料

第一次看到「CSP-J2024题目+答案解析」这几个字，很多人以为它只是一套卷子。它确实是卷子，但更像驾照考试的科目一：单题不难，覆盖面却广得离谱——从 1MB 等于多少个二进制位，到二叉树的前中后序遍历，再到汉诺塔怎么挪盘子，全在里面。这种题最不讲情面的地方在于，你不会就是不会，蒙不出来，也不存在「写个循环试试」的余地。

这份资料的价值就在「答案解析」四个字上。题目只告诉你选 A 还是选 B，解析告诉你为什么 struct 不算基本数据类型、为什么把循环条件从i*i<=n改成i<=n结果一点没变、为什么dp[i-3]会运行时崩溃而不是编译报错。把这些零散的知识点串起来，你对「计算机到底在干什么」会有一层新的认知。

2. 为什么这类题要这么出：从「会敲代码」到「懂计算机」

写得出一个能跑的循环，和知道这个循环在做什么，是两码事。入门级认证的题目设计思路，正是想把这两者区分开：它不指望你写出多复杂的程序，但要确认你对计算机的基本规则有清晰的认知。这份 2024 的题目加解析，正好把这种出题逻辑完整地展示了一遍。

2.1 入门级认证的定位：先证明你懂规则，再谈写程序

打个比方，学开车先要学科目一。你可以把车开走，但不知道红灯该停、不知道虚线能不能压，那不叫会开车，叫侥幸。编程也一样：你能用int存数字，但不知道它最多存到二十一亿多就溢出，那不叫掌握，叫碰运气。

所以单项选择题里会出现「int 的存储范围」这种题。它考的不是背诵，而是「一个 32 位有符号整数，最高位拿去当符号位，剩下 31 位表示数值」这个结构。你理解了结构，范围自然就推出来了；你只会背数字，换个位宽就崩。格雷码、进制换算、ASCII 码运算也是同一个逻辑——它们都是计算机内部表示信息的基本方式，懂了表示方式，很多看起来玄学的现象就有了答案。

这类题还有个隐藏目的：筛掉「只会调库」的路径依赖。现实里写代码，sort一调、框架一上，很多东西不用管；但一旦遇到边界问题、精度问题、性能问题，底层认知的缺口就露出来了。题目正是在这些缺口上出题。

2.2 三类题型的分工：选择题打地基、阅读程序看理解、完善程序考推理

这套卷子的结构非常清晰，三块内容各有各的考察目标：

选择题是「面」，阅读程序是「深度」，完善程序是「推理」。三者叠在一起，构成一个从「知道」到「读懂」再到「会补」的阶梯。很多人在选择题上失分，不是因为难，而是因为知识点零散、凭印象作答；在阅读程序上失分，往往是因为习惯性地「从第一行往下读」，而不是先找输入输出。

阅读程序题的策略其实是反直觉的：先看main函数读了什么、输出了什么，再回头看被调用的函数。这跟读一篇陌生代码库的顺序一样——先找入口，再钻细节。完善程序题则更像填空式推理：先搞清楚这段代码想干什么，再判断每个空位上「必须是什么」，剩下的选项自然排除。

2.3 为什么解析比题目本身更值钱

一道选择题的答案是四个字母之一，但解析是一段完整的推理。比如那道「以下哪个不是 C++ 中的基本数据类型」，答案是 struct。如果只记答案，下次遇到 class、union、enum 还是会犹豫；但解析会告诉你：基本数据类型是语言内置的、不可再拆的原子类型，int、float、char、bool 属于这一类，而 struct 是把若干已有类型打包成的新类型，是复合类型。

再比如那道「哪个不是 C++ 中的循环语句」，选项里塞了个 repeat-until。这个语法在某些教学语言里确实存在，语义是「先执行一次，再判断是否继续」，和 do-while 相似但条件相反。如果你只知道 C++ 有 for、while、do-while 三种，那这道题靠排除法也能做；但知道 repeat-until 的来历，你就能顺手理解「不同语言的语法糖长得像，语义未必一样」这件事。

解析的另一个作用是暴露「思维捷径」的失效点。很多人做存储换算题，习惯性写 1024，结果题目问的是「多少二进制位」，1024 是字节数，还得乘 8。这种错不是知识错，是审题习惯错，而解析恰好能把这类习惯问题点出来。

3. 单项选择题里那些「看着眼熟却答不对」的点

选择题失分最集中的地方，往往不是最难的题，而是那些「以为自己会」的题。存储换算、进制、ASCII 码，这些内容在教材里出现过太多次，反而容易被草草扫过。这一章挑几个高频失分点摊开讲。

3.1 位与字节：1MB 到底是多少个二进制位

这道题的问法很朴素：已知 1KB 是 1024 字节，1MB 是 1024KB，问 1MB 是多少个二进制位。失分点几乎全在最后一步——算完字节数就收手了，忘了字节和位之间还差一个 8。

用一段代码把这个换算关系写清楚最直观：

# 存储单位换算：从 MB 一路拆到 bit mb = 1 kb = mb * 1024 # 1MB = 1024KB byte_count = kb * 1024 # 1KB = 1024 字节 bit_count = byte_count * 8 # 1 字节 = 8 位 print(byte_count) # 1048576，也就是 2 的 20 次方 print(bit_count) # 8388608，也就是 2 的 23 次方

参数说明很关键：1024是 2 的 10 次方，来自二进制体系；8是一个字节包含的位数，来自硬件对「一个字节能表示多少种状态」的约定。两个数字来源不同，不能混用。代码里把每一步单独一行，就是为了让「乘 1024」和「乘 8」这两件事在视觉上分开——手算时写成一长串，最容易漏掉后一个。

这里还有个容易混淆的点：硬盘厂商习惯用十进制标容量，1GB 按十亿字节算；操作系统按二进制报容量，同一块盘显示出来就小一圈。这不属于本题考点，但理解了 1024 和 1000 的分歧，就不会再被「买的盘怎么少了」这类现象绊住。

3.2 格雷码与进制换算：相邻只差一位的编码

格雷码这道题，很多人第一反应是「没背过，跳过」。其实它有一个非常好记的性质：任意两个相邻的编码，二进制位上只差一位。

打个比方，老式电梯的楼层指示灯，换层时只灭一盏、亮一盏，不会整排灯一起乱闪。格雷码就是这个思路：从 3 到 4，普通二进制是 011 变 100，三位全变；格雷码只变一位，中间过程不会出现一堆位同时翻转造成的瞬时错误。旋转编码器、位置传感器这类硬件特别吃这一套，因为多位同时跳变时，采样瞬间可能读到完全错误的中间值。

生成规则也不复杂，第 i 个格雷码等于i ^ (i >> 1)：

# 生成 3 位格雷码，并验证相邻两项只差一位 def gray(n): return [i ^ (i >> 1) for i in range(1 << n)] codes = gray(3) print(codes) # [0, 1, 3, 2, 6, 7, 5, 4] # 相邻两项做异或，结果应当是 1、2、4 这类 2 的幂，代表只差一位 diffs = [codes[i] ^ codes[i + 1] for i in range(len(codes) - 1)] print(diffs) # [1, 2, 1, 4, 1, 2, 1]

i >> 1是右移一位，相当于把数字砍掉最低位；再和原数异或，就把「相邻两个数之间变化的那一位」保留下来了。判断diffs里是不是全是 2 的幂，就等价于判断「相邻只差一位」。做选择题时不用现推，按这个规则列几项，把选项对一遍即可——这比死记序列稳得多。

进制换算题的通用解法是「先化成十进制再比」，因为人对十进制的直觉最可靠。二进制的 1011、八进制的 13、十六进制的 B，看着毫不相干，化成十进制都是 11。

3.3 数据结构与算法常识：栈、图、二叉树、二分

这四类题在卷子里出现的频率很高，而且每一类都有一个「一句话就能说清」的核心性质。

栈是「先进后出」，像羽毛球筒：先塞进去的球，最后才能拿出来。判断出栈顺序是否可能，靠的是模拟：给一个目标序列，从头到尾走一遍，需要谁就把谁压进去，压到目标元素后立刻弹出，中途如果栈顶对不上就判死。这类题不需要背结论，动手模拟三十秒就能判定。很多人翻车是因为只看第一两个元素就开始下结论，忽略了后面可能出现的「卡死」情况。

无向图那条性质更干脆：所有顶点的度数之和等于边数的两倍。原因是一条边有两个端点，给两端各贡献一个度。这个结论在有向图里是「入度之和等于出度之和等于边数」，别混着记。理解了「一条边贡献两个度」，就不会再选「等于边数」那个选项。

二叉树遍历的三种顺序，记法只有一句话：前序是「根左右」，中序是「左根右」，后序是「左右根」，这里的「左右」指子树。给前序和中序求后序，方法是：前序的第一个一定是根；拿这个根去中序里切一刀，左边是左子树的所有节点，右边是右子树的所有节点；再看前序里对应的段，递归处理。以卷子里那道题为例，前序是 A、B、D、E、C、F、G，中序是 D、B、E、A、F、C、G，A 是根，中序里 A 左边的 D、B、E 构成左子树，右边构成右子树，逐层切下去就能还原整棵树。这类题不靠背，靠画图，纸上画三分钟比脑子里想十分钟准。

二分查找的比较次数，本质是「每次砍一半，砍几次能砍到只剩一个」。n 个元素最多比较的次数是 log2n 向上取整再加一次。做选择题时用具体数字代进去验证最快：8 个元素砍三次到 1 个，再加一次判断，心里就有数了。

3.4 语言常识与操作系统识别

语言类题目往往不难，但容易「想多了」。基本数据类型那题，正确答案是 struct。理由前面说过：基本类型是语言内置的原子类型，struct 是拿已有类型拼出来的复合类型。这里容易犯的错是把「常用」当「基本」，struct 确实常用，但常用的不一定基本。

循环语句那题，repeat-until 不属于 C++ 的语法。这类题的通用判断方法是：先想这门语言的标准语法里有没有这个关键字，再想它的语义能不能用已有语句等价实现。C++ 里「先执行再判断」用 do-while 就够了，repeat-until 是别的语言里的写法。

ASCII 码那道题问的是字符加一个数字之后变成什么。这个知识点唯一的抓手是记住几个锚点：小写 a 是 97，大写 A 是 65，数字字符 0 是 48。有了锚点，剩下的靠加减和「字母在表里是连续排列的」推出来。'a' 加 13 落在 n 上，就是顺着字母表往后数十三格。

至于「哪个不是操作系统」那道题，选项里塞了一个记事本类的文本工具。判断标准很朴素：操作系统是管理硬件、给程序提供运行环境的那一层，文本编辑器只是跑在它上面的一个应用。这个区分一旦建立，以后看到「浏览器是不是操作系统」「虚拟机算不算操作系统」这类讨论，也能自己判断。

4. 阅读程序题：把代码当黑匣子，只看输入和输出

阅读程序题的迷惑性在于代码长。三段程序加起来几十行，逐行读很容易迷失在变量名里。更有效的做法是先不看实现，只看main里读了什么、算了什么、打印了什么，把这段代码当成一个黑匣子：给它什么输入，它吐什么输出。

4.1 质数统计题的三种改法：改效率不改结果

第一段程序有三个函数：判断单个数字是不是质数、统计某个范围内质数的个数、求某个范围内质数的和。main只读一个整数，输出「个数 和」两个值。结构清楚了，后面的判断题就变成了「改动会不会影响黑匣子的输出」。

题目里有这么一问：把判断质数函数里的循环条件从i*i <= n改成i <= n/2，输入 20 时输出会不会变。答案是不会。原因是这两种写法判断的都是「有没有因子」，只是搜索范围不同：前者搜到平方根就停，因为如果 n 有大于平方根的因子，必然对应一个小于平方根的因子；后者搜到一半，范围更宽，多搜的那些数字不可能整除 n，只是白跑。

还有一问是把条件改成i <= n，问输出会不会变。同样不变，只是更慢。这里有个容易被忽略的判断：循环条件放宽，只会让判断多跑几轮，不会改变「是不是质数」的结论，因为判断的核心是「有没有整除」，而不是「跑了几轮」。

这类题的正确读法是先找出「决定输出的那一行」，再看改动是否触及那一行。改动落在效率上，输出不变；改动落在判断逻辑上，输出才可能变。区分这两者，是这个题型最核心的能力。

4.2 动态规划那道题：相邻必选一个的最小和

第二段程序是一段动态规划，处理的问题可以这样描述：给一个数组，要求相邻两个位置中至少选一个，让选中的数字之和最小。这个设定和「不能选相邻两家的盗贼」是镜像关系——一个是不能都选，一个是不能都不选。

int compute(vector<int> &cost) { int n = cost.size(); vector<int> dp(n + 1, 0); dp[1] = cost[0]; // 只有一个位置时，只能选它 for (int i = 2; i <= n; i++) { // 到第 i 个位置为止的最小和：要么上一个位置已选（dp[i-1]）， // 要么上上个位置已选、跳过上一个（dp[i-2]），两者取小再加当前代价 dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i - 1]; } return min(dp[n], dp[n - 1]); // 末尾两种收尾方式取更优 }

dp[i]表示「考虑到第 i 个位置时，满足约束的最小代价」，转移方程里的两个候选分别对应「上一个位置选了」和「上一个位置没选但上上个选了」。最后的返回值取dp[n]和dp[n-1]的较小值，是因为收尾时最后一个位置选或不选都合法，取更省的那个。

这里有个特别值得注意的判断题：把dp[i-1]改成dp[i-3]，会不会编译错误？答案是运行时可能出错，编译不会报错。原因是数组下标在编译期不检查，dp[i-3]在 i 小于 3 时就是负数下标，属于越界访问，表现是运行崩溃或者读到乱七八糟的值。编译错误和运行错误的区别，是这套题反复在考的点——前者是语法层面就不合法，编译器直接拒绝；后者是语法合法但行为不可预测。

另一道判断题问「程序是否总是输出数组中最小的元素」，答案是错。因为约束是「相邻至少选一个」，最优解可能不得不选一个较大的数来满足约束，简单取最小值会违反规则。这类题的迷惑性在于：程序里确实有min，但min是在「两个合法方案」之间取小，不是在「所有元素」之间取小。

4.3 递归函数那张「乘法伪装成加法」的脸

第三段程序里有个递归函数，写成一个数加上「自己少一层」的结果，终止条件是第二参数为 0 时直接返回第一个参数。这其实就是乘法：a 加自己 b 次，等于 a 乘 b。外层再套一个平方，最终的输出是乘积的平方。

读这类题有个技巧：手动展开两三层。输入 2 和 3，展开成 2 +（2 +（2 + 2）），一共四个 2，结果是 8，再平方是 64。注意判断题里说的「返回值为 64」是错的，64 是最终输出，函数的返回值是 8。这种「返回值」和「程序输出」的区分，是判断题最爱设的坑。

还有一问是把函数体改成「加上 a-1、b-1」的形式。这时候每一项都在变，手算是最稳的办法：输入 3 和 3，展开是 3 + 2 + 1 + 0，结果是 6，平方得到最终输出。不要试图套公式，这类改动往往打破原有的等价关系，硬套旧结论必翻车。

至于「b 为负数时会无限递归」这一问，答案是正确。终止条件只覆盖了 b 等于 0 的情况，b 为负数时每次减一只会越减越远，永远碰不到 0，栈帧越堆越深，最后栈溢出。这是递归题里最经典的血泪经验：终止条件必须覆盖所有可能的输入方向，而不能只覆盖「正常路径」。

4.4 判断改动的后果：编译错误还是运行错误

把这个题型里的判断题归纳一下，其实只问三件事：改动会不会改变结果、改动会不会引入错误、错误发生在哪个阶段。

「改变结果」看的是逻辑路径有没有被切断；「引入错误」看的是边界条件有没有被破坏；「哪个阶段」看的是编译器能不能在编译期发现。数组越界、除以零、无限递归，都属于编译期看不出来、运行起来才炸的类型；类型不匹配、变量未声明、括号不配对，才是编译器能拦下来的。

把这三件事分开想，阅读程序题的判断题基本不会连错。真正容易出错的是「改动既没改变结果、也没引入错误，只是变慢」这种情形——很多人一看代码变了，就默认答案会变。

5. 常见误区与易混概念：几组最容易翻车的对照

这套卷子里有一批概念，名字相近、出场频率又高，初学的人经常把它们当成同一件事。下面几组是我认为最容易混的，按「混在哪、为什么混、怎么分」拆开说。

5.1 编译错误、运行错误与逻辑错误

易混点：都是「程序出问题了」，很多人不区分，统称「报错」。

为什么混：三者都可能表现为「程序没给出正确结果」，而且在初学阶段，一个括号写错和一个数组越界，看到的都是屏幕上跳出红字或者程序直接退出。

怎么区分：编译错误发生在「翻译阶段」，代码根本没跑起来，原因通常是语法不合法、类型不匹配、变量没声明；运行错误发生在「执行阶段」，代码跑起来了但中途出事，比如数组越界、除以零、栈溢出；逻辑错误最隐蔽，程序正常跑完、正常输出，只是结果不对。卷子里那道dp[i-3]的题，就是典型的「不会编译错误，但可能运行错误」——下标是合法表达式，编译器没理由拒绝，但运行到 i 小于 3 时就出界了。

判断方法很实用：问自己「这行代码让不让人读懂语法」。读得懂语法，编译器就放行；至于放行之后会不会炸，那是运行时的事。

5.2 效率优化与结果正确性

易混点：代码改动了，结果一定变。

为什么混：平时写代码，改动往往伴随行为变化，久而久之形成「改了就不同」的直觉。

怎么区分：看改动落在「搜索范围」还是「判断逻辑」上。把质数判断的循环从i*i <= n放宽到i <= n，改的是搜索范围，判断条件还是「能不能整除」，结论不变，只是多跑几轮。把「能不能整除」改成「能不能被 2 整除」，改的是判断逻辑，结论立刻错。卷子里连着几道题都在考这个区分，说明它是高频考点。

顺带说一句，优化和正确性在真实项目里也常被混为一谈。有人为了提速把边界检查去掉，测试环境跑得好好的，线上遇到脏数据就翻车。这类教训在卷子上是选择题，在工程里是事故。

5.3 前序、中序、后序：三种遍历不是随便起的名字

易混点：三个名字都带「序」，容易记串。

为什么混：中文名里没有直接体现「根在哪个位置」，只能靠口诀硬背，背完就忘。

怎么区分：把「根」的位置当成锚点。前序是根最先被访问，中序是根在中间被访问，后序是根最后被访问。剩下两个位置永远是「先左后右」，这条不变。所以三种顺序其实是同一个遍历路线，只是「什么时候记录根节点」不同。

还原二叉树时也用这个锚点：前序的第一个必是根，后序的最后一个必是根，中序则要靠「根的左边是左子树、右边是右子树」来切分。抓住这一点，画图还原就是机械操作，不需要灵感。

5.4 枚举上界为什么取平方根，而不是取一半

易混点：判断一个数是不是完全平方数，枚举到哪儿为止？

为什么混：直觉上「一半」听起来更保险，范围更大似乎更不容易漏。

怎么区分：想清楚要找的是什么。完全平方数要找的是「某个整数的平方等于它」，枚举的对象是平方根，自然只需要枚举到「这个数开方」的位置，再往上枚举，平方一定超过原数。取一半属于「范围给多了」，虽然不容易漏，但多跑了很多无用功。卷子里的完善程序题，上界取的就是开方后的整数部分。

这里附带一个易错细节：开方结果要向下取整，并且要处理浮点误差。整数开方在某些边界值上可能算出 4.999999 这类结果，向下取整就变成 4，漏掉正确答案。稳妥写法是用整数方式求上界，或者判断时用乘法而不是除法。

5.5 递归终止条件：写 0 还是写 1

易混点：汉诺塔这类递归，终止条件到底该写盘子数为 0 还是 1？

为什么混：两种写法在很多实现里都能跑出正确结果，于是被认为「随便写」。

怎么区分：写 1 表示「只剩一个盘子时直接搬过去」，写 0 表示「没有盘子时什么都不做」。两种都能终止递归，但对应的递归体不一样：如果终止条件写 1，递归体里要先搬 n-1 个、再搬最大的、再搬 n-1 个；如果写 0，递归体里的「搬一个」这一步就要单独处理。卷子里那段的写法是「为 1 时直接搬」，所以空位上填的是 1，而不是 0。

判断方法：看递归体里有没有「显式搬运一个盘子」的动作。有，终止条件就写 1；没有、全靠递归下探到底再统一处理，终止条件写 0。这个问题没有标准答案，只有「和递归体配套」这一条原则。

6. 什么时候该用这份解析，什么时候别在上面耗时间

这份资料最适合两类场景。一类是「刚接触这类题型，需要建立知识地图」：把单项选择题过一遍，你会发现考点集中在几个固定板块——数据表示、数据结构性质、语言常识、算法复杂度，每个板块的题量都不大，但每次都会考。这时候用解析把每个板块的核心结论固定下来，比刷十套卷子都管用。

另一类是「做题时对了但说不清为什么」：选择题蒙对、判断题凭感觉选对，这种情况最危险，因为换个问法就错。解析的价值在这里体现得最明显——它把「为什么是这个答案」摊开，让你能自查是哪一步的推理断了。

不适合的场景也得说清楚。如果你连基本的循环、数组都还没写熟，直接啃阅读程序题会很痛苦，因为题目默认你能读懂几十行代码的结构，这个前提不具备，看解析也只是看懂字面意思。另外，如果你已经有比较完整的知识体系，只是想在考前找手感，那通读解析的收益很低，直接限时做题、只对答案、错题再翻解析，效率高得多。

下面这张表可以帮你快速判断自己该用哪种方式：

有个细节值得提醒：阅读程序题的解析里，往往会写「直接模拟即可」这类话。这不是敷衍，而是这类题的正确解法确实是模拟。但模拟也要讲方法——在纸上画一张表，把每一步的变量值列出来，比在脑子里空转可靠得多。我见过太多人在这类题上「想当然」，结果第一步就记错了变量的初值。

说个我自己的教训。早些年做这类判断题，我习惯先看选项再回头读代码，觉得这样有针对性。结果连着翻车好几次：选项里埋的坑，恰恰是利用了「先看选项会形成的先入为主」。比如问「输出是否总是最小值」，脑子里先有了「这题在考最小值」的预设，读代码时就会不自觉地把min当成对全体元素取最小，而忽略它其实是在两个状态之间取小。从那以后我每次做阅读程序题，都强制自己先用一句话写下「这段程序在算什么」，写不出来就不看选项。这个习惯救了我很多次。

希望这份梳理能帮到你。题目会过时，解析里的推理方式不会——真正值得带走的，是那套「先定性、再定量、最后验边界」的路子。想要完整题目与逐题解析，可以取用这份整理好的资料对照着过一遍。

本文还有配套的精品资源，点击获取