【2025 CSP-J 第一轮认证（入门级）真题卷】 本文为完整 43 题题干与选项的整理版，供限时自测使用；答案与逐题解析见本站另一篇《2025 CSP-J 第一轮（入门级）参考答案与逐题解析》——建议先自己做完再对答案。

⚠️ 题目整理自网络流传版本并经多来源交叉核对，若与 CCF 官方卷面有出入，以官方公布为准。

2025 年 CSP-J 第一轮认证（入门级）共 43 小题、满分 100 分：

部分 题号 题量 分值
一、单项选择题 1–15 15 每题 2 分，共 30 分
二、阅读程序 16–33 18 判断 + 选择，共 40 分
三、完善程序 34–43 10 每题 3 分，共 30 分

建议做法：按正式考试时间限时 100 分钟做完（判断题选 √ / ×），再对照解析篇逐题复盘。想直接在 OJ 上作答的同学，可以使用本站配套的 Hydro 客观题包（分 A/B/C 三卷导入）。

一、单项选择题（共 15 题，每题 2 分，共计 30 分；每题有且仅有一个正确选项）

  1. 一个 32 位无符号整数可以表示的最大值，最接近下列哪个选项？（ ） A. 4 × 10^9 B. 3 × 10^10 C. 2 × 10^9 D. 2 × 10^10

  2. 在 C++ 中，执行 int x = 255; cout << (x & (x - 1)); 后，输出的结果是？（ ） A. 255 B. 254 C. 128 D. 0

  3. 函数 calc(n) 的定义如下，则 calc(5) 的返回值是多少？（ ）

int calc(int n) {
    if (n <= 1) return 1;
    if (n % 2 == 0) return calc(n / 2) + 1;
    else return calc(n - 1) + calc(n - 2);
}

A. 5 B. 6 C. 7 D. 8

  1. 用 5 个权值 10、12、15、20、25 构造哈夫曼树，该树的带权路径长度是多少？（ ） A. 176 B. 186 C. 196 D. 206

  2. 在一个有向图中，所有顶点的入度之和等于所有顶点的出度之和，这个总和等于？（ ） A. 顶点数 B. 边数 C. 顶点数 + 边数 D. 顶点数 × 2

  3. 从 5 位男生和 4 位女生中选出 4 人组成一个学习小组，要求学习小组中男生和女生都有。有多少种不同的选法？（ ） A. 126 B. 121 C. 120 D. 100

  4. 假设 a、b、c 都是布尔变量，逻辑表达式 (a && b) || (!c && a) 的值与下列哪个表达式不始终相等？（ ） A. a && (b || !c) B. (a || !c) && (b || !c) && (a || a) C. a && (!b || c) D. !(!a || !b) || (a && !c)

  5. 已知 f[0] = 1，f[1] = 1，并且对于所有 n ≥ 2 有 f[n] = (f[n-1] + f[n-2]) % 7，那么 f[2025] 的值是多少？（ ） A. 2 B. 4 C. 5 D. 6

  6. 下列关于 C++ string 类的说法，正确的是？（ ） A. string 对象的长度在创建后不能改变。 B. 可以使用 + 运算符直接连接一个 string 对象和一个 char 类型的字符。 C. string 的 length() 和 size() 方法返回的值可能不同。 D. string 对象必须以 ‘\0’ 结尾，且这个结尾符计入 length()。

  7. 考虑以下 C++ 函数：

void solve(int &a, int b) {
    a = a + b;
    b = a - b;
    a = a - b;
}
int main() {
    int x = 5, y = 10;
    solve(x, y);
}

在 main 函数调用 solve 后，x 和 y 的值分别是？（ ）

A. 5, 10 B. 10, 5 C. 10, 10 D. 5, 5

  1. 一个 8×8 的棋盘，左上角坐标为 (1,1)，右下角为 (8,8)。一个机器人从 (1,1) 出发，每次只能向右或向下走一格。要到达 (4,5)，有多少种不同的路径？（ ） A. 20 B. 35 C. 56 D. 70

  2. 某同学用冒泡排序对数组 {6, 1, 5, 2, 4} 进行升序排序，请问需要进行多少次元素交换？（ ） A. 5 B. 6 C. 7 D. 8

  3. 十进制数 720 和八进制数 270 的和用十六进制表示是多少？（ ） A. 388₁₆ B. 3DE₁₆ C. 288₁₆ D. 990₁₆

  4. 一棵包含 1000 个结点的完全二叉树，其叶子结点的数量是多少？（ ） A. 499 B. 512 C. 500 D. 501

  5. 给定一个初始为空的整数栈 S 和一个空的队列 P。我们按顺序处理输入的整数队列 A：7、5、8、3、1、4、2。对于队列 A 中的每一个数，执行以下规则：如果该数是奇数，则将其压入栈 S；如果该数是偶数，且栈 S 非空，则弹出一个栈顶元素，并加入到队列 P 的末尾；如果该数是偶数，且栈 S 为空，则不进行任何操作。当队列 A 中的所有数都处理完毕后，队列 P 的内容是什么？（ ） A. 5, 1, 3 B. 7, 5, 3 C. 3, 1, 5 D. 5, 1, 3, 7

