首页 › 试卷 › GESP编程能力等级认证 › GESP-C++二级 › 2024年6月CCF-GESP编程能力等级认证C++编程二级真题

2024年6月CCF-GESP编程能力等级认证C++编程二级真题 VIP

GESP-C++二级 共 27 题 2024 年 含标准答案与解析
返回试卷列表
本页为整卷浏览:先自己做一遍,再展开「查看答案与解析」核对。

一、单选题

1. 单选题

小杨父母带他到某培训机构给他报名参加CCF组织的GESP认证考试的第1级,那他可以选择的认证语言有几种?( )(2024.6-2)

  • A 1
  • B 2
  • C 3
  • D 4
查看答案与解析
答案:C
解析:

本题考察GESP等级的认证语言,包括c++、python和图形化编程三种语言

CCF的GESP认证考试第1级可以选择的认证语言有Python、C++和图形化编程(如Scratch),因此可以选择的语言有3种。

2. 单选题

下面流程图在yr输入2024时,可以判定yr代表闰年,并输出 2月是29天 ,则图中菱形框中应该填入( )。(2024.6-2)

  • A (yr%400==0) || (yr%4==0)
  • B (yr%400==0) || (yr%4==0 && yr%100!=0)
  • C (yr%400==0) && (yr%4==0)
  • D (yr%400==0) && (yr%4==0 && yr%100!=0)
查看答案与解析
答案:B
解析:

本题通过流程图体现分支结构,条件判断框中填写闰年的判定条件:年份是4的倍数时,该年是闰年。当年份是100的倍数时,当且仅当年份是400的倍数时才是闰年

要判断一个年份是否是闰年,可以使用以下规则:

* 如果年份能被 4 整除,但不能被 100 整除,那么它是闰年。

* 如果年份能被 400 整除,那么它也是闰年。

所以正确答案为B

3. 单选题

在C++中,下列不可做变量的是( )。(2024.6-2)

  • A five-Star
  • B five_star
  • C fiveStar
  • D _fiveStar
查看答案与解析
答案:A
解析:

本题考察c++中变量的命名由数字、字母、下划线组成,没有短横线,并且只能由字母或下划线开头

在C++中,变量命名必须遵循以下规则:

变量名只能包含字母(大写或小写)、数字和下划线。

变量名的第一个字符必须是字母或下划线,不能是数字。

变量名不能包含空格或特殊字符(如连字符)。

根据这些规则,选项中不符合规则的变量名是 five-Star,因为它包含了不允许的字符 -(连字符)。

4. 单选题

在C++中,与 for(int i=0; i<10; i++) 效果相同的是( )。

  • A for(int i=0; i<10; i+=1)
  • B for(int i=1; i<=10; i++)
  • C for(int i=10; i>0; i–)
  • D for(int i=10; i<1; i++)
查看答案与解析
答案:A
解析:

本题考察c++中的加赋值运算符,i+=1的含义是i=i+1,也就是实现了i++的操作

在C++中,与 for(int i=0; i<10; i++) 效果相同的循环是:

for(int i=0; i<10; i+=1)

这两个循环的初始化、条件检查和增量操作是相同的,因此它们的效果是相同的。

5. 单选题

在C++中, cout << (5 % 2 && 5 % 3) 的输出是( )。

  • A 1
  • B 2
  • C true
  • D false
查看答案与解析
答案:A
解析:

5%2的结果非0,为1;5%3的结果非0,为1;二者进行&&与运算,结果仍为1,通过cout进行输出

在C++中,5 % 2 和 5 % 3 的结果分别是 1 和 2。接着,我们使用逻辑 AND 操作符 && 来计算 1 && 2。在逻辑表达式中,非零值被视为 true,而零值被视为 false。

因此,1 和 2 都是非零值,所以 1 && 2 是 true,在整数上下文中,true 的值是 1。

所以,cout << (5 % 2 && 5 % 3) 的输出是 1。

6. 单选题

执行下面的C++代码时输入 1 ,则输出是( )。

int month;
cin >> month;
switch(month){
	case 1:
		cout << "Jan ";
	case 3:
		cout << "Mar ";
		break;
	default:
		;
}
  • A Jan
  • B Mar
  • C Jan Mar
  • D 以上均不对
查看答案与解析
答案:C
解析:

