CSP-J 2026 初赛模拟试卷一

ID: 2872

客观题

尝试: 3

已通过: 0

难度: 10

上传者:

Hydro

启动计算机引导操作系统是将操作系统（ {{ select(1) }}

从磁盘调入中央处理器
从内存储器调入高速缓冲存储器
从软盘调入硬盘
从系统盘调入内存储器

Windows9x是一种（）操作系统。 {{ select(2) }}

单任务字符方式
单任务图形方式
多任务字符方式
多任务图形方式

在 $24\times 24$ 点阵的字模中，汉字“一”与“编”的字模占用字节数分别是（ )。 {{ select(3) }}

72 72
32 32
32 72
72 32

计算机的运算速度取决于给定时间内其处理器所能处理的数据量。处理器一次能处理的数据量称为字长。已知64位的奔腾处理器一次能处理64位，相当于（）字节。 {{ select(4) }}

算式 $(2047)_{10} - (3\mathrm{FF})_{16} + (2000)_{8}$ 的结果是（ {{ select(5) }}

$(2048)_{10}$
$(2049)_{10}$
$(3746)_{8}$
$(1\mathrm{AF}7)_{16}$

计算机的运算速度可以用MIPS来描述，它的含义是（ {{ select(6) }}

每秒执行百万条指令
每秒处理百万个字符
每秒执行千万条指令
每秒处理千万个字符

设栈S的初始状态为空，现有5个元素组成的序列{1,2,3,4,5}，对该序列在栈S上依次进行如下操作（从序列中的1开始，出栈后不再进栈）：进栈、出栈、进栈、进栈、出栈、进栈、出栈、进栈。出栈的元素序列是（）。 {{ select(7) }}

{5,4,3,2,1}
{2,3}
{2,3,4}
{1,3,4}

在有 $n$ 个叶节点的哈夫曼树中，节点总数为（ {{ select(8) }}

不确定
$2n - 1$
$2n + 1$
2n

电线上停着两种鸟（A和B），可以看出相邻的两只鸟将电线划分为一个线段。这些线段可分为两类：一类是线段两端的鸟种类相同，另一类是线段两端的鸟种类不同。已知电线的两个端点处恰好停着种类相同的鸟，那么两端的鸟种类不同的线段数目一定是（）。 {{ select(9) }}

奇数
偶数
可奇可偶
数目固定

从未排序序列中挑选元素，并将其依次放入已排序序列（初始时为空）的一端，这种排序方法称为（）。 {{ select(10) }}

插入排序
归并排序
选择排序
快速排序

对于一棵满二叉树，若其叶节点数为 $m$ 、分支节点数为 $L$ 、总节点数为 $n$ ，则下列关系式恒成立的是（）。 {{ select(11) }}

$n = L + m$
$L + m = 2n$
$m = L - 1$
$n = 2L - 1$

以下不是操作系统名字的是（）。 {{ select(12) }}

Windows XP
Arch/Info
Linux
OS/2

以下不是个人计算机的硬件组成部分的是（）。 {{ select(13) }}

主板
虚拟内存
总线
硬盘

已知元素（8,25,14,87,51,90,6,19,20），这些元素以（）的顺序全部入栈，再全部出栈，可使栈的出栈顺序满足：8在51之前；90在87之后；20在14之后；25在6之前；19在90之后。 {{ select(14) }}

20,6,8,51,90,25,14,19,87
51,6,19,20,14,8,87,90,25
19,20,90,8,6,25,51,14,87
6,25,51,8,20,19,90,87,14

假设我们用向量 $d = (a_{1},a_{2},\dots ,a_{5})$ 表示无向连通图 $G$ 的5个顶点的度数，下面给出的（）组 $d$ 值合理。 {{ select(15) }}

(2,2,2,2,2)
(1,2,2,1,1)
(3,3,3,2,2)
(5,4,3,2,1)

阅读程序（1）：

#include <iostream>
#include <cmath>
using namespace std;
bool IsPrime(int num) {
    for (int i=2; i<=sqrt(num); i++) {
        if (num % i == 0) return false;
    }
    return true;
}
int main() {
    int num = 0;
    cin >> num;
    if (IsPrime(num)) cout << "YES" << endl;
    else cout << "NO" << endl;
    return 0;
}

输入97时，输出为NO。 {{ select(16) }}

正确
错误

输入 119 时, 输出为 YES。 {{ select(17) }}

正确
错误

若将第 5 行的 $< =$ 改成 $<$ , 程序输出不会改变。 {{ select(18) }}

正确
错误

当程序执行第 8 行时, i 的值为 sqrt(num)。 {{ select(19) }}

正确
错误

最坏情况下, 此程序的时间复杂度是 ( )。 {{ select(20) }}

$O(\mathrm{num})$
$O(\mathrm{num}^2)$
$O(\sqrt{\mathrm{num}})$
$O(\log \mathrm{num})$

若输入为 20 以内的正整数, 则输出 YES 的概率是 ( )。 {{ select(21) }}

0.45
0.4
0.5
0.35

阅读程序（2）：

