2026信息素养初赛-数字守艺人-初中组C++(困难)

一、单选题（共10题）

第1题

在"数字守艺人"场景中，选手需要用C++实现剪纸纹样的批量生成，要求根据输入纹复杂度等级（1-5级）自动

生成对应数量的基础纹样组合。已知1级对应1种基础纹样，每提升1级，基础纹样数量翻倍。若使用递归函计算n

级对应的纹样总数，下列关于递归终止条件写法正确的是？

A.if(n==0)return0;

B.if(n==1)return1;

C.if(n==5)return16;

D.if(n<1)return-1;

答案：B

解析：根据题目描述，1级对应1种基础纹样，这是递归的起始条件也就终止边界。当n=1时，不需要再

递归调用，直接返回1；对于n>1的情况，递归调用计算n-1级的结果再乘以2。选项A的终止条件n0不符合题目定义

的等级范围；选项C的n5是特定等级的结果，不通用终止条件；选项D的返回-1是错误处理，不递归终止的逻辑

边界。

第2题

某选手在模拟皮影戏角色动作的C++程序中，使用STL的

vector

存储角色的关键帧坐标。现在需要从已有100个

关键帧中，筛选出x坐标大于300且y坐标小于200的关键帧，并按x坐标降序排。下列代码片段中，最符合C++11

及以上标准且效率最优的是？

A.

vector<Point>res;

for(autop:frames){

if(p.x>300&&p.y<200)res.push_back(p);

}

sort(res.begin(),res.end(),[](constPoint&a,constPoint&b){

returna.x>b.x;

});

B.

vector<Point>res;

copy_if(frames.begin(),frames.end(),back_inserter(res),

[](constPoint&p){returnp.x>300&&p.y<200;});

sort(res.begin(),res.end(),greater<Point>());

C.

vector<Point>res(frames);

res.erase(remove_if(res.begin(),res.end(),

[](constPoint&p){returnp.x<=300||p.y>=200;}),res.end());

sort(res.begin(),res.end(),[](constPoint&a,constPoint&b){

returna.x<b.x;

});

D.

vector<Point>res;

for(inti=0;i<frames.size();i++){

if(frames[i].x>300&&frames[i].y<200)res.push_back(frames[i]);

}

sort(res.begin(),res.end());

答案：A

解析：选项A使用C++11的范围for循环遍历，结合lambda表达式作为排序规则，逻辑清晰且符合标准筛选和排序

的逻辑完全匹配题目要求；选项B中

greater<Point>()

需要Point类型重载

>

运算符，题目未说明该类型有此重

载，会导致编译错误；选项C的排序规则是按x升序，不符合题目要求的降序；选项D

的

sort(res.begin(),res.end())

同样需要Point类型重载

<

运算符，且默认是升序，不符合需求。

第3题

在"数字守艺人"的非遗数据管理任务中，选手需要用C++存储1000条皮影刻制的工艺数据，每包含匠人ID、

刻制时长、残次率三个字段，要求能快速根据匠人ID查询对应的平均刻制时长。下列数据结构中，最适合实现该需

求的是？

A.std::array

B.std::list

C.std::map

D.std::queue

答案：C

解析：std::map是基于红黑树的有序关联容器，支持以键值对的形式存储数据这里可用匠人ID作为键，存储对

应的时长统计数据，能够实现O(logn)时间复杂度的查询操作，完全符合快速查询的需求。std::array是固定大小的数

组，不适合动态的键值查询；std::list是双向链表，查询效率为O(n)，对于1000条数据效率较低；std::queue是队

列，仅支持先进先出的操作无法实现按ID查询。

第4题

某选手在模拟陶瓷烧制窑温监控的C++程序中，需要实现一个函数根据当前窑温（整数类型）返回对应的烧制阶

段：温度<800为"预热期"，800≤温度<1200为"升温期"，1200≤温度<1350为"烧制期"，温度≥1350为"冷却期"。下

列函数实现中，符合C++语法规范且逻辑正确的是？