本题考察对于switch语句的理解,当没有使用break将各种分支情况隔离开时,会执行所有分支情况的语句

让我们分析这段代码的执行过程:

int month;

cin >> month; 当输入为 1 时,month 的值为 1。

switch(month) 语句用于根据 month 的值执行相应的 case 块。

具体来看:

* 当 month 为 1 时,执行 case 1 块,输出 "Jan "。

* 由于 case 1 块中没有 break 语句,程序会继续执行下一个 case 块,即 case 3,并输出 "Mar "。

* 然后遇到 break 语句,跳出 switch 结构。

因此,当输入 1 时,输出结果是 "Jan Mar "。

7. 单选题

执行下面C++代码后,有关说法错误的是( )。

int a, b;
cin >> a >> b;
if (a && b)
	cout << "1";
else if (!(a || b))
	cout << "2";
else if (a || b)
	cout << "3";
else
	cout << "4";
  • A 如果先后输入1和1,则将输出1
  • B 如果先后输入0和1或者1和0,则将输出3
  • C 如果先后输入0和0,则将输出2
  • D 如果先后输入0和0,则将输出4
查看答案与解析
答案:D
解析:

本题考察对于if-else条件语句的理解。当if括号内的语句为真,会执行if代码块中的语句,否则跳转至else if或者else。当a=0、b=0时,a||b的结果为0,所以!(a||b)的结果为1,输出2

让我们逐步分析这段代码以及每种输入情况下的输出结果:

1. 如果先后输入 `1` 和 `1`:

   - `a && b` 为 `true`(`1 && 1`),所以输出 `1`。

   **正确**。A 是正确的说法。

2. 如果先后输入 `0` 和 `1` 或者 `1` 和 `0`:

   - `a && b` 为 `false`。

   - `!(a || b)` 为 `false`(`!(0 || 1)` 或 `!(1 || 0)`)。

   - `a || b` 为 `true`(`0 || 1` 或 `1 || 0`),所以输出 `3`。

   **正确**。B 是正确的说法。

3. 如果先后输入 `0` 和 `0`:

   - `a && b` 为 `false`。

   - `!(a || b)` 为 `true`(`!(0 || 0)`),所以输出 `2`。

   **正确**。C 是正确的说法。

4. 如果先后输入 `0` 和 `0`:

   - `a && b` 为 `false`。

   - `!(a || b)` 为 `true`(`!(0 || 0)`),所以输出 `2`,不会执行到 `else` 部分,也不会输出 `4`。

   **错误**。D 是错误的说法。

因此,答案是:

如果先后输入0和0,则将输出4

8. 单选题

某货币由5元,2元和1元组成。输入金额(假设为正整数),计算出最少数量。为实现其功能,横线处应填入代码是( )。

int N;
cin >>N;

int M5,M2,M1;
M5 = N / 5;
M2 = ______________;
M1 = ______________;
printf("5*%d+2*%d+1*%d", M5, M2, M1);
  • A 第1横线处应填入:N / 2第2横线处应填入:N - M5 - M2
  • B 第1横线处应填入:(N - M5 * 5) / 2第2横线处应填入:N - M5 * 5 - M2 * 2
  • C 第1横线处应填入:N - M5 * 5 / 2第2横线处应填入:N - M5 * 5 - M2 * 2
  • D 第1横线处应填入:(N - M5 * 5) / 2第2横线处应填入:N - M5 - M2
查看答案与解析
答案:B
解析:

本题考察对题干中逻辑的理解,其中M5、M2、M1分别代表5元、2元、1元货币的个数。需要货币总数尽可能少,因此尽可能使用面额更高的货币。首先由N/5计算出5元货币的个数,这个结果将会取得整数。剩余无法用5元来表示的金额,则 是N - M5 * 5,用(N - M5 * 5) / 2 计算出2元货币的个数,剩余金额(N - M5 * 5 - M2 * 2)/1得到1元货币的个数

要计算用最少数量的货币来凑出指定金额 N,需要先使用尽可能多的 5 元,再使用 2 元,最后使用 1 元。我们需要确定 M5、M2 和 M1 的值。

首先,我们计算 M5:

M5 = N / 5;

接着,我们计算 M2。这时,我们需要先从总金额 N 中减去 5 元币的总价值,然后再除以 2 元:

M2 = (N - M5 * 5) / 2;

