---

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

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

---

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

• $(11010101010101010101001)_2$
• $(10010101010101010101001)_2$
• $(11010101010101110101001)_2$
• $(10010111010101010101001)_2$

---

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

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

---

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

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

---

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

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

---

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

• 156/-4/
• 56/1-4/
• 4156/-/
• 4156-//

---

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

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

---

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

• 0,110,111,1110,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. 无向图 $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) }}

• acdegfb
• abdcfge
• abcdcfg
• abdfgec

---

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

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

• 113
• 105
• 112
• 104

---

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

• 5
• 6
• 7
• 8

---

阅读程序（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 是正整数且不大于 10000000
    cout << Euler(x) << endl;
    return 0;
}

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

• 正确
• 错误

---

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

• 正确
• 错误

---

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

• 正确
• 错误

---

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

• 25
• 26
• 27
• 28

---

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

• 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. 输入如下时，输出为8。 {{ select(21) }}

• 正确
• 错误

---

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

• 正确
• 错误

---

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

• 正确
• 错误

---

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

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

---

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

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

---

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

• $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. 输入5 2时，程序的输出为10。 {{ select(27) }}

• 正确
• 错误

---

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

• 正确
• 错误

---

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

• 正确
• 错误

---

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

• 70
• 120
• 360
• 720

---

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

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

---

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

• 165
• 330
• 495
• 792

---

完善程序（1）：

#include <iostream>
#include <string>
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）：

#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[i] - '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]

---