ID: 6170

客观题

尝试: 0

已通过: 0

难度: (无)

上传者:

cjzm

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

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

A. 字节
B. 编号
C. 容量
D. 地址

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

A. $(110101010101010101010101001)_2$
B. $(100101010101010101010101001)_2$
C. $(110101010101011101010101001)_2$
D. $(100101110101010101010101001)_2$

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

A. $(10111100)_2$
B. $(10111101)_2$
C. $(11000011)_2$
D. $(11000010)_2$

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

A. $43/55$
B. $4/5$
C. $97/110$
D. $46/55$

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

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;

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

A. 1 5 6 / - 4 /
B. 5 6 / 1 - 4 /
C. 4 1 5 6 / - /
D. 4 1 5 6 - / /

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

A. 'B'
B. 'C'
C. 'D'
D. 'K'

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

A. 0, 110, 111, 1110, 1011, 11
B. 1, 0, 10, 11, 1, 1
C. 0001, 0000, 010, 011, 001, 1
D. 0, 0110, 111, 1110, 1011, 011

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

A. CJYYDS
B. Safari
C. Android
D. WeChat

无向图 $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$ 开始进行深度优先搜索，不能得到的顶点序列是（）。 {{ select(10) }}

A. $a\ c\ d\ e\ g\ f\ b$
B. $a\ b\ d\ c\ f\ g\ e$
C. $a\ b\ c\ d\ e\ f\ g$
D. $a\ b\ d\ f\ g\ e\ c$

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

A. $[b, f, h, i, g, d, e, c, a]$
B. $[b, f, g, h, i, d, e, c, a]$
C. $[f, h, i, g, d, e, c, b, a]$
D. $[f, h, i, g, d, c, b, e, a]$

现在有一个整数序列是 $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) }}

A. 冒泡排序
B. 希尔排序
C. 归并排序
D. 计数排序

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

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

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

A. $113$
B. $105$
C. $112$
D. $104$

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

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

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

(1)

 1 #include <iostream>
 2 using namespace std;
 3 
 4 bool isPrime (int n) {
 5     for (int i=2; i<n; ++i)
 6         if (n % i == 0) return false;
 7     return true;
 8 }
 9 
10 int Euler(int n) {
11     int ret = n;
12     for (int i=2; i<=n; ++i)
13         if (n % i == 0 && isPrime(i))
14             ret = ret / i * (i-1);
15     return ret;
16 }
17 
18 int main () {
19     int x;
20     cin >> x; // 保证 x 是正整数且不大于 100000000
21     cout << Euler(x) << endl;
22     return 0;
23 }

判断题

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

A. 正确
B. 错误

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

A. 正确
B. 错误

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

A. 正确
B. 错误

选择题

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

A. $25$
B. $26$
C. $27$
D. $28$

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

A. $135$
B. $270$
C. $540$
D. $1080$

(2)

 1 #include <iostream>
 2 #include <vector>
 3 using namespace std;
 4 int Deal(int n, int s, vector <int> &arr) {
 5     int count = 0;
 6     vector<int> sum;
 7     sum.push_back(0);
 8     for (int i = 1; i <= n; ++i) {
 9         sum.push_back(sum[i-1] + arr[i]);
10     }
11     for (int i = 1; i <= n; ++i) {
12         int L=i ,R=n;
13         while (L <= R) {
14             int mid = (L + R) >> 1;
15             if (sum[mid] - sum[i-1] <= s) {
16                 L = mid + 1;
17             } else {
18                 R = mid - 1;
19             }
20         }
21         count += (R-i+1);
22     }
23     return count;
24 }
25 int main () { // 输入均为正整数
26     int n, s;
27     cin >> n >> s;
28     vector<int> arr(n+1);
29     arr[0] = 0;
30     for (int i = 1 ; i <= n; ++i) cin >> arr[i];
31     cout << Deal(n, s, arr) << endl;
32     return 0;
33 }

判断题

输入如下时，输出为 $8$ 。

4 5
1 2 3 4

A. 正确
B. 错误

sum[mid] - sum[i-1] 的意思为 $arr[i-1] + arr[i] + \cdots + arr[mid]$ 。 {{ select(22) }}

A. 正确
B. 错误

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

A. 正确
B. 错误

选择题

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