二、阅读程序（判断题正确选 √、错误选 ×；除特殊说明外判断题 1.5 分，选择题 3 分，共计 40 分）

程序（1）

#include <algorithm>
#include <cstdio>
#include <cstring>
inline int gcd(int a, int b) {
    if (b == 0) return a;
    return gcd(b, a % b);          // 第 7 行
}
int main() {
    int n;
    scanf("%d", &n);
    int ans = 0;
    for (int i = 1; i <= n; ++i) {
        for (int j = i + 1; j <= n; ++j) {
            for (int k = j + 1; k <= n; ++k) {
                if (gcd(i, j) == 1 && gcd(j, k) == 1   // 第 16 行
                    && gcd(i, k) == 1) {
                    ++ans;
                }
            }
        }
    }
    printf("%d\n", ans);
    return 0;
}

  1. （1 分）当输入为 2 时，程序并不会执行第 16 行的判断语句。（ ） A. √ B. ×

  2. 将第 16 行中的 && gcd(i, k) == 1 删去不会影响程序运行结果。（ ） A. √ B. ×

  3. 当输入的 n ≥ 3 的时候，程序总是输出一个正整数。（ ） A. √ B. ×

  4. 将第 7 行的 gcd(b, a % b) 改为 gcd(a, a % b) 后，程序可能出现的问题是（ ） A. 输出的答案大于原答案。 B. 输出的答案小于原答案。 C. 程序有可能陷入死循环。 D. 可能发生整型溢出问题。

  5. 当输入为 8 的时候，输出为（ ） A. 37 B. 42 C. 35 D. 25

  6. 调用 gcd(36, 42) 会返回（ ） A. 6 B. 252 C. 3 D. 2

程序（2）

#include <algorithm>
#include <cstdio>
#include <cstring>
#define ll long long
int n, k;
int a[200007];
int ans[200007];
int main() {
    scanf("%d%d", &n, &k);
    for (int i = 1; i <= n; ++i) {
        scanf("%d", &a[i]);
    }
    std::sort(a + 1, a + n + 1);                       // 第 13 行
    n = std::unique(a + 1, a + n + 1) - a - 1;         // 第 14 行
    for (int i = 1, j = 0; i <= n; ++i) {
        for (; j < i && a[i] - a[j + 1] > k; ++j)      // 第 16 行
            ;
        ans[i] = ans[j] + 1;                           // 第 18 行
    }
    printf("%d\n", ans[n]);
    return 0;
}

  1. 当输入为“3 1 3 2 1”时，输出结果为 2。（ ） A. √ B. ×

  2. 假设输入的 n 为正整数，输出的答案一定小于等于 n，大于等于 1。（ ） A. √ B. ×

  3. 将第 14 行的 n = std::unique(a + 1, a + n + 1) - a - 1; 删去后，有可能出现与原本代码不同的输出结果。（ ） A. √ B. ×

  4. 假设输入的 a 数组和 k 均为正整数，执行第 18 行代码时，一定满足的条件不包括（ ） A. j <= i B. a[i] - a[j] > k C. j <= n D. a[j] < a[i]

  5. 当输入的 n = 100、k = 2、a = {1, 2, …, 100} 时，输出为（ ） A. 34 B. 100 C. 50 D. 33

  6. 假设输入的 a 数组和 k 均为正整数，但 a 数组不一定有序，则若误删去第 13 行的 std::sort(a + 1, a + n + 1);，程序有可能出现的问题有（ ） A. 输出的答案比原本答案更大 B. 输出的答案比原本答案更小 C. 出现死循环行为 D. 以上均可能发生

程序（3）

#include <algorithm>
#include <cstdio>
#include <cstring>
#define ll long long
int f[5007][5007];
int a[5007], b[5007];
int n;
int main() {
    scanf("%d", &n);
    for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
    for (int i = 1; i <= n; ++i) scanf("%d", &b[i]);
    for (int i = 1; i <= n; ++i) {                     // 第 16 行
        for (int j = 1; j <= n; ++j) {
            f[i][j] = std::max(f[i][j], std::max(f[i - 1][j], f[i][j - 1]));  // 第 18 行
            if (a[i] == b[j]) {
                f[i][j] = std::max(f[i][j], f[i - 1][j - 1] + 1);
            }
        }
    }
    printf("%d\n", f[n][n]);
    return 0;
}

  1. 当输入“4 1 2 3 4 1 3 2 2”时，输出为 2。（ ） A. √ B. ×

  2. 当程序运行完毕后，对于所有的 1 ≤ i, j ≤ n，都一定有 f[i][j] ≤ f[n][n]。（ ） A. √ B. ×

  3. 将第 18 行的 f[i][j] = std::max(f[i][j], std::max(f[i - 1][j], f[i][j - 1])); 删去后，并不影响程序运行结果。（ ） A. √ B. ×

  4. 输出的答案满足的性质有（ ） A. 小于等于 n B. 大于等于 0 C. 不一定大于等于 1 D. 以上均是

  5. 如果在第 16 行的循环前加上以下两行：std::sort(a + 1, a + n + 1); std::sort(b + 1, b + n + 1);，则答案会（ ） A. 变大或不变 B. 变小或不变 C. 一定变大 D. 不变

  6. 如果输入的 a = {1, 2, …, n}，而且 b 数组中数字均为 1~n 中的正整数，则上述代码等价于下面哪个问题？（ ） A. 求 b 数组去重后的长度 B. 求 b 数组的最长上升子序列 C. 求 b 数组的长度 D. 求 b 数组的最大值