最后,我们计算 M1,这时需要从总金额 N 中减去 5 元币和 2 元币的总价值,剩下的就是用 1 元币表示的金额:

M1 = N - M5 * 5 - M2 * 2;

因此,正确的选项是:

第1横线处应填入:(N - M5 * 5) / 2

第2横线处应填入:N - M5 * 5 - M2 * 2

9. 单选题

下面C++代码执行后的输出是( )。

int loopCount = 0;
for (int i=0; i < 10; i++)
	for (int j=1; j < i; j++)
		loopCount += 1;
cout << loopCount;
  • A 55
  • B 45
  • C 36
  • D 28
查看答案与解析
答案:C
解析:

本题考察对于循环嵌套以及赋值运算符的理解。使用loopcount变量记录内层循环总次数,当i=2时,内层循环执行1次,当i=3时,内层循环执行2次…当i=9时,内层循环执行8次.因此总次数为(1+8)*8/2=36

让我们逐步分析这段代码,以确定 loopCount 的最终值。

我们先来看看这两个嵌套的 for 循环是如何工作的:

最外层的循环是 for (int i = 0; i < 10; i++):

当 i = 0 时,内层的 for 循环条件 j < i 不满足,所以内层循环不执行。

当 i = 1 时,内层的 for 循环条件 j < i 仍不满足,所以内层循环不执行。

当 i = 2 时,内层的 for 循环是 for (int j = 1; j < 2; j++),即 j 取值为 1,所以内层循环执行一次,loopCount += 1,loopCount 变为 1。

当 i = 3 时,内层的 for 循环是 for (int j = 1; j < 3; j++),即 j 取值为 1 和 2,内层循环执行两次,loopCount += 2,loopCount 变为 3。

以此类推,直到 i = 9。

我们可以计算每次 i 值时,loopCount 的增加量:

当 i = 2 时,loopCount 增加 1。

当 i = 3 时,loopCount 增加 2。

当 i = 4 时,loopCount 增加 3。

当 i = 5 时,loopCount 增加 4。

当 i = 6 时, loopCount 增加 5。

当 i = 7 时, loopCount 增加 6。

当 i = 8 时, loopCount 增加 7。

当 i = 9 时, loopCount 增加 8。

把这些增加量加起来:

1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 = 36

因此,代码执行后的输出是 36。

正确答案是:

36

10. 单选题

下面C++代码执行后的输出是( )。

int loopCount = 0;
for (int i=0; i < 10; i++){
	for (int j=0; j < i; j++)
		if (i * j % 2)
			break;
	loopCount += 1;
}
cout << loopCount;
  • A 25
  • B 16
  • C 10
  • D 9
查看答案与解析
答案:C
解析:

本题考察对于循环嵌套以及break终止语句的理解。当i=1时,j=0,i*j%2的结果是0;当i=2时,j=0/1,结果都是0;当i=3时,j=0/1/2,结果分别是0/1/0…当结果为1时,执行break语句终止内层循环,进入下一轮的外层循环。使用loopcount变量记录结果为0的次数。实际上loopCount计数不受内层循环影响,执行了10次加1操作。

这段代码中,外层循环从0到9,内层循环对每个i从0到i-1进行迭代。当i\*j的结果为奇数时,内层循环立即停止。最终外层循环运行了10次,因为在每次迭代中,内层循环大多数情况下都会迭代,只有在i\*j为奇数时才会中止。

11. 单选题

假设下面C++代码执行过程中仅输入正负整数或0,有关说法错误的是( )。

int N,Sum = 0;
cin >> N;
while (N){
	Sum += N;
	cin >> N;
}
cout << Sum;
  • A 执行上面代码如果输入0,将终止循环
  • B 执行上面代码能实现所有非0整数的求和
  • C 执行上面代码第一次输入0,最后将输出0
  • D 执行上面代码将陷入死循环,可将 while (N) 改为 while (N==0)
查看答案与解析
答案:D
解析:

该代码不会陷入死循环,N的值随机,D选项的改动后执行意义都变了,只能输出0

让我们逐一分析每个选项:

如果输入0,循环条件 `while (N)` 将会变为假,从而终止循环。这是正确的。

代码中通过循环不断将输入的整数加到 `Sum` 变量中,因此可以实现所有非0整数的求和。这也是正确的。

