#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) }}