三、完善程序（单选题，每小题 3 分，共计 30 分）

程序（1）字符串解码

“行程长度编码”（Run-Length Encoding）是一种无损压缩算法，常用于压缩重复字符较多的数据，以减少存储空间。假设原始字符串不包含数字字符。压缩规则如下：i）如果原始字符串中一个字符连续出现 N 次（N ≥ 2），在压缩字符串中它被表示为“字符 + 数字 N”。例如，编码“A12”代表 12 个连续的字符 A。ii）如果原始字符串中一个字符只出现 1 次，在压缩字符串中它就表示为该字符本身。例如，编码“B”代表 1 个字符 B。

以下程序实现读取压缩字符串并输出其原始的、解压后的形式。试补全程序。

#include <cctype>
#include <iostream>
#include <string>
using namespace std;

int main() {
    string z;
    cin >> z;
    string s = "";

    for (int i = 0; i < z.length(); ) {
        char ch = z[i];

        if (① && isdigit(z[i + 1])) {
            i++;
            int count = 0;
            while (i < z.length() && isdigit(z[i])) {
                count = ②;
                i++;
            }
            for (int j = 0; j < ③; ++j) {
                s += ch;
            }
        } else {
            s += ④;
            ⑤;
        }
    }

    cout << s << endl;
    return 0;
}

  1. ①处应填（ ） A. i < z.length() B. i - 1 >= 0 C. i + 1 < z.length() D. isdigit(z[i])

  2. ②处应填（ ） A. count + (z[i] - '0') B. count * 10 + (z[i] - '0') C. z[i] - '0' D. count + 1

  3. ③处应填（ ） A. count - 1 B. count C. 10 D. z[i] - '0'

  4. ④处应填（ ） A. z[i + 1] B. ch C. z.back() D. (char)z[i] + 1

  5. ⑤处应填（ ） A. i-- B. i = i + 2 C. i++ D. 不执行任何操作

程序（2）精明与糊涂

有 N 个人，分为两类：i）精明人：永远能正确判断其他人是精明还是糊涂；ii）糊涂人：判断不可靠，会给出随机的判断。已知精明人严格占据多数，即如果精明人有 k 个，则满足 k > N/2。你只能通过函数 query(i, j) 让第 i 个人判断第 j 个人：返回 true 表示判断结果为“精明人”；返回 false 表示判断结果为“糊涂人”。你的目标是，通过这些互相判断，找出至少一个百分之百能确定的精明人。同时，你无需关心 query(i, j) 的内部实现。

以下程序利用“精明人占多数”的优势。设想一个“消除”的过程，让人们互相判断并进行抵消。经过若干轮抵消后，最终留下的候选者必然属于多数派，即精明人。

例如，假设有三个人 0、1、2。如果 0 说 1 是糊涂人，而 1 也说 0 是糊涂人，则 0 和 1 至少有一个是糊涂人。程序将同时淘汰 0 和 1。由于三人里至少有两个精明人，我们确定 2 是精明人。

试补全程序。

#include <iostream>
#include <vector>
using namespace std;

int N;
bool query(int i, int j);

int main() {
    cin >> N;

    int candidate = 0;
    int count = ①;

    for (int i = 1; i < N; ++i) {
        if (②) {
            candidate = i;
            count = 1;
        } else {
            if (③) {
                ④;
            } else {
                count++;
            }
        }
    }

    cout << ⑤ << endl;
    return 0;
}

  1. ①处应填（ ） A. 0 B. 1 C. N D. -1

  2. ②处应填（ ） A. count < 0 B. count == 1 C. count == 0 D. query(candidate, i) == false

  3. ③处应填（ ） A. query(candidate, i) == false B. query(i, candidate) == true C. query(candidate, i) == false && query(i, candidate) == false D. query(candidate, i) == false || query(i, candidate) == false

  4. ④处应填（ ） A. count-- B. break C. count++ D. candidate = i

  5. ⑤处应填（ ） A. N - 1 B. count C. candidate D. 0

做完之后

  • 想对答案与看分步推导，请移步本站《2025 CSP-J 第一轮（入门级）参考答案与逐题解析》；
  • 想在 OJ 上直接作答并自动判分，本站提供了分三卷的 Hydro 客观题包（单选 / 阅读程序 / 完善程序），导入后即可布置练习或测验。

来源说明：题目整理自网络流传的 CCF《2025 CCF 非专业级别软件能力认证第一轮（CSP-J1）入门级 C++ 语言试题》版本，并经多来源交叉核对排版与选项；若与官方卷面不一致，以 CCF 官方公布为准。仅供学习交流。