当第一次输入为0时,循环条件 `while (N)` 将会首次检查到假,因此不会执行循环体内的代码,直接输出 `Sum` 的当前值,即0。这是正确的。

将 `while (N)` 改为 `while (N==0)` 会导致循环条件错误,因为这将要求输入值必须为0才能执行循环。这是错误的。

综上所述,正确答案是:

执行上面代码将陷入死循环,可将 `while (N)` 改为 `while (N==0)` 是错误的。

12. 单选题

执行下面的C++代码,有关说法正确的是( )【质数是指仅能被1和它本身整除的正整数】。

int N;
cin >> N;
bool Flag = true;
for ( int i = 2; i < N; i++){
	if (i * i > N)
		break;
	if (N % i == 0){
		Flag = false;
		break;
	}
}
if (Flag)
	cout << N << "是质数" << endl;
else
	cout << N << "不是质数" << endl;
  • A 如果输入正整数,上面代码能正确判断N是否为质数
  • B 如果输入整数,上面代码能正确判断N是否为质数
  • C 如果输入大于等于0的整数,上面代码能正确判断N是否质数
  • D 如将 Flag = true 修改为 Flag = N>=2? true:false 则能判断所有整数包括负整数、0、正整数是否为质数
查看答案与解析
答案:D
解析:

原代码没有考虑N=1的情况,将输出1为质数,由此排除ABC。D选项的改动规避了N<2的情况,正确

如果将 `Flag = true` 修改为 `Flag = N>=2? true:false`,那么这段代码将根据输入的整数 `N` 的值来判断是否为质数,包括负整数、0和正整数的情况。这是因为这种修改会根据 `N` 的值直接确定 `Flag` 的初值,而不再依赖于循环和条件判断部分的计算。

13. 单选题

下面C++代码用于实现如下图所示的效果,其有关说法正确的是( )。

for (int i = 1; i < 6; i++){ // L1
	for (int j = 1; j < i+1; j++) //L2
		cout << i*j << " ";
	cout << endl;
}
  • A 当前代码能实现预期效果,无需调整代码
  • B 如果 cout << endl; 移到循环L2内部,则可实现预期效果
  • C 如果 cout << endl; 移到循环L1外部,则可实现预期效果
  • D 删除 cout << endl; 行,则可实现预期效果
查看答案与解析
答案:A
解析:

i=1,j=1,输出1后换行;i=2,j=1/2,输出2 4后换行;以此类推得到的输出结果与题干相符

14. 单选题

下面C++代码执行后,输出是( )。

int cnt1 = 0, cnt2 = 0;
for (int i = 0; i < 10; i++){
	if (i % 2 == 0)
		continue;
	if (i % 2)
		cnt1 += 1;
	else if (i % 3 == 0)
		cnt2 += 1;
}
cout << cnt1 << " " << cnt2;
  • A 5 2
  • B 5 0
  • C 0 2
  • D 0 0
查看答案与解析
答案:B
解析:

i的取值范围从0遍历到9,使用cnt1变量记录满足i%2==1的个数,使用cnt2变量记录满足i%3==0的个数,分别是i=1、3、5、7、9。通过观察if-else结构可知,只有当i%2==1且i%2!=1时才会执行else if判断,这显然互相矛盾,因此else if之后的语句不会执行,cnt2保持初始值0

在这段代码中,循环从0到9遍历每个数字 `i`:

- 如果 `i` 是偶数,就跳过该循环。

- 如果 `i` 是奇数,会执行 `if (i % 2)` 条件下的代码,将 `cnt1` 增加1。

- `cnt2` 不会增加,因为没有满足 `else if (i % 3 == 0)` 条件的情况。

因此,最终输出结果是 5 0,其中 `cnt1` 统计了所有奇数的个数。

15. 单选题

在下面的C++代码中,N必须是小于10大于1的整数,M为正整数(大于0)。如果M被N整除则M为幸运数,如果M中含有N且能被N整除,则为超级幸运数,否则不是幸运数。程序用于判断M是否为幸运数或超级幸运数或非幸运数。阅读下面代码,有关说法正确的是( )。

int N, M;
cout << "请输入幸运数字:";
cin >> N;
cout << "请输入正整数:";
cin >> M;

bool Lucky;
if (M % N == 0)
	Lucky = true;
else
	Lucky = false;