A.

stringgetStage(inttemp){

switch(temp){

casetemp<800:return"预热期";

case800<=temp<1200:return"升温期";

case1200<=temp<1350:return"烧制期";

default:return"冷却期";

}

}

B.

stringgetStage(inttemp){

if(temp<800)return"预热期";

elseif(temp<1200)return"升温期";

elseif(temp<1350)return"烧制期";

elsereturn"冷却期";

}

C.

stringgetStage(inttemp){

returntemp<800?"预热期":

temp<1200?"升温期":

temp<1350?"烧制期":"冷却期";

}

D.

stringgetStage(inttemp){

if(temp<800){

return"预热期";

}elseif(800<=temp&&temp<1200){

return"升温期";

}elseif(1200<=temp&&temp<1350){

return"烧制期";

}else{

return"冷却期";

}

}

答案：D

解析：选项D的逻辑判断完全符合题目要求的温度区间，且语法规范，每个条件都明确写出完整围可读性

强；选项A的switch语句使用条件表达式作为case标签，不符合C++语法规范，switch的case必须是常量表达式；选

项B的第二个条件

temp<1200

在第一个条件

temp<800

不成立的情况下，等价于

800≤temp<1200

，逻辑正确

但选项D的写法更清晰严谨；选项C的三目运算符嵌套虽然逻辑正确，但可读性较差，且在复杂区间判断中容易出

错，不符合代码可读性要求。

第5题

在"数字守艺人"场景中，选手需要用C++实现二十四节气的日期计算，已知某一年立春是2月4日，每个节气间隔

约15天。现在需要计算从立春开始的第n个节气的日期（n从0开始）。下列关于闰年判断的代码，正确的是？

A.

boolisLeap(intyear){

return(year%4==0)||(year%100!=0&&year%400==0);

}

B.

boolisLeap(intyear){

return(year%4==0)&&(year%100!=0)||(year%400==0);

}

C.

boolisLeap(intyear){

return(year%4==0)&&(year%400==0||year%100!=0);

}

D.

boolisLeap(intyear){

return(year%4==0)&&(year%100==0)&&(year%400==0);

}

答案：B

解析：闰年的判断规则是能被4整除但不能被100整除，或者能被400整除。选项B的逻辑表达式符合这个规则，且

运算符优先级正确（&&优先级高于||）；选项A的逻辑错误，会把能被100整除但不能被400整除的年份判定为闰；

选项C的逻辑虽然正确，但表达式冗余；选项D的逻辑错误，只有能同时被4、100、400整除的年份才会被判定为闰

年，遗漏了能被4整除但不能被100整除的情况。

第6题

某选手在C++程序中使用

fstream

读取一个存储剪纸纹样数据的CSV文件，文件每行格式为"纹样ID,复杂度等级,使

用颜色数"。现在需要统计每个复杂度等级对应的平均颜色数。下列代码片段中，会导致程序运行错误是？

A.

map<int,pair<int,int>>stat;//等级->(总颜色数,数量)

ifstreamfin("patterns.csv");

stringline;

while(getline(fin,line)){

stringstreamss(line);

stringid,level,color;

getline(ss,id,',');

getline(ss,level,',');

getline(ss,color,',');

intl=stoi(level);

intc=stoi(color);

stat[l].first+=c;

stat[l].second++;

}

B.

unordered_map<int,double>avg;

unordered_map<int,int>count;

ifstreamfin("patterns.csv");

intid,level,color;

charcomma;

while(fin>>id>>comma>>level>>comma>>color){

avg[level]+=color;

count[level]++;

}

for(auto&p:avg){

p.second/=count[p.first];

}

C.

vector<pair<int,int>>data;//(等级,颜色数)

ifstreamfin("patterns.csv");

stringline;

while(fin>>line){

size_tpos1=line.find(',');

size_tpos2=line.find(',',pos1+1);

intlevel=stoi(line.substr(pos1+1,pos2-pos1-1));

intcolor=stoi(line.substr(pos2+1));

data.emplace_back(level,color);

}

