GESP 2024年12月认证 C++ 4级真题

场次：2024年12月
满分：100 分
题目来源：官方直发原件

1 单选题（每题 2 分，共 30 分）

下面的语句中，（）正确定义了一个计算浮点数 $x$ 的平方( $x^2 = x \times x$ )的函数,并成功调用该函数。

float square(float x) {
    return x * x;
}
float area = square(2);

square(float x) {
    return x * x;
}
float area = square(2);

void square(float x) {
    return x * x;
}
area = square(2.0);

void square(float x) {
    x * x;
    return;
}
area = square(2);

下面代码的描述中，正确的是（）。

void n_chars(char c, int n) {
   while (n-- > 0)
        cout << c;
}

char my_char = 'w';
int times = 5;
n_chars(my_char, times);

代码执行结束后，times 的值为0

n 是形参，times 是实参

n 是实参，times 是形参

代码最后一行换成 n_chars(times, my_char); 也可以

给定以下代码，

void func(int& x) {
    x = x * 2;
}

int a = 5;
func(a);

执行上述代码后，变量 a 的值为（）。

运行下面代码，屏幕上输出是（）。

double* p_arr = new double [3];
p_arr[0] = 0.2;
p_arr[1] = 0.5;
p_arr[2] = 0.8;
p_arr += 1;
cout << p_arr[0] << endl;
p_arr -= 1;
delete p_arr;

0.2

0.5

1.2

1.5

运行下面代码片段后，x 和 *p 的结果分别是（）。

int x = 20;
int* p = &x;
*p = *p + 2；

原文保真说明：原卷印刷错误 1 处（照原卷保留，未作修改）

原卷印刷如此标点题干 · 第 3 行
原卷作 *p = *p + 2； ，常规写法应为 *p = *p + 2;
原卷代码第 3 行行末是全角分号 U+FF1B（900 dpi 放大图像可见其字形与第 1、2 行的半角分号不同），照原卷转写。

20 20

20 22

22 20

22 22

下面的描述中，（）不能正确定义一个名为 Student 的结构体以及一个包含20个元素的结构数组。

原文保真说明：原卷印刷错误 4 处（照原卷保留，未作修改）

原卷印刷如此版式选项 1
原卷作 struct Student students[20];
原卷此行类型名与变量名之间是 2 个空格（450 dpi 图像测量确认），不得归一化为 1 个空格。
原卷印刷如此版式选项 2
原卷作 Student students[20];
原卷此行类型名与变量名之间是 2 个空格（450 dpi 图像测量确认），不得归一化为 1 个空格。
原卷印刷如此版式选项 3
原卷作 Student* students = new Student[20];
原卷此行类型名与变量名之间是 2 个空格（450 dpi 图像测量确认），不得归一化为 1 个空格。
原卷印刷如此版式选项 4
原卷作 Student students = new Student[20];
原卷此行类型名与变量名之间是 2 个空格（450 dpi 图像测量确认），不得归一化为 1 个空格。

struct Student {
    string name;
    int age;
    float score;
};
struct Student  students[20];

struct Student {
    string name;
    int age;
    float score;
};
Student  students[20];

struct Student {
    string name;
    int age;
    float score;
};
Student*  students = new Student[20];

struct Student {
    string name;
    int age;
    float score;
};
Student  students = new Student[20];

假定整型是32位，对一个 $2$ 行 $3$ 列的二维整数数组 array,假设数组第一个元素在内存中的地址为 0x7ffee4065820，则第2行第2个元素的地址 &array[1][1] 为（）。

int array[2][3] = {
    {0, 1, 2},
    {3, 4, 5}
};

0x7ffee4065824

0x7ffee4065828

0x7ffee406582c

0x7ffee4065830

下面（）正确定义二维数组。

int a[3][];

int a[][];

int a[][4];

int a[][2] = {{1,2},{1,2},{3,4}};

下面代码采用递推算法来计算斐波那契数列 $f(n) = f(n-1) + f(n-2)$ ，则横线上应填写（）。

int fib(int n) {
    if (n == 0 || n == 1)
        return n;

    int f1 = 0;
    int f2 = 1;
    int result = 0;
    for (int i = 2; i <= n; i++) {
        ________________________________     // 在此处填入代码
    }
    return result;
}

result = f1 + f2;
f1 = f2;
f2 = result;

result += f1 + f2;
f1 = f2;
f2 = result;