while (M){
	if (M % 10 == N && Lucky){
		printf("%d是%d的超级幸运数!", M, N);
		break;
	}
	M /= 10;
}
if (M == 0)
	if (Lucky)
		printf("%d是%d的幸运数!", M, N);
	else
		printf("%d非%d的幸运数!", M, N);
  • A 如果N输入3,M输入36则将输出:36是3的超级幸运数!
  • B 如果N输入7,M输入21则将输出:21是7的幸运数!
  • C 如果N输入8,M输入36则将输出:36非8的超级幸运数!
  • D 如果N输入3,M输入63则将输出:63是3的超级幸运数!
查看答案与解析
答案:D
解析:

本题需要注意当M的个位与N不相同时,M会不断除以10即发生变化,而且没有变量存储原M值。因此A、B、C选项中最终会输出的M都不是最开始的输入值。

这段代码的逻辑是:

1. 根据输入的 `N` 和 `M`,确定 `M` 是否为 `N` 的幸运数(即能被 `N` 整除)。

2. 循环检查 `M` 的每一位数字,如果发现某位数字等于 `N` 并且 `M` 是幸运数,则输出超级幸运数的消息。

3. 如果循环结束后 `M` 变为0,根据 `Lucky` 的值输出幸运数或非幸运数的消息。

因此,选项 D 正确,因为当输入 `N` 为3,`M` 为63时,输出为:"63是3的超级幸运数!" 符合预期输出。

二、判断题

16. 判断题

执行C++代码 cout << ‘9’+‘1’; 的输出为10。( )

  • A对
  • B错
查看答案与解析
答案:错
解析:

使用单引号代表这是一个字符,本条cout语句会输出数字字符9和数字字符1的ascII码之和106

这个表达式 `'9' + '1'` 在 C++ 中涉及字符的 ASCII 值相加,而不是直接的数学加法。在 ASCII 中,字符 '9' 的值是 57,字符 '1' 的值是 49。因此,表达式的计算结果为 106。

17. 判断题

C++表达式 -12 % 10 的值为2。( )

  • A对
  • B错
查看答案与解析
答案:错
解析:

c++中对于负数的取模运算,就是正常取余后保留负号

在 C++ 中,取模运算(%)的结果的符号与被除数的符号相同。因此,对于表达式 `-12 % 10`:

- 被除数 `-12` 是负数。

- 取模运算的结果的符号与被除数 `-12` 的符号相同,即为负数。

计算过程如下:

- `-12` 除以 `10` 的商为 `-1`,余数为 `-2`。

- 因此,`-12 % 10` 的结果为 `-2`,不是 `2`。

18. 判断题

C++表达式 int(12.56) 的值为13。( )

  • A对
  • B错
查看答案与解析
答案:错
解析:

在c++中使用int()对浮点数做强制类型转换,会舍弃小数部分,保留为整数12

在 C++ 中,对一个浮点数进行强制类型转换为整型时,会向零取整,即舍弃小数部分,不进行四舍五入。因此,对于表达式 `int(12.56)`:

- `12.56` 强制转换为整型时,会取其整数部分。

- 故 `int(12.56)` 的值为 `12`,而不是 `13`。

19. 判断题

C++的整型变量N被赋值为10,则语句 cout << N / 3 << “-” << N % 3 执行后输出是3-1。 ( )

  • A对
  • B错
查看答案与解析
答案:对
解析:

本题考察c++中运算符/和%。/表示整数除法,返回的值是做整数除法,取除法的商。因此10/3 =3,10%3=1。

在这个表达式中,整型除法 `N / 3` 将 `10` 除以 `3`,其结果为 `3`(因为整数除法会向下取整)。

整型取模运算 `N % 3` 则是 `10` 除以 `3` 的余数,结果为 `1`。

因此,表达式 `cout << N / 3 << "-" << N % 3` 的输出为 `3-1`。

20. 判断题

在C++代码中,不可以将变量命名为scanf,因为scanf是C++语言的关键字。( )

  • A对
  • B错
查看答案与解析
答案:错
解析:

scanf()是c++中的库函数,用于标准输入,而不是关键字。

在C++中,`scanf`并不是关键字,而是C语言中的输入函数。在C++中可以使用`scanf`作为变量名,尽管不建议这样做,因为它可能会造成混淆,特别是在包含了 `<cstdio>` 头文件的情况下,它可能会与C语言的标准库函数`scanf`冲突。

21. 判断题