D.

structPattern{intid;intlevel;intcolor;};

vector<Pattern>patterns;

ifstreamfin("patterns.csv");

Patternp;

while(fin>>p.id>>p.level>>p.color){

patterns.push_back(p);

}

答案：D

解析：选项D的代码中，使用

fin>>p.id>>p.level>>p.color

读取CSV文件，但是CSV文件的字段之间是逗

号分隔，而

>>

运算符默认以空白字符作为分隔，无法正确解析逗号的数据会导致读取错误程序

行结果不符合预期；其他选项都正确处理了CSV文件的逗号分隔符，能够正确读取数据。

第7题

在模拟刺绣纹样生成的C++程序中，选手需要实现一个函数，生成n×n的二维数组表示纹样，其中奇行元素

为1，偶数行的元素为0（行号从0开始）。下列函数实现中，效率最优的是？

A.

vector<vector<int>>generatePattern(intn){

vector<vector<int>>res(n,vector<int>(n,0));

for(inti=0;i<n;i+=2){

fill(res[i].begin(),res[i].end(),1);

}

returnres;

}

B.

vector<vector<int>>generatePattern(intn){

vector<vector<int>>res;

for(inti=0;i<n;i++){

vector<int>row(n,i%2==0?1:0);

res.push_back(row);

}

returnres;

}

C.

vector<vector<int>>generatePattern(intn){

vector<vector<int>>res(n);

for(inti=0;i<n;i++){

for(intj=0;j<n;j++){

res[i].push_back(i%2==0?1:0);

}

}

returnres;

}

D.

int**generatePattern(intn){

int**res=newint*[n];

for(inti=0;i<n;i++){

res[i]=newint[n];

for(intj=0;j<n;j++){

res[i][j]=i%2==0?1:0;

}

}

returnres;

}

答案：A

解析：选项A使用STL的

fill

函数批量填充行元素，避免了嵌套循环效率最高；选项B的逻辑正确，但每次创建

行向量时都要初始化所有元素，效率略低于选项A；选项C使用嵌套循环逐个添加元素，效率最低；选项D使用原生

指针创建二维数组，需要手动管理内存容易出现泄漏，且效率不如选项A。

第8题

某选手在C++程序中定义了一个表示剪纸纹样的类：

classPaperCut{

private:

stringname;

intcomplexity;

public:

PaperCut(stringn,intc):name(n),complexity(c){}

booloperator<(constPaperCut&other)const{

returncomplexity<plexity;

}

};

现在需要将一个

vector<PaperCut>

按复杂度降序排，下列代码正确的是？

A.

sort(patterns.begin(),patterns.end(),greater<PaperCut>());

B.

sort(patterns.begin(),patterns.end(),[](constPaperCut&a,constPaperCut&b){returna<b;});

C.

sort(patterns.rbegin(),patterns.rend());

D.

sort(patterns.begin(),patterns.end(),less<PaperCut>());

答案：C

解析：选项C使用反向迭代器

rbegin()

和

rend()

，对原序列进行反向排由于类中重载了

<

运算符表示复杂度

升序，反向排后就得到了降的结果；选项A的

greater<PaperCut>()

需要类重载

>

运算符，题目中没有定义

会编译错误；选项B的lambda表达式使用

a<b

，排序结果是升，不符合要求；选项D的

less<PaperCut>()

等

价于默认排序，结果也是升。

第9题

在"数字守艺人"场景中，选手需要用C++实现一个非遗技艺的评分系统，规则为：从10个评委的打分中去掉一

个最高分和一低，计算剩余8个分数的平均值。下列代码片段中，能正确实现该功是？

A.

doublecalculateScore(vector<int>&scores){

intsum=accumulate(scores.begin(),scores.end(),0);

intmax_val=*max_element(scores.begin(),scores.end());

intmin_val=*min_element(scores.begin(),scores.end());

return(sum-max_val-min_val)/8.0;

}

B.

doublecalculateScore(vector<int>&score