result += f1 + f2;
f2 = result;
f1 = f2;

result = f1 + f2;
f2 = result;
f1 = f2;

下面关于排序算法（冒泡排序、插入排序和选择排序）的描述中，不正确的是（）。

冒泡排序基于元素交换实现，需借助临时变量，共涉及 $3$ 个单元操作；而插入排序基于元素赋值实现，仅需 $1$ 个单元操作。因此冒泡排序的计算开销通常比插入排序更高。

选择排序在任何情况下的时间复杂度都为 $O(n^2)$ 。

冒泡排序在任何情况下的时间复杂度都为 $O(n^2)$ 。

如果给定数据部分有序，插入排序通常比选择排序效率更高。

冒泡排序的第一轮操作是从左到右遍历数组，通过两两比较相邻元素，将当前最大的元素移动到末尾。给定数组 arr[]={4, 1, 3, 1, 5, 2}，执行第一轮冒泡排序后数组 arr 中的内容为（）。

1, 4, 3, 1, 5, 2

1, 3, 1, 4, 2, 5

1, 4, 3, 1, 2, 5

4, 1, 3, 1, 5, 2

给定如下代码，其时间复杂度为（）。

int cellRecur(int n) {
    if (n == 1)
        return 1;
    return cellRecur(n - 1) + cellRecur(n - 1) + 1;
}

$O(n^2)$

$O(2^n)$

$O(1)$

$O(n)$

下面代码实现了插入排序函数，则横线上应填写（）。

void insertion_sort(vector<int> &nums) {
    for (int i = 1; i < nums.size(); i++) {

        ________________________________ {    // 在此处填入代码

        while (j >= 0 && nums[j] > base)

            nums[j + 1] = nums[j];
            j--;
        }
        nums[j + 1] = base;
    }
}

原文保真说明：原卷印刷错误 1 处（照原卷保留，未作修改）