下面C++代码执行后将导致死循环。( )

for (int i = 0; i < 10; i++)
	continue;
  • A对
  • B错
查看答案与解析
答案:错
解析:

执行continue语句后,会跳过当前循环的剩余语句不执行转而进入下一轮循环。题干中i=0,此时执行continue回到for语句,i自增为1,继续执行continue回到for语句,i自增为2;依次循环直到i=10不再执行。因此总循环数为10次,并不会出现死循环。

这段代码不会导致死循环。关键字 `continue` 用于终止当前循环的迭代,并立即开始下一次迭代。在这段代码中,`continue` 语句使得每次循环迭代时都会跳过循环体的剩余部分,直接进行下一次循环。

因此,这段代码会正常执行,不会造成死循环。

22. 判断题

下面C++代码执行后将输出10。( )

int cnt = 0;
for (int i = 0; i < 10; i++)
	for (int j = 0; j < i; j++){
		cnt += 1;
		break;
	}
cout << cnt;
  • A对
  • B错
查看答案与解析
答案:错
解析:

本题使用cnt变量记录第二层循环执行的次数,当i=0时,内层循环执行0次;当i=1时,内层循环执行1次,当i=2时,内层循环执行2次…当i=9时,内层循环执行9次.因此总次数为(1+9)*9/2=45

内部的 `break;` 语句会导致内层循环 `for (int j = 0; j < i; j++)` 每次只执行一次,因为 `break;` 会立即终止当前循环。这意味着每当 `i` 增加时,内部循环只会执行一次,然后立即终止。

因此,`cnt` 只会累加 `1`,而不会根据 `i` 的增加而逐步累加更多。最终的输出结果是 `cnt` 的值,即 `1`。

23. 判断题

下面C++代码执行后,将输出5。( )

int cnt = 0;
for (int i = 1; i < 5; i++)
	for (int j = i; j < 5; j +=i)
		if (i * j % 2 == 0)
			cnt += 1;
cout << cnt;
  • A对
  • B错
查看答案与解析
答案:对
解析:

当i=1时,j=1/2/3/4,此时ij%2的结果为1/0/1/0,结果为0时满足if条件判断则执行cnt的自增语句;当i=2时,j=2/4,此时ij%2的结果为0/0;当i=3时,j=3,此时ij%2的结果为1;当i=4时,j=4,此时ij%2的结果为0;

对于每个 `i` 的值,内部循环 `for (int j = i; j < 5; j += i)` 会使 `j` 从 `i` 开始增加,增加步长为 `i`,直到 `j` 不小于 `5`。

现在我们分析每个 `i` 的情况:

- 当 `i = 1` 时,`j` 只能是 `1`,因为 `j += i`,满足条件的组合是 `(1, 1)`,因为 `1 * 1 % 2 == 0`。

- 当 `i = 2` 时,`j` 从 `2` 到 `4`,步长为 `2`,满足条件的组合是 `(2, 2), (2, 4)`,因为 `2 * 2 % 2 == 0` 和 `2 * 4 % 2 == 0`。

- 当 `i = 3` 时,`j` 只能是 `3`,因为 `j += i`,满足条件的组合是 `(3, 3)`,因为 `3 * 3 % 2 == 0`。

- 当 `i = 4` 时,`j` 只能是 `4`,因为 `j += i`,满足条件的组合是 `(4, 4)`,因为 `4 * 4 % 2 == 0`。

因此,满足条件 `i * j % 2 == 0` 的组合有 `1 + 2 + 1 + 1 = 5` 组。

所以,最终输出的 `cnt` 的值为 `5`。

24. 判断题

下面C++代码能实现正整数各位数字之和。( )

int N,Sum = 0;
cin >> N;
while (N){
	Sum += N % 10;
	N /= 10;
}
cout << Sum;
  • A对
  • B错
查看答案与解析
答案:对
解析:

本题考察对两种运算符的认识,通过N%10取得N的个位数,用sum变量保存,再通过N/=10去掉N的个位数,下一次取得的实际上是N的十位数。循环往复,直到N=0循环结束,此时已将N的所有位数加到sum中

这段代码确实可以实现正整数各位数字之和的功能。具体来说:

- `N % 10` 可以获取 `N` 的个位数字。

- `Sum += N % 10` 将个位数字加到 `Sum` 上。

