CSP-J2026题目

别@我

2026-09-19 14:57:04

发布于：新疆

31阅读

0回复

0点赞

CSP‑J2026第一轮试题

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

下列 C++ 数据类型中，能够精确存储 $10^{18}+1$ 这个整数的是（）
A. float B. long long C. double D. int
十六进制数 $2F5$ 转换为八进制数是（）
A. 1364 B. 1635 C. 1405 D. 1365
执行下列 C++ 代码，输出是（）

int a = 7, b = 3;
std::cout << a / b * b + a % b;

A. 9 B. 10 C. 7 D. 6

初始时栈为空，将 1、2、3、4 依次入栈，入栈过程中允许随时出栈。下列出栈序列中不可能出现的是（）
A. 2，4，3，1 B. 1，2，3，4
C. 3，1，2，4 D. 1，4，3，2
一棵有 100 个结点的完全二叉树，其中叶子结点个数是（）
A. 49 B. 50 C. 64 D. 51
执行下列代码后 s 的值是（）

int s = 0; 
for (int i = 1; i <= 100; i++)
    if (i % 3 == 0 || i % 5 == 0)
        s += i;

A. 3048 B. 2733 C. 2318 D. 2418

上楼梯每步可上 1 级、2 级或 3 级，从地面（可视为第 0 级）走到第 8 级台阶共有多少种不同走法（）
A. 44 B. 121 C. 149 D. 81
下图为 $5 \times 5$ 网格，行号、列号均从 0 开始，# 为障碍，. 为可通行格：

S . . # .
. . . # .
. . . # .
# # . . E
. . . # .

从 S 出发做广度优先搜索（BFS）：初始时把 S 入队；每次取出队首格子，按"上、下、左、右"（上＝行号减 1，下＝行号加 1，左＝列号减 1，右＝列号加 1）的顺序遍历它的四个相邻格子，越界、障碍或已访问的格子跳过，其余格子标记为已访问并入队。当 E 第一次入队时，已经入队过的格子（含 S 和 E）共有多少个（）
A. 15 B. 12 C. 14 D. 13

满足 $1 \le n \le 100$ 且 $\gcd(n, 60) = 6$ 的正整数 $n$ 共有多少个（）
A. 8 B. 6 C. 4 D. 5
某国硬币面值为 1 元、4 元、6 元且数量不限，凑出 9 元最少需要多少枚（）
A. 3 B. 4 C. 5 D. 2
执行下列代码，输出是（）

int a[5] = {1, 3, 5, 7, 9}; 
int *p = a + 2; 
*(p - 1) = p[0] + p[2];
p[1] = *(a + 1) - a[0];
cout << a[1] << "," << a[3];

A. 14,13 B. 8,13 C. 14,7 D. 14,2

在含 1000 个互不相同元素的升序数组中，用二分法查找给定值（返回元素位置或报告不存在），最坏情况下需要与数组元素比较多少次？（）
A. 500 B. 9 C. 11 D. 10
数组 $a[1..n]$ 的前缀和数组 $s$ （即 $s[i] = a[1] + a[2] + \cdots + a[i]$ ）满足 $s[i] = 3i^2 + i$ 。则 $a[10]$ 的值是（）
A. 252 B. 310 C. 58 D. 61
数轴上有 7 个点，坐标分别为 1、3、4、7、10、15、20。在数轴上选取一个整数坐标点 $P$ ，使 $P$ 到这 7 个点的距离之和最小，这个最小距离和是（）
A. 37 B. 42 C. 40 D. 38
一个无向图有 10 个顶点，其中 4 个顶点的度为 3，其余顶点的度均为 4，则该图的边数是（）
A. 36 B. 18 C. 17 D. 20

二、阅读程序（程序输入不超过数组或字符串定义的范围；判断题正确填 √，错误填 ×；除特殊说明外，判断题 1.5 分，选择题 3 分，共计 40 分）

程序（1）

#include <iostream>
using namespace std;
int main() {
    int n;
    cin >> n;
    int x = 1, y = 1;
    while (n > 0) {
        if (n % 2 == 0) {
            ++x;
        } else {
            ++x;
            ++y;
        }
        n = n / 2;
    }
    cout << x << ' ' << y << endl;
    return 0;
}

以下问题均假定输入的 $n$ 为不超过 $2^{31}-1$ 的非负整数。

判断题
16. 当输入为 3 时，程序输出为 3 3。（）
17. 将第 11 行的 ++x; 删除后，程序输出的两个数一定相等。（）
18. 假设输入为非负整数，则程序输出的第一个数一定不小于第二个数。（）