原卷印刷如此多余符号题干 · 第 4 行
原卷作 ________________________________ { // 在此处填入代码
原卷填空行末尾多印一个左花括号「{」，加之第 3、5、7 行为空行、while 语句体花括号配对与缩进异常，全部照原卷版式转写。

int base = nums[i], j = i - 1;

int base = nums[i], j = i;

int base = nums[0], j = i - 1;

int base = nums[0], j = i;

下面哪种方式不能实现将字符串"Welcome to GESP!"输出重定向到文件 log.txt （）。

原文保真说明：原卷印刷错误 1 处（照原卷保留，未作修改）

原卷印刷如此错字选项 4 · 第 6 行
原卷作 cout.rdbuf(oorg_cout); ，常规写法应为 cout.rdbuf(org_cout);
原卷印作 oorg_cout，比第 2 行声明的 org_cout 多一个 o（图像与文本层一致），照原卷转写。

freopen("log.txt", "w", stdout);
cout << "Welcome to GESP!" << endl;
fclose(stdout);

std::ofstream outFile("log.txt");
outFile << "Welcome to GESP!" << endl;
outFile.close();

std::ofstream outFile("log.txt");
cout << "Welcome to GESP!" << endl;
outFile.close();

ofstream log_file("log.txt");
streambuf* org_cout = cout.rdbuf();
cout.rdbuf(log_file.rdbuf());
cout << "This output will go to the log file." << endl;
cout.rdbuf(oorg_cout);

运行下面的代码，将出现什么情况？（）

double hmean(double a, double b) {
    if (a == -b )
        throw runtime_error("Runtime error occurred");
    return 2.0*a*b/(a + b);
}

int main() {
    double x = 10;
    double y = -10;

    try {
        int result = hmean(x, y);
        cout << "hmean: " << result << endl;
    }
    catch (const runtime_error& e) {
        cout << "Caught: " << e.what() << endl;
    } catch (...) {
        cout << "Caught an unknown exception." << endl;
    }
    return 0;
}

屏幕上输出 Caught: Runtime error occurred

屏幕上输出 Caught an unknown exception

程序调用 std::terminate()

编译错误

判断题（每题 2 分，共 20 分）

判断题「√」表示正确，「×」表示错误

在 C++ 中，下面代码可以正确定义指针和初始化指针。

int* ptr;
*ptr = 10;

√（正确）

×（错误）

一个函数必须在调用之前既声明又定义。

√（正确）

×（错误）

函数参数可以通过值传递、引用传递和指针传递，这样函数内对参数的修改可以直接修改传入变量的值。

√（正确）

×（错误）

int arr[3][] 是一个正确的二维数组的声明。

√（正确）

×（错误）

递推是一种通过已知的初始值和递推公式，逐步求解目标值的算法。

√（正确）

×（错误）

某算法的递推关系式为 $T(n) = T(n-1) + n$ （ $n$ 为正整数）及 $T(0) = 1$ ，则该算法的时间复杂度为 $O(n^2)$ 。

√（正确）

×（错误）

冒泡排序的平均时间复杂度为 $O(n^2)$ ，但最优情况下为 $O(n)$ 。

√（正确）

×（错误）

冒泡排序和插入排序都是稳定的排序算法。

√（正确）

×（错误）

选择排序是稳定的排序算法。

√（正确）

×（错误）

在 C++语言中，如果一个函数可能抛出异常，那么一定要在 try 子句里调用这个函数。

√（正确）

×（错误）

编程题（每题 25 分，共 50 分）

编程题

Recamán

C++时间 1 s内存 512 MB标准输入输出

小杨最近发现了有趣的 Recamán 数列，这个数列是这样生成的：

数列的第一项 $a_1$ 是 $1$ ；
如果 $a_{k-1}-k$ 是正整数并且没有在数列中出现过，那么数列的第 $k$ 项 $a_k$ 为 $a_{k-1}-k$ ，否则为 $a_{k-1}+k$ 。

小杨想知道 Recamán 数列的前 $n$ 项从小到大排序后的结果。手动计算非常困难，小杨希望你能帮他解决这个问题。

输入格式

第一行，一个正整数 $n$ 。

输出格式

一行， $n$ 个空格分隔的整数，表示 Recamán 数列的前 $n$ 项从小到大排序后的结果。

样例

输入 1

输出 1

1 2 3 6 7

样例解释

对于样例 1， $n=5$ ：

$a_1=1$ ；
$a_1-2=-1$ ，不是正整数，因此 $a_2=a_1+2=3$ ；
$a_2-3=0$ ，不是正整数，因此 $a_3=a_2+3=6$ ；
$a_3-4=2$ ，是正整数，且没有在数列中出现过，因此 $a_4=a_3-4=2$ ；
$a_4-5=-3$ ，不是正整数，因此 $a_5=a_4+5=7$ 。

$a_1,a_2,a_3,a_4,a_5$ 从小到大排序的结果为 $1,2,3,6,7$ 。

输入 2

输出 2

1 2 3 6 7 12 13 20

数据范围

对于所有数据点，保证 $1\le n\le 3\, 000$ 。

你的代码（C++）

提交后由评测机编译运行，结果见下方

编辑器加载中…

76 B / 64 KB

判题结果

编程题

字符排序

C++时间 1 s内存 512 MB标准输入输出

小杨有 $n$ 个仅包含小写字母的字符串 $s_1,s_2,\ldots,s_n$ ，小杨想将这些字符串按一定顺序排列后拼接到一起构成字符串 $t$ 。小杨希望最后构成的字符串 $t$ 满足：

假设 $t_i$ 为字符串 $t$ 的第 $i$ 个字符，对于所有的 $j\lt i$ 均有 $t_j\le t_i$ 。两个字符的大小关系与其在字母表中的顺序一致，例如 $\texttt{e}\lt \texttt{g}\lt \texttt{p} \lt \texttt{s}$ 。

小杨想知道是否存在满足条件的字符串排列顺序。

输入格式

第一行包含一个正整数 $T$ ，代表测试数据组数。

对于每组测试数据，第一行包含一个正整数 $n$ ，含义如题面所示。

之后 $n$ 行，每行包含一个字符串 $s_i$ 。

输出格式

对于每组测试数据，如果存在满足条件的排列顺序，输出（一行一个） $\texttt{1}$ ，否则输出（一行一个） $\texttt{0}$ 。

样例

输入 1

3
3
aa
ac
de
2
aac
bc
1
gesp

输出 1

1
0
0

样例解释

对于第一组测试数据，一种可行的排列顺序为 $\texttt{aa}+\texttt{ac}+\texttt{de}$ ，构成的字符串 $t$ 为 $\texttt{aaacde}$ ，满足条件。

数据范围

对于全部数据，保证有 $1\le T,n\le 100$ ，每个字符串的长度不超过 $10$ 。

你的代码（C++）

提交后由评测机编译运行，结果见下方

编辑器加载中…

76 B / 64 KB