普及组 CSP-J 2026 初赛模拟卷 7

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

第 1 题

{{ select(1) }} 计算机内存中的每一个基本单元，都被赋予了一个唯一的序号，称为（ ）。

• 字节
• 编号
• 容量
• 地址

第 2 题

{{ select(2) }} 计算 $(ABCDEF)_{16} + (FEDCBA)_{16}$ 的二进制结果是（ ）。

• $(1101010101010101010101001)_2$
• $(1001010101010101010101001)_2$
• $(1101010101010111010101001)_2$
• $(1001011101010101010101001)_2$

第 3 题

{{ select(3) }} 十进制数 $-67$ 的八位二进制补码是（ ）。

• $(10111100)_2$
• $(10111101)_2$
• $(11000011)_2$
• $(11000010)_2$

第 4 题

{{ select(4) }} $12$ 张扑克牌，分别为黑桃、红心、梅花、方块的 J、Q、K。从中抽取三张牌，如果有对子就能获胜；如果没有对子，有黑桃 K 也能获胜。获胜的概率是（ ）。

• $43/55$
• $4/5$
• $97/110$
• $46/55$

第 5 题

{{ select(5) }} 一个链表的节点定义为：struct node { int data; node* next; };。该链表中的数据的数值从小到大排列。现在想在这个链表中插入一个新的节点，其成员 data 的值为 $20$。为了依旧满足链表从小到大的顺序，定位到需将新节点插入至指针 node* a 指向的节点的后面。正确的操作指令是（ ）。

• node* newnode;
  a -> data = 20;
  a -> next = newnode;
  newnode -> data = a -> data;
  

• node* newnode;
  newnode -> data = 20;
  a -> next = newnode;
  a -> data = newnode -> data;
  

• node* newnode;
  newnode -> data = 20;
  a -> next = newnode;
  newnode -> next = a -> next;
  

• node* newnode;
  newnode -> data = 20;
  newnode -> next = a -> next;
  a -> next = newnode;
  

第 6 题

{{ select(6) }} 算 $24$ 点游戏指的是用给出的四个数字结合加、减、乘、除运算凑出 $24$。用 $1,4,5,6$ 算 $24$ 点，下列后缀表达式中正确的是（ ）。

• 1 5 6 / - 4 /
• 5 6 / 1 - 4 /
• 4 1 5 6 / - /
• 4 1 5 6 - / /

第 7 题

{{ select(7) }} 在 C++ 语言中，char K = (char)('J'-7)，那么变量 K 代表的字母是（ ）。

• 'B'
• 'C'
• 'D'
• 'K'

第 8 题

{{ select(8) }} 字符 A~F 的出现频率分别为 $0.04, 0.09, 0.11, 0.12, 0.15, 0.49$，则这些字符所对应的哈夫曼编码可能为（ ）。

• $0,110,1110,11101,1011,11$
• $1,0,10,11,1,1$
• $0001,0000,010,011,001,1$
• $0,0110,111,1110,1011,011$

第 9 题

{{ select(9) }} 下列选项中（ ）是操作系统的名字。

• CJYYDS
• Safari
• Android
• WeChat

第 10 题

{{ select(10) }} 无向图 $G=(V,E)$，顶点集合 $V=\{a,b,c,d,e,f,g\}$，边集 $E=\{(a,b),(a,c),(b,d),(c,d),(d,e),(d,f),(e,g),(f,g)\}$，从顶点 $a$ 开始进行深度优先搜索，不能得到的顶点序列是（ ）。

• $a\ c\ d\ e\ g\ f\ b$
• $a\ b\ d\ c\ f\ g\ e$
• $a\ b\ c\ d\ e\ f\ g$
• $a\ b\ d\ f\ g\ e\ c$

第 11 题

{{ select(11) }} 给定二叉树的前序遍历序列为 $[a,b,c,d,f,g,h,i,e]$，中序遍历序列为 $[b,a,f,d,h,g,i,c,e]$，该二叉树的后序遍历的结果是（ ）。

• $[b,f,h,i,g,d,e,c,a]$
• $[b,f,g,h,i,d,e,c,a]$
• $[f,h,i,g,d,e,c,b,a]$
• $[f,h,i,g,d,c,b,e,a]$

第 12 题

现在有一个整数序列是 $5,17,28,96,13,15$，要对其进行排序。

第一次排序后：$5,17,28,13,15,96$。

第二次排序后：$5,17,13,15,28,96$。

第三次排序后：$5,13,15,17,28,96$。

根据上面前三次的排序情况，使用的排序算法可能是（ ）。 {{ select(12) }}

• 冒泡排序
• 希尔排序
• 归并排序
• 计数排序