单选题
19. 将第 7 行的 while (n > 0) 改为 while (n >= 0) 后，程序可能出现的问题是（）。
A. 陷入死循环 B. 输出结果比原来大
C. 输出结果比原来小 D. 输出结果不受影响

当输入为 6 时，输出为（）。
A. 3 3 B. 4 2 C. 4 3 D. 5 2
若输入 $n$ 依次取遍 $0, 1, 2, \ldots, 2^{31}-1$ 中的所有整数，则程序输出的第二个数恰好为 2 的次数为（）。
A. 16 B. 30 C. 31 D. 32

程序（2）

#include <algorithm>
#include <iostream>
#include <string>
using namespace std;
int a[100007], b[100007], c[100007], carry[100007];
string input_str;
int a_len, b_len;
int main() {
    cin >> input_str;
    a_len = input_str.size();
    for (int i = 0; i < a_len; i++) {
        a[i] = input_str[a_len - i - 1] - '0';
    }
    cin >> input_str;
    b_len = input_str.size();
    for (int i = 0; i < b_len; i++) {
        b[i] = input_str[b_len - i - 1] - '0';
    }
    carry[0] = 0;
    for (int i = 0; i < max(a_len, b_len) + 1; i++) {
        c[i] = a[i] + b[i] + carry[i];
        if (c[i] >= 10) {
            carry[i + 1] = 1;
            c[i] -= 10;
        } else {
            carry[i + 1] = 0;
        }
    }
    for (int i = max(a_len, b_len); i >= 0; i--) {
        cout << c[i];
    }
    cout << endl;
    return 0;
}

本题输入的两个数均为非负整数，位数不超过 100000，可能包含前导零。

判断题
22. 当输入为 123 456 时，程序输出为 0579。（）
23. 假设输入的两个数均不含前导零，则程序输出的结果也一定不会含有前导零。（）
24. 将第 21 行改为 c[i]=a[i]+b[i]; 后，程序输出的结果一定比原来的结果小。（）

单选题
25. 当输入为 12345 678 时，输出为（）。
A. 012923 B. 013023 C. 13023 D. 130230

将第 22 行的 if (c[i]>=10) 改为 if (c[i]>10) 后，当输入为 95 15 时，输出为（）。
A. 01010 B. 110 C. 140 D. 1410
假设输入的两个数均为 $n$ 位正整数（不含前导零），且它们的和小于 $10^n$ ，则程序输出的字符串一定满足（）。
A. 第一个字符一定不为 '0'
B. 长度一定为 $n$
C. 长度一定为 $n+1$ ，且第一个字符为 '0'
D. 长度可能为 $n+2$

程序（3）

#include <iostream>
using namespace std;
bool check_prime(int x) {
    if (x <= 1) return false;
    for (int i = 2; i * i <= x; i++) {
        if (x % i == 0) return false;
    }
    return true;
}
int n;
void search_result(int x) {
    if (!check_prime(x)) return;
    if (x >= n) {
        cout << x << endl;
        return;
    }
    for (int i = 0; i <= 9; i++) {
        search_result(x * 10 + i);
    }
}
int main() {
    cin >> n;
    for (int i = 1; i <= 9; i++) search_result(i);
    return 0;
}

判断题
28. 当输入为 10 时，程序的输出共有 10 行。（）
29. 若输入的 $n$ 不大于 5，则程序的输出中一定包含 5。（）
30. 若输入的 $n$ 大于 10，将第 17 行的 for (int i=0;i<=9;i++) 改为 for (int i=1;i<=9;i+=2) 后，程序的输出结果一定不变。（）

单选题
31. 当输入为 24 时，程序输出的第 3 行为（）。
A. 23 B. 29 C. 31 D. 239

下列关于该程序输出的说法中，正确的是（）。
A. 输出的数一定按照从小到大的顺序排列
B. 随着输入 $n$ 的增大，输出的行数一定不会增加
C. 输出的数的个位数字只可能是 3 或 7
D. 输出的每个大于等于 10 的数，十进制下删去它的末位数字后得到的数一定是质数
当输入为 200 时，程序输出的行数为（）。
A. 12 B. 13 C. 14 D. 15

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

（1）（进制减半）

给定 $n,m$ ，再给定一个 $m^n$ 进制下的数 $A$ ，其各个数位上的数按照从高位到低位的顺序给出，请你将其转化为 $n$ 进制，并同样按照从高位到低位的顺序输出。

输入的第一行依次为 $n$ 、 $m$ 和 $A$ 的位数 $d$ ，接下来 $d$ 个数 $a_d, a_{d-1}, \cdots, a_1$ 从高位到低位描述各个数位上的数。