A. 只可能变大
B. 只可能变小
C. 不变
D. 可能变大也可能变小

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

A. 一定不会变大
B. 一定不会变小
C. 一定不变
D. 可能变大也可能变小

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

A. $n(n+1)/2$
B. $n(n-1)/2$
C. $n(n+1)$
D. $n(n-1)$

(3)

 1 #include <iostream>
 2 using namespace std;
 3 int Function(int a, int b) {
 4     if (b == 0) return 1;
 5     if (a-1 >= b) return Function(a-1, b) + Function(a-1, b-1);
 6     return Function(a-1, b-1);
 7 }
 8 int main() { // 输入均为正整数
 9     int a, b;
10     cin >> a >> b;
11     cout << Function(a, b) << endl;
12     return 0;
13 }

判断题

输入 5 2 时，程序的输出为 $10$ 。 {{ select(27) }}

A. 正确
B. 错误

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

A. 正确
B. 错误

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

A. 正确
B. 错误

选择题

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

A. $70$
B. $120$
C. $360$
D. $720$

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

A. 单调变大
B. 单调变小
C. 先变小再变大
D. 先变大再变小

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

A. $165$
B. $330$
C. $495$
D. $792$

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

(1)

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

 1 #include <iostream>
 2 #include <cstring>
 3 using namespace std;
 4 int main () {
 5     int count = ①;
 6     string a, b;
 7     cin >> a >> b;
 8     for (int i= 0; i< a.length (); ++i) {
 9         int flag = ②;
10         for (int j = 0; j < ③; ++j) {
11             if (④) {
12                 flag = 1;
13                 break;
14             }
15         }
16         if (flag == 0) ⑤;
17     }
18     cout << count << endl;
19     return 0;
20 }

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

A. 0
B. 1
C. 2
D. 3

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

A. 0
B. 1
C. 2
D. 3

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

A. a.length()
B. b.length()
C. a.length() - 1
D. b.length() - 1

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

A. a[j] != b[j]
B. a[i+j] != b[i+j]
C. a[j] != b[i+j]
D. a[i+j] != b[j]

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

A. break
B. continue
C. count = 1
D. ++count

(2)

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

 1 #include <iostream>
 2 #include <vector>
 3 #include <algorithm>
 4 #include <cstring>
 5 using namespace std;
 6 int main () {
 7     string s1, s2;
 8     cin >> s1 >> s2;
 9     int n = s1.length();
10     vector< vector <int> > dp (n+1, vector <int> (n+1));
11     for (int i = 1; i <= n; ++i) {
12         for (int j = 1; j <= n; ++j) {
13             dp[i][j] = ①;
14             if (②) {
15                 dp[i][j] = max(dp[i][j], ③);
16             }
17         }
18     }
19     int count = 0;
20     for (int i = 0; i < n; ++i) count += ④;
21     cout << ⑤ << endl;
22     return 0;
23 }

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

A. max(dp[i][j], dp[i-1][j-1])
B. max(dp[i-1][j], dp[i][j-1])
C. min(dp[i][j], dp[i-1][j-1])
D. min(dp[i-1][j], dp[i][j-1])

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

A. s1[i] == s2[j]
B. s1[i-1] == s2[j-1]
C. s1[i] == s2[j-1]
D. s1[i-1] == s2[j]

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

A. dp[i-1][j-1] + s1[i-1] - 'a'
B. dp[i-1][j] + s1[i-1] - 'a'
C. dp[i][j-1] + s2[i-1] - 'a'
D. dp[i-1][j-1] + 2 * (s1[i-1] - 'a')

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

A. s1[i] - 'a'
B. s2[i] - 'a'
C. s1[i] + s2[i] - 'a'
D. s1[i] + s2[i] - 2 * 'a'

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

A. dp[n][n]
B. count + dp[n][n]
C. count - dp[n][n]
D. count - 2 * dp[n][n]

#cspjmn7. CSP-J 2026 初赛模拟卷 7

CSP-J 2026 初赛模拟卷 7

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

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

(1)

(2)

(3)

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

(1)

(2)

#cspjmn7. CSP-J 2026 初赛模拟卷 7

CSP-J 2026 初赛模拟卷 7

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

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

(1)

(2)

(3)

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

(1)

(2)

登录