第 13 题

{{ select(13) }} 以下算法描述正确的是（ ）。

• 算法的时间复杂度是指执行算法程序所需要的时间
• 算法必须能在执行有限个步骤之后终结
• 设计时法只需要考虑数据结构的选择和结果的准确性
• 算法的空间复杂度是指算法程序中指令（或语句）的参数

第 14 题

{{ select(14) }} 小明的小团队中只有 $10$ 个成员（算上小明），他讨厌其中的两个人，又喜欢其中的三个人。明天小明就要出差了，他可以带任意多个团队成员一起去，也可以自己一个人去。他不想和他讨厌的人出差，也不想让出差的人中一个自己喜欢的都没有。他一共有（ ）种出差人选的方案。

• $113$
• $105$
• $112$
• $104$

第 15 题

{{ select(15) }} 一个递增的 int 类型数组 $n$ 有 $200$ 个元素，如果用二分查找数组中的整数 num，则最多需要比较（ ）次就可以断定该 num 是否在数组 $n$ 中。

• $5$
• $6$
• $7$
• $8$

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

（1）

#include <iostream>
using namespace std;

bool isPrime (int n) {
    for (int i=2; i<n; ++i)
        if (n % i == 0) return false;
    return true;
}

int Euler(int n) {
    int ret = n;
    for (int i=2; i<=n; ++i)
        if (n % i == 0 && isPrime(i))
            ret = ret / i * (i-1);
    return ret;
}

int main () {
    int x;
    cin >> x; // 保证 x 是正整数且不大于 100000000
    cout << Euler(x) << endl;
    return 0;
}

判断题

第 16 题

{{ input(16) }} 当输入为 $12$ 时，程序的输出为 $4$。

第 17 题

{{ input(17) }} 将 isPrime() 函数中的 for 循环改成 for (int i=2; i*i<n; ++i)，程序结果不变。（ ）

第 18 题

{{ input(18) }} 将 ret = ret / i * (i-1); 改成 ret = ret * (i-1) / i; 结果可能与原程序结果不一样。（ ）

选择题

第 19 题

{{ select(19) }} 将 Euler() 函数中的 for 循环改成 for (int i=2; i*2<n; ++i)，下列哪一个输入的结果会与原程序结果不同？（ ）

• $25$
• $26$
• $27$
• $28$

第 20 题

{{ select(20) }} 当输入为 $2025$ 时，程序的输出为（ ）。

• $135$
• $270$
• $540$
• $1080$

（2）

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

int Deal(int n, int s, vector <int> &arr) {
    int count = 0;
    vector<int> sum;
    sum.push_back(0);
    for (int i = 1; i <= n; ++i) {
        sum.push_back(sum[i-1] + arr[i]);
    }
    for (int i = 1; i <= n; ++i) {
        int L=i,R=n;
        while (L <= R) {
            int mid = (L + R) >> 1;
            if (sum[mid] - sum[i-1] <= s) {
                L = mid + 1;
            } else {
                R = mid - 1;
            }
        }
        count += (R-i+1);
    }
    return count;
}

int main () { // 输入均为正整数
    int n, s;
    cin >> n >> s;
    vector<int> arr(n+1);
    arr[0] = 0;
    for (int i = 1; i <= n; ++i) cin >> arr[i];
    cout << Deal(n, s, arr) << endl;
    return 0;
}

判断题

第 21 题

{{ input(21) }} 输入如下时，输出为 $8$。

4 5
1 2 3 4

第 22 题

{{ input(22) }} sum[mid] - sum[i-1] 的意思为 arr[i-1] + arr[i] + ... + arr[mid]。（ ）

第 23 题

{{ input(23) }} 若输入完全对 arr 数组排序，结果与原程序结果一样。（ ）

选择题

第 24 题

{{ select(24) }} （$2$ 分） 若将主函数里的 arr[0] = 0 改为 arr[0] = 1，结果与改之前相比（ ）。

• 只可能变大
• 只可能变小
• 不变
• 可能变大也可能变小

第 25 题

{{ select(25) }} 若将 Deal() 函数中开始的 sum.push_back(0); 改为 sum.push_back(1); 结果与改之前相比（ ）。

• 一定不会变大
• 一定不会变小
• 一定不变
• 可能变大也可能变小

第 26 题

{{ select(26) }} 若输入的 $s$ 满足 $s \geq arr[1] + arr[2] + \cdots + arr[n]$，则输出必为（ ）。

• $n(n+1)/2$
• $n(n-1)/2$
• $n(n+1)$
• $n(n-1)$

（3）

#include <iostream>
using namespace std;