#include <bits/stdc++.h>
using namespace std;
const int mod = 2048;
long long c,n;
long long kasumi(long long x,long long mi) {
    long long res = 1;
    while (mi) {
        if (mi & 1) {
            res = (res * x) % mod;
        }
        x = (x * x) % mod;
        mi >>= 1;
    }
    return res;
}
int main() {
    cin >> n >> c;
    if (n == 3) {
        printf("%ld", c * (c - 1));
        return 0;
    }
    long long ans = ((kasumi(c-1,n) + (c-1) * kasumi(-1,n)) % mod + mod) % mod;
    cout << ans << endl;
    return 0;
}

将第 9 行和第 11 行中的圆括号去掉, 程序输出不变。 {{ select(22) }}

正确
错误

将第 12 行的 mi $> = 1$ 改为 mi $* = 0.5$ , 程序输出不变。 {{ select(23) }}

正确
错误

若输入 4 4, 输出为 78。 {{ select(24) }}

正确
错误

此程序的时间复杂度为 $O(\log n)$ 。 {{ select(25) }}

正确
错误

（4分）若输入3 4，输出为（ {{ select(26) }}

阅读程序（3）：

#include <cstdio>
int n,r,num[10000];
bool mark[10000];
void print() {
    for (int i=1; i<=r; i++)
        printf("%d\n", num[i]);
    printf("\n");
}
void search(int x) {
    for (int i=1; i<=n; i++)
        if (!mark[i]) {
            num[x] = i;
            mark[i] = true;
            if (x == r) print();
            search(x + 1);
            mark[i] = false;
        }
}
int main() {
    scanf("%d%d", &n, &r);
    search(1);
}

程序结束时，对任意 $1 \leq i \leq n$ ，都有 $\mathrm{mark}[i] = 0$ 。 {{ select(27) }}

正确
错误

若 $n < r$ ，则程序无输出。 {{ select(28) }}

正确
错误

若输入4 3，则输出中数字1和2的个数不同。 {{ select(29) }}

正确
错误

此程序的时间复杂度为 $O(n)$ 。 {{ select(30) }}

正确
错误

若输入6 3，则函数print的执行次数为（）。 {{ select(31) }}

若输入7 4，则输出的最后一行为（）。 {{ select(32) }}

4 5 6 7
7 6 5 4
4 3 2 1
1 2 3 4

完善程序（1）：

#include <iostream>
#include <algorithm>
using namespace std;
struct point { int x, y, v; } a[10000];
int cmp(const point &a, const point &b) {
    if (①) return 1;
    return 0;
}
int fat[101];
int father(int x) {
    if (fat[x] != x) return fat[x] = ②;
    return fat[x];
}
void unionn(int x, int y) {
    int fa = father(x), fb = father(y);
    if (fa != fb) fat[fa] = fb;
}
int main() {
    int i,j,n,m, k=0, ans=0, cnt=0;
    cin >> n;
    for (i=1; i<=n; i++)
        for (j=1; j<=n; j++) {
            cin >> m;
            if (m != 0) {
                k++; a[k].x=i; a[k].y=j; a[k].v=m;
            }
        }
    sort(a+1, a+1+k, ③);
    for (i=1; i<=n; i++) fat[i] = i;
    for (i=1; i<=k; i++) {
        if (father(a[i].x) != ④) {
            ans += a[i].v;
            unionn(a[i].x, a[i].y);
            cnt++;
        }
        if (⑤) break;
    }
    cout << ans << endl;
    return 0;
}

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

a.v < b.v
a.v > b.v
a.v >= b.v
a.v <= b.v

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

father(x)
father(fat[x])
fat[father(x)]
x

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

algorithm
point
cmp
sizeof(a)

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

a[i].y
father(a[i].y)
fat[a[i].y]
a[i].x

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

cnt >0
i = 1
ans == n-1
cnt == n-1

完善程序（2）：

#include <iostream>
using namespace std;
int G[5][5];
int visited[5][5];
int n = 5;
void euler(int u) {
    for (int v=0; v<n; v++) {
        if (G[u][v] && ①) {
            cout << u << "->" << v << endl;
            visited[u][v] = visited[v][u] = ②;
            ③
        }
    }
}
int main() {
    G[1][2] = G[2][1] = G[1][3] = ④ = 1;
    G[2][4] = G[4][2] = G[3][4] = ⑤ = 1;
    euler(1);
    return 0;
}

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

G[v][u]
!visited[u][v]
visited[u][v]
visited[v][u]

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

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

euler(v);
euler(u);
G[u][v]=0;
G[v][u]=0;

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

G[0][1]
G[1][0]
G[3][1]
G[0][3]

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

G[0][2]
G[2][0]
G[2][1]
G[4][3]

#CSP0007. CSP-J 2026 初赛模拟试卷一

状态

开发

支持

关于

#CSP0007. CSP-J 2026 初赛模拟试卷 一

CSP-J 2026 初赛模拟试卷 一

状态

开发

支持

关于

登录

#CSP0007. CSP-J 2026 初赛模拟试卷一

CSP-J 2026 初赛模拟试卷一