- `N /= 10` 可以将 `N` 的个位数字去掉,使得下一次循环时处理 `N` 的十位数字。

因此,这段代码可以正确计算输入正整数 `N` 的各位数字之和。答案是正确的。

25. 判断题

GESP测试是对认证者的编程能力进行等级认证,同一级别的能力基本上与编程语言无关。( )2024.6-2

  • A对
  • B错
查看答案与解析
答案:对
解析:

本题考察对GESP的认识,GESP测试是对认证者的编程能力进行等级认证, 同⼀级别的能力基本上与编程语言无关

GESP(General Entrance Software Professional)测试是一个通用的入门级认证考试,评估认证者在计算机编程和软件开发方面的基本能力,而不是特定于某种编程语言。虽然在实际应用中,编程语言的选择可能会对解决问题的方法和效率产生影响,但是GESP认证更侧重于对基本编程概念和解决问题的一般方法的评估,而不是特定语言的高级特性或库的掌握程度。

因此,可以认为在GESP测试中,不同编程语言的使用对于获得相同级别的认证基本上是无关紧要的。

三、简答题

26. 简答题

平方之和

时间限制:1.0 s

内存限制:512.0 MB

题面描述

小杨有n个正整数a1,a2,...,an,他想知道对于所有的i(1≤i≤n),是否存在两个正整数x 和y满足x×x+y×y=ai。

输入格式

第一行包含一个正整数n,代表正整数数量。

之后n行,每行包含一个正整数,代表ai。

输出格式

对于每个正整数ai,如果存在两个正整数x和y满足x×x+y×y=ai,输出 Yes,否则输出 No。


输入样例

2
5
4

输出样例

Yes
No

样例解释

对于第一个正整数,存在1×1+2×2=5,因此答案为 Yes。

数据范围

对于全部数据,保证有1≤n≤10,1≤ai≤106。

查看答案与解析
答案:<pre class="brush:cpp;toolbar:false">#include&lt;bits/stdc++.h&gt; using namespace std; bool check(int x){ int y = sqrt(x); return y*y==x; } int main(){ int t; cin&gt;&gt;t; while(t--){ int n; cin&gt;&gt;n; int fl=0; for(int i=1;i*i&lt;n;i++){ int j=n-i*i; if(check(j))fl=1; } if(fl)cout&lt;&lt;"Yes\n"; else cout&lt;&lt;"No\n"; } }</pre>
解析:

1、按题目要求定义好需要的变量,并实现输入

2、通过while循环n次单独接收每次的数据ai,定义f1变量表示结果

3、在1~根号ai之间遍历数字i,此时i就是x

4、调用check()函数计算ai,剩余的数为ai-i*i,判断它能否被开方5、如果可以则f1=1,输出Yes,否则输出No

27. 简答题

计数

时间限制:1.0 s

内存限制:512.0 MB

题面描述

小杨认为自己的幸运数是正整数k(注:保证1≤k≤9)。小杨想知道,对于从1到n的所有正整数中,k出现了多少次。

输入格式

第一行包含一个正整数n。

第二行包含一个正整数k。

输出格式

输出从1到n的所有正整数中,k出现的次数。


输入样例

25
2

输出样例

9

样例解释

从1到25中,2出现的正整数有2,12,20,21,22,23,24,25,一共出现了9次。

数据范围

对于全部数据,保证有1≤n≤1000,1≤k≤9。

查看答案与解析
答案:<pre class="brush:cpp;toolbar:false">#include &lt;iostream&gt; using namespace std; int check(int x, int y) { int cnt = 0; while (x &gt; 0) { int tmp = x % 10; if (tmp == y) { cnt++; } x = x / 10; } return cnt; } int main() { int n, k; cin &gt;&gt; n &gt;&gt; k; int ans = 0; for (int i = 1; i &lt;= n; i++) { ans += check(i, k); } cout &lt;&lt; ans &lt;&lt; endl; return 0; }</pre>
解析:

1、按题目要求定义好需要的变量,并实现输入

2、通过for循环遍历1~n中的每个数i,调用check()函数计算该数中k出现多少次

3、定义check()函数,传入参数i和k,通过i%10得到i的个位,与k比较,如果相同则cnt+1.再通过i/10去掉i的个位。通过循环重复上述步骤,将i的每一位都与k作对比

4、定义ans变量累计每次cnt的结果,得到最终答案