int Function(int a, int b) {
    if (b == 0) return 1;
    if (a-1 >= b) return Function(a-1, b) + Function(a-1, b-1);
    return Function(a-1, b-1);
}

int main() { // 输入均为正整数
    int a, b;
    cin >> a >> b;
    cout << Function(a, b) << endl;
    return 0;
}

判断题

第 27 题

{{ input(27) }} 输入 $5\ 2$ 时，程序的输出为 $10$。（ ）

第 28 题

{{ input(28) }} 输入的 $a$ 小于 $b$ 时，Function 函数可能陷入无限递归。（ ）

第 29 题

{{ input(29) }} 程序的运行时间与 $b$ 相关但与 $a$ 无关，且 $b$ 越大运行时间越长。（ ）

选择题

第 30 题

{{ select(30) }} （$2$ 分） 输入 $10\ 7$ 时，程序的输出为（ ）。

• $70$
• $120$
• $360$
• $720$

第 31 题

{{ select(31) }} 若输入的 $a$ 不变，$b$ 依次取 $1,2,\cdots,a$，则程序的输出（ ）。

• 单调变大
• 单调变小
• 先变小再变大
• 先变大再变小

第 32 题

{{ select(32) }} 若将 if (b == 0) 改成 if (b == 1)，并输入 $12\ 5$，则程序的输出为（ ）。

• $165$
• $330$
• $495$
• $792$

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

（1）（找子串个数）给定两个字符串 $a$ 和 $b$，求 $a$ 中有多少个与 $b$ 一样的子串。

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

int main () {
    int count = ①;
    string a, b;
    cin >> a >> b;
    for (int i = 0; i< a.length (); ++i) {
        int flag = ②;
        for (int j = 0; j < ③; ++j) {
            if (④) {
                flag = 1;
                break;
            }
        }
        if (flag == 0) ⑤;
    }
    cout << count << endl;
    return 0;
}

第 33 题

{{ select(33) }} ①处应填（ ）。

• $0$
• $1$
• $2$
• $3$

第 34 题

{{ select(34) }} ②处应填（ ）。

• $0$
• $1$
• $2$
• $3$

第 35 题

{{ select(35) }} ③处应填（ ）。

• a.length()
• b.length()
• a.length() - 1
• b.length() - 1

第 36 题

{{ select(36) }} ④处应填（ ）。

• a[j] != b[j]
• a[i+j] != b[i+j]
• a[j] != b[i+j]
• a[i+j] != b[j]

第 37 题

{{ select(37) }} ⑤处应填（ ）。

• break
• continue
• count = 1
• ++count

（2）（以最小代价删除字符）给定长度相同的两个字符串 $s1$ 和 $s2$，且字符串只由小写英文字母构成。现在规定，删除 'a' 的代价为 $0$，删除 'b' 的代价为 $1$，以此类推，删除 'z' 的代价为 $25$。这两个字符串都可以删除字母，求使得它们相同的最小代价。

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

int main () {
    string s1, s2;
    cin >> s1 >> s2;
    int n = s1.length();
    vector <vector<int>> dp (n+1, vector <int> (n+1));
    for (int i = 1; i <= n; ++i) {
        for (int j = 1; j <= n; ++j) {
            dp[i][j] = ①;
            if (②) {
                dp[i][j] = max(dp[i][j], ③);
            }
        }
    }
    int count = 0;
    for (int i = 0; i < n; ++i) count += ④;
    cout << ⑤ << endl;
    return 0;
}

第 38 题

{{ select(38) }} ①处应填（ ）。

• max(dp[i][j], dp[i-1][j-1])
• max(dp[i-1][j], dp[i][j-1])
• min(dp[i][j], dp[i-1][j-1])
• min(dp[i-1][j], dp[i][j-1])

第 39 题

{{ select(39) }} ②处应填（ ）。

• s1[i] == s2[j]
• s1[i-1] == s2[j-1]
• s1[i] == s2[j-1]
• s1[i-1] == s2[j]

第 40 题

{{ select(40) }} ③处应填（ ）。

• dp[i-1][j-1] + s1[i-1] - 'a'
• dp[i-1][j] + s1[i-1] - 'a'
• dp[i][j-1] + s2[j-1] - 'a'
• dp[i-1][j-1] + 2 * (s1[i-1] - 'a')

第 41 题

{{ select(41) }} ④处应填（ ）。

• s1[i] - 'a'
• s2[i] - 'a'
• s1[i] + s2[i] - 'a'
• s1[i] + s2[i] - 2 * 'a'

第 42 题

{{ select(42) }} ⑤处应填（ ）。

• dp[n][n]
• count + dp[n][n]
• count - dp[n][n]
• count - 2 * dp[n][n]