#rscK002. RSC 2026中学组样题
RSC 2026中学组样题
RSC 2026中学组样题
一、单项选择题
1.在 C++中,下列哪种写法不是合法的函数定义(即无法通过编译)?
{{ select(1) }}
- int myFunction(int a, int b) { return a + b; }
- myFunction(int a, int b){ return a + b;}
- int myFunction(int a, int b);
- int myFunction(int, int);
2.已知小写字母 a的 ASCII 码值为 97(十进制),那么小写字母k的 ASCII 码值为?
{{ select(2) }}
- 107
- 106
- 108
- 105
3.以下关于 C++中数组初始化的说法,正确的是?
{{ select(3) }}
- 数组可以不初始化直接使用
- 初始化数组时,元素个数可以超过数组定义的大小
- 可以部分初始化数组,未初始化的元素默认值为0
- 数组初始化只能在定义时进行,不能在其他地方进行
4.在 C++中,if-else if语句用于?
{{ select(4) }}
- 依次判断多个不同条件,并执行首次满足条件的对应代码块
- 只判断一个条件并执行相应代码块
- 循环执行一段代码
- 处理异常情况
5.已知 int a=5,b=2,c=7;,则表达式(a>b)||(c<b)&&(a!=c)的值为?
{{ select(5) }}
- true
- false
- 1
- 0
6.计算机中,以下哪种存储设备的数据读写速度相对较慢 ?
{{ select(6) }}
- 内存
- 固态硬盘
- 机械硬盘
- 高速缓存
7.在 C++中,变量名不能以下列哪个字符开头?
{{ select(7) }}
- 字母
- 下划线
- 数字
- 美元符号($)
8.以下 C++ 代码片段试图实现”与非门“逻辑(即:两个条件都为真时,结果为假;否则结果为真),但其中可能错误,请找出并修正它: ?
bool nand(bool a,bool b){
return !(a&&b);
}
{{ select(8) }}
- 代码完全正确,无需修改
- 代码错误,应改为 return!(a || b);
- 代码错误,应改为 return a && b;
- 代码错误,应改为 return a || b;
9.已知二维数组 int arr[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};
在 C++ 中,数组元素在内存中按行优先顺序连续存储。若 arr[0]的地址为 100(十进制),每个 int 类型占用 4字节,则表达式 *(arr[1]+2)的值为(),以及该表达式对应的内存地址是( )。
{{ select(9) }}
- 7,112
- 6,120
- 7,124
- 8,116
10.计算机中,操作系统的主要任务不包括 ?
{{ select(10) }}
- 管理计算机硬件资源
- 提供用户操作界面
- 开发应用软件
- 管理计算机软件资源
11.在 C++中,for 循环的一般形式为 for(初始化表达式;条件表达式;更新表达式){ 循环体 },其中更新表达式的作用是?
{{ select(11) }}
- 初始化循环变量
- 判断循环是否继续执行
- 在每次循环结束后更新循环变量的值
- 执行循环体中的代码
12.以下关于 C++ 程序执行流程的说法,正确的是 ?
{{ select(12) }}
- 程序从 main 函数开始执行
- 程序从第一个函数开始执行
- 程序可以没有 main 数
- 函数必须在 main 函数之后定义
13.若有定义 int a=3,b=4;,则表达式(a+b)%2的值为?
{{ select(13) }}
- 0
- 1
- 2
- 3
14.在 C++中,以下哪种数据类型用于存储单精度浮点数 ?
{{ select(14) }}
- double
- float
- int
- char
15.以下是一段 C++程序:
#include <iostream>
using namespace std;
int main(){
int i=1;
do{
cout<<i<<" ";
i++;
}while(i<=5);
return 0;
}
程序的输出结果是()?
{{ select(15) }}
- 1 2 3 4 5
- 1 2 3 4
- 2 3 4 5
- 5 4 3 2 1
16.以下 C++ 代码中,函数 matrixMultiplication 的作用是 ?
void matrixMultiplication(int matl[][3], int mat2[][3], int result[][3]){ }
{{ select(16) }}
- 对矩阵进行转置
- 计算两个矩阵的乘法
- 对矩阵进行加法运算
- 计算矩阵的行列式
17.关于 C++ 异常处理 try-catch-throw,下列说法正确的是 ?
{{ select(17) }}
- try 块中出现异常会直接终止程序
- catch 块可以不写,单独使用 try 依然合法
- throw 用于主动抛出异常,catch 用于捕获并处理
- 异常处理只能处理编译期错误,不能处理运行错误
18.以下 C++ 代码的输出是 ?
const int num = 10:
num = 20;
std::cout << num;
{{ select(18) }}
- 10
- 20
- 程序错误
- 无法确定
19.下面代码执行后,变量t的类型是 ?
typedef int INT
num=20;
std::cout << num;
{{ select(19) }}
- int
- INT
- 无法确定
- 程序错误
20.关于 C++ 结构体(struct)与类(class),下列说法正确的是?
{{ select(20) }}
- 结构体默认成员权限是 private,类默认是 public
- 结构体默认成员权限是 public,类默认是 private
- 结构体不能有成员函数
- 类不能定义成员变量子串长度
21.动态分配的数组应如何释放 ?
{{ select(21) }}
- delete arr;
- delete arr[];
- delete[] arr;
- delete(arr);
22.函数重载的必要条件是?
{{ select(22) }}
- 返回值类型不同
- 参数列表不同
- 函数名不同
- 作用域不同
23.以下代码定义了两个 isPrime 函数:
bool isPrime(int n){/* 实现略 */}
bool isPrime(double num){/*实现略 */}
这体现了 C++的什么特性?
{{ select(23) }}
- 动态内存分配
- 函数递归
- 函数重载
- 模板函数
24.二维数组 matrix[3][3]初始化为{{1,2,3},{4,5,6},{7,8,9}},matrix[1][2]的值是 ?
{{ select(24) }}
- 5
- 6
- 8
- 9
25.以下链表插入函数:
void insertFront(Node* head, int val){
Node* newNode = new Node{val, head->next}
head->next= newNode;
}
执行后,链表会发生什么变化?
{{ select(25) }}
- 在头节点前插入新节点
- 在头节点后插入新节点
- 替换头节点的数据
- 链表变为环形结构
26.在C++ 中,break 语句在循环里的作用是?
{{ select(26) }}
- 跳过本次循环剩余语句,直接进入下一次循环
- 结束当前整个循环,继续执行循环后面的代码
- 让程序暂停等待输入
- 抛出异常并终止程序
27.在 C++ 中,编写质数判断函数时,以下哪种循环条件是实际开发中性能最优且无精度风险的 ?
{{ select(27) }}
- i<n
- i<=sqrt(n)
- i*i<=n
- i<=n/2
28.以下函数用于生成质数数组:
int* generatePrimes(int size){
int* primes = new int[size];
int count =0, num= 2;
while (count < size){
if (isPrime(num)){
primes[count]= num;
count++;
}
num++;
}
return primes;
}
若 size=5,返回的质数是?
{{ select(28) }}
- 3,5,7,11,13
- 2,3,5,7,11
- 2,3,5,7
- 2,4,6,8,10
29.贪心算法解决硬币找零问题时 ?
{{ select(29) }}
- 总是选择面值最小的硬币
- 总是选择面值最大的硬币
- 随机选择硬币
- 需要回溯
30.以下递归函数:
int mystery(int n){
if(n==0) return 1;
return n * mystery(n-1);
}
调用mystery(4)的返回值是?
{{ select(30) }}
- 4
- 12
- 24
- 48
31.关于 float 和 double,正确的是 ?
{{ select(31) }}
- float 存储圆周率到小数点后 10 位足够精确
- double 和 float 占用内存相同
- 科学计算应优先选 double
- float num=3.1415926535; 能精确存储
32.int num=(int)3.14; 的值是 ?
{{ select(32) }}
- 3
- 3.14
- 4
- 0
33.int a=5,b=3; 执行 a+=b; 后 a的值是?
{{ select(33) }}
- 8
- 2
- 15
- 53
34.以下代码输出是( )
for(int i=1; i=5; i++}{
if(i==3) continue;
cout<<i<<" ";
}
{{ select(34) }}
- 1,2,3,4,5
- 1,2,4,5
- 3,4,5
- 1,2
35.已知 int arr[5]={1,2,3,4,5};,执行 arr[2]+= arr[4];后,arr[2]的值为 ?
{{ select(35) }}
- 3
- 4
- 8
- 15
36.C++ 中,关于函数默认参数,说法正确的是()。
{{ select(36) }}
- 默认参数必须放在参数列表最右侧
- 默认参数可以放在任意位置
- 调用函数时必须传入所有参数
- 一个函数不能有多个默认参数
37.以下函数调用输出是?
void func(int a=1,int b=2){cout<<a<<b;}
func(3);
{{ select(37) }}
- 12
- 32
- 31
- 编译错误
38.(5>3)&&(4<2)的结果是?
程序如下:
#include <iostream>
using namespace std;
int main(){
cout<<((5>3)&&(4<2))<< endl;
return 0;
}
{{ select(38) }}
- true
- false
- 1
- 0
39.以下代码输出是?
int i=0;
while(i< 5){
if(i==2){
i++;
continue;
}
cout<<i<<" ";
i++;
}
{{ select(39) }}
- 0 1 3 4
- 0 1 2 3 4
- 0 1 2 4
- 0 1 3
40.执行以下 C++ 代码,输出结果是?
#include <iostream>
using namespace std;
int main(){
int x=10;
int y=5;
int z=0;
if(x>y){
z=x+y;
if(z%2==0){
z+=3;
} else {
z-=2;
}
} else {
z=x-y;
}
cout << z << endl;
return 0;
}
{{ select(40) }}
- 15
- 18
- 13
- 8
二、阅读程序题
(一)阅读程序,回答下面问题
#include <iostream>
#include <vector>
using namespace std;
//动态创建 nxn 矩阵并填充连续自然数
int** createMatrix(int n){
int** mat = new int*[n];
for (int i=0;i<n; i++){
mat[i]= new int[n];
for(int j=0;j<n; j++){
mat[i][j]=i*n+j+1;
}
}
return mat;
}
//递归计算矩阵主对角线元素和
int diagonalSum(int** mat,int size,int row=0){
if(row >= size) return 0;
return mat[row][row]+diagonalSum(mat, size, row + 1);
}
void freeMatrix(int** mat, int n){
for (int i=0;i<n;i++){
delete[] mat[i];
}
delete[] mat;
}
int main(){
int n=3;
int** matrix= createMatrix(n);
cout <<"主对角线和:" << diagonalSum(matrix, n)<< endl;
// 修改矩阵元素
matrix[1][1]= 100;
cout<<"修改后对角线和:"<< diagonalSum(matrix,n)<< endl;
freeMatrix(matrix, n);
return 0;
}
(1).createMatrix(3)生成的矩阵是?{{ select(41) }}
- {{1,2,3}, {4,5,6}, {7,8,9}}
- {{1,4,7}, {2,5,8},{3,6,9}}
- {0,1,2}, {3,4,5}, {6,7,8}}
- {1,1,1}, {2,2,2}, {3,3,3}}
(2).首次调用 diagonalSum(matrix,3)的返回值是?{{ select(42) }}
- 6
- 15
- 24
- 30
(3).freeMatrix 函数的作用是:?{{ select(43) }}
- 重置矩阵元素为 0
- 释放动态分配的二维数组内存
- 删除矩阵指针
- 压缩矩阵存储空间
(4).修改 matrix[1][1]=100 后,第二次 diagonalsum 的返回值是?{{ select(44) }}
- 15
- 105
- 110
- 115
(二)请阅读以下代码,然后回答问题:
程序代码:
#include <iostream>
using namespace std;
struct Node{
int data;
Node* next;
Node(int val):data(val), next(nullptr){}
};
// 创建链表:生成n个节点的链表,节点值=索引值*2
Node* createList(int n){
if(n <= 0) return nullptr;
Node* head = new Node(0);
Node* current = head;
for (int i=1;i<n;i++){
current->next =new Node(i*2);
current=current->next;
}
return head;
}
// 递归计算链表节点值的总和
int sumList(Node* node){
if(node == nullptr) return 0;
return node->data + sumList(node->next);
}
//递归反转链表
Node* reverseList(Node* head){
if(head == nullptr || head->next == nullptr)
return head;
Node* newHead =reverseList(head->next);
head->next->next = head;
head->next = nullptr;
return newHead;
}
void printList(Node* head){
while (head){
cout <<head->data<<" ";
head = head->next;
cout << endl;
}
}
void deleteList(Node* head){
while (head) {
Node* temp = head;
head = head->next;
delete temp;
}
}
int main(){
Node* list = createList(4);
cout<<"Original: ";
printList(list);//输出:0 2 4 6
int sum= sumList(list);
cout <<"Sum:"<<sum<<endl; //输出:12
Node* reversed =reverseList(list);
cout << "Reversed:";
printList(reversed);//输出:6 4 2 0
deleteList(reversed);
return 0;
}
(1).createList(3)生成的链表是?{{ select(45) }}
- 0→2→4
- 2→4→6
- 0→1→2
- 1→2→3
(2).sumList(list)对原始链表的返回值是: {{ select(46) }}
- 6
- 12
- 18
- 24
(3).递归函数 reverseList 的终止条件是:{{ select(47) }}
- head->next == nullptr
- head==nullptr || head->next == nullptr
- head->data==0
- head->next->next == nullptr
(4).执行 deleteList(reversed)后未释放的内存会导致:{{ select(48) }}
- 编译错误
- 运行时崩溃
- 内存泄漏
- 数据损坏
三、完善程序题
(一)补充代码,完善程序。
//程序如下:
#include <iostream>
#include <vector>
#include <cmath>
#include <string>
// 判断质数
bool isPrime(int num){
if (num <= 1) return false;
for (int i=2;i*i<=num;i++){
if(________) return false;//填空1
}
return true;
}
//分解质因数
std::vector<int> primeFactorization(int num){
std::vector<int> primeFactors;
for(int i=2;i<=num; i++){
while(__________){//填空2
primeFactors.push_back(i);
num /= i;
}
}
return primeFactors;
}
//检查特殊数字组合
bool checkSpecialCombination(int password, int specialNumber){
std::string passwordStr=std::to_string(password);
std::string specialStr=std::to_string(specialNumber);
return passwordStr.find(specialStr)!= std::string::npos;
}
// 快速幂算法
int fastPower(int base, int exponent){
int result = 1;
while (exponent>0){
if(exponent%2==1){
result = result * base;
}
base *= base;
exponent /= 2;
}
return result;
}
int main(){
int password=123456;
//测试质数判断
std::cout<<"123456 是质数吗?" << std::boolalpha <<__________<< std::endl;//填空3
// 测试质因数分解
std::vector<int> factors=primeFactorization(password);
std::cout<<"123456 的质因数:";
for(int factor:factors){
std::cout<<factor<<" ";
}
std::cout << std::endl;
//测试特殊数字组合检査
std::cout<<"包含'123'吗?"<< checkSpecialCombination________<< std::endl;//填室4
// 测试快速幂
std::cout<<"2^10="<< fastPower(2, 10)<< std::endl;
return 0;
}
请把你的答案填入以下对应空位中(不要输入多余空格)。
填空1:{{ input(49) }}
填空2:{{ input(50) }}
填空3:{{ input(51) }}
填空4:{{ input(52) }}
(二)空间站能源管理员
你是一名空间站能源管理员,负责为三个机器人分配能量块。能量块编号为质数(2,3,5……),程序需实现:
1.按能量块大小排序
2.平均分配能量给三个机器人
3.使用二分查找定位特定能量块
4.动态管理能量块数组
#include <iostream>
#include <algorithm>
using namespace std;
// 质数判断
bool isPrime(int num){
if(num <= 1) return false;
for(int i=2; i*i<=num; i++){
if(________) return false;// 填空1 请通过余数计算
}
return true;
}
//能量排序
void sortEnergyBlocks(int blocks[],int size){
sort(blocks, blocks+size);// 使用标准库排序
for (int i=0;i<size/2; i++){
________;//填空2:交换元素实现降序
}
}
// 二分查找
int binarySearch(int blocks[], int size, int target){
int left=0,right=size-1;
while (left <= right) {
int mid = (left + right) /2;
if(blocks[mid]== target) return mid;
if(blocks[mid]< target){
________;// 填空3
} else {
right= mid -1;
}
}
return -1;
}
//能量分配
void distributeEnergy(int blocks[], int size){
int robot1=0,robot2 =0, robot3 = 0;
for (int i=0;i< size; i++){
switch(i%3){
case 0:robot1 += blocks[i]; break;
case 1:robot2 += blocks[i]; break;
case 2:robot3 += blocks[i]; break;
}
}
cout<<"机器人1能量:"<< robot1 << endl;
cout<<"机器人2能量:"<< robot2 << endl;
cout<<"机器人3能量:"<< robot3 << endl;
}
int main(){
const int SIZE=6;
int* energyBlocks = new int[SIZE];
// 生成能量块(前6个质数)
int count = 0;
for (int num = 2; count< SIZE; num++){
if(isPrime(num)){
energyBlocks[count++]= num;
}
}
//任务1:能量块排序
sortEnergyBlocks(energyBlocks, SIZE);
cout<<"能量块降序:";
for (int i= 0;i< SIZE; i++){
cout << energyBlocks[i]<<" ";
}
cout << endl;
//任务2:查找特定能量块
int target = 7;
int pos = binarySearch(energyBlocks,________,target);//填空 4
cout << target << "的位置:" << pos << endl;
//任务3:分配能量
distributeEnergy(energyBlocks, SIZE);
delete[] energyBlocks;
return 0;
}
请把你的答案填入以下对应空位中(不要输入多余空格)。
填空1:{{ input(53) }}
填空2:{{ input(54) }}
填空3:{{ input(55) }}
填空4:{{ input(56) }}