数据满足 $2 \le n, m \le 10$ ， $1 \le d \le 18$ ， $0 \le A < 2^{63}$ ，对于所有 $1 \le i \le d$ ， $0 \le a_i < m^n$ 。

以下程序按"逐位除以 $n$ "的方法完成进制转换。请补全程序。

#include <iostream>
constexpr int N = 100005;
long long b[N];
int main() {
    long long n, m, d;
    std::cin >> n >> m >> d;
    int len = 1;
    for (int i = 0; i < d; i++) {
        long long x;
        std::cin >> x;
        for (int j = len; j >= 1; j--)
            b[j] = ① ;
        b[0] = ② ;
        len++;
        for (int j = 0; j < len; j++)
            if (b[j] >= n) {
                b[j + 1] += ③ ;
                b[j] = ④ ;
                if (j + 1 == len) len++;
            }
    }
    while ( ⑤ ) len--;
    for (int i = len - 1; i >= 0; i--)
        std::cout << b[i] << ' ';
    return 0;
}

①处应填（）
A. b[j] * n B. b[j] * m
C. b[j - 1] * n D. b[j - 1] * m
②处应填（）
A. x * n B. x C. 0 D. m
③处应填（）
A. b[j] / m B. b[j] % n C. b[j] % m D. b[j] / n
④处应填（）
A. b[j] / m B. b[j] % n C. b[j] % m D. b[j] / n
⑤处应填（）
A. len > 0 && b[len - 1] == 0
B. len > 0 && b[0] == 0
C. len > 1 && b[len - 1] == 0
D. len > 1 && b[0] == 0

（2）（平衡分割）

给定一个长度为 $n$ 的字符串，其中每个字符都是一个十六进制数位。例如，字符串 016A 表示十进制下的四个数 0、1、6、10。

现在请选择 $k$ 个（ $k$ 是你选定的数）切分位置 $p_1, p_2, \ldots, p_k$ ，其中 $1 \le k < n$ ，且 $1 \le p_1 < p_2 < \cdots < p_k < n$ 。再令 $p_0 = 0$ ， $p_{k+1}=n$ 。

对于每个 $0 \le i \le k$ ，计算第 $p_i+1$ 个数到第 $p_{i+1}$ 个数的平均值，记作 $b_i$ 。你的目标是使 $b_0,b_1,\dots,b_k$ 中最大值与最小值之差尽可能小，并输出这个最小值。

其中 $2 \le n \le 20$ 。输入字符串中的字符只可能是 0～9 或 A～F。本题假定字符采用 ASCII 编码。输出答案时保留小数点后 6 位。

以下程序通过递归枚举所有可能的连续分段方案。请补全程序。

#include <algorithm>
#include <iomanip>
#include <iostream>
using namespace std;
constexpr int N = 25;
int n, a[N];
char s[N];
double ans = 1e100;
int value(char c) { return ① ; }
void split(int l, int cnt, double mnb, double mxb) {
    if (l > n) {
        if (cnt == 0) return;
        ans = min(ans, mxb - mnb);
        return;
    }
    int sum = 0;
    for ( ② ) {
        sum += a[r];
        double nwb = ③ ;
        split( ④ );
    }
}
int main() {
    cin >> n >> s + 1;
    for (int i = 1; i <= n; ++i)
        a[i] = value(s[i]);
    split( ⑤ );
    cout << fixed << setprecision(6) << ans;
    return 0;
}

①处应填（）
A. c - (c < '9' ? '0' : 'A' - 10)
B. c - (c < 'A' ? '0' : 'A' - 10)
C. c - (c < 'A' ? 'A' - 10 : '0')
D. c - (c < 'A' ? '0' : 'A' + 10)
②处应填（）
A. int r = l + 1; r <= n; ++r
B. int r = l; r < n; ++r
C. int r = l; r <= n; r += 2
D. int r = l; r <= n; ++r
③处应填（）
A. sum / (r - l + 1) * 1.0
B. sum * 1.0 / (r - l) + 1
C. sum * 1.0 / (r - l + 1)
D. (sum - a[r]) * 1.0 / (r - l + 1)
④处应填（）
A. r + 1, cnt + (r < n), min(mnb, nwb), max(mxb, nwb)
B. r + 1, cnt + (r <= n), min(mnb, nwb), max(mxb, nwb)
C. r + 1, cnt + (r < n), max(mnb, nwb), min(mxb, nwb)
D. r + 1, cnt + (r <= n), max(mnb, nwb), min(mxb, nwb)
⑤处应填（）
A. 0, 0, 1e100, -1e100 B. 0, 0, -1e100, 1e100
C. 1, 0, -1e100, 1e100 D. 1, 0, 1e100, -1e100