扳手亿维科创中心

外观

2024年12月 GESP C++ 四级真题解析 ​

一、单选题（每题2分，共30分） ​

1. 下面的语句中，（）正确定义了一个计算浮点数 x 的平方 x² = x × x 的函数，并成功调用该函数。 ​

A.

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

B.

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

C.

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

D.

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

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

cpp
void n_chars(char c, int n){
    while (n-- > 0)
        cout << c;
}
char my_char = 'w';
int times = 5;
n_chars(my_char, times);

A. 代码执行结束后，times 的值为 0
B. n 是形参，times 是实参
C. n 是实参，times 是形参
D. 代码最后一行换成 n_chars(times, my_char); 也可以

3. 给定以下代码，执行后变量 a 的值为（）。 ​

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

A. 5
B. 10
C. 15
D. 20

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

cpp
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;
delete[] p_arr - 1;         // 恢复原地址再释放

A. 0.2
B. 0.5
C. 1.2
D. 1.5

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

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

A. 20 20
B. 20 22
C. 22 20
D. 22 22

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

A.

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

B.

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

C.

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

D.

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

7. 假定整型是 32 位，对一个 2 行 3 列的二维整数数组 array，假设数组首地址为 0x7ffee4065820，则 &array[1][1] 的地址为（）。 ​

A. 0x7ffee4065824
B. 0x7ffee4065828
C. 0x7ffee406582c
D. 0x7ffee4065830

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

A. int a[3][];

B. int a[][];

C. int a[][4];

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

9. 下面代码采用递推算法来计算斐波那契数列，则横线上应填写（）。 ​

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

A.

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

B.

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

C.

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

D.

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

10. 下面关于排序算法的描述中，不正确的是（）。 ​

A. 冒泡排序基于元素交换实现，需借助临时变量，共涉及 3 个单元操作；而插入排序基于元素赋值实现，仅需 1 个单元操作。因此冒泡排序的计算开销通常比插入排序更高。
B. 选择排序在任何情况下的时间复杂度都为 O(n²)。
C. 冒泡排序在任何情况下的时间复杂度都为 O(n²)。
D. 如果给定数据部分有序，插入排序通常比选择排序效率更高。

11. 冒泡排序第一轮对数组 {4,1,3,1,5,2} 执行后结果为（）。 ​

A. 1,4,3,1,5,2
B. 1,3,1,4,2,5
C. 1,4,3,1,2,5
D. 4,1,3,1,5,2

12. 给定递归代码，其时间复杂度为（）。 ​

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

A. O(n²)
B. O(2ⁿ)
C. O(1)
D. O(n)

13. 下面代码实现插入排序，横线上应填写（）。 ​

cpp
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;
    }
}

A. int base = nums[i], j = i - 1;
B. int base = nums[i], j = 1;
C. int base = nums[0], j = i - 1;
D. int base = nums[0], j = i;

已按规范重新构建 第14题 完整题目与解析如下：

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

A.

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

B.

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

C.

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

D.

cpp
ofstream log_file("log.txt");
streambuf* org_cout = cout.rdbuf();
cout.rdbuf(log_file.rdbuf());
cout << "Welcome to GESP!" << endl;
cout.rdbuf(org_cout);

15. 运行下面代码将出现什么情况？ ​

cpp
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, 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;
}

A. 屏幕上输出 Caught: Runtime error occurred
B. 屏幕上输出 Caught an unknown exception
C. 程序调用 std::terminate
D. 编译错误

二、判断题（每题2分，共20分） ​

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

cpp
int* ptr;
*ptr = 10;

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

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

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

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

6. 某算法的递推关系式为 T(n) = T(n-1) + n 及 T(0) = 1，则该算法的时间复杂度为 O(n²)。 ​

7. 冒泡排序的平均时间复杂度为 O(n²)，但最优情况下为 O(n)。 ​

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

9. 选择排序是稳定的排序算法。 ​

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

三、编程题（每题25分，共50分） ​

1. Recaman ​

题目描述 ​

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

  • 数列的第一项 a₁ 是 1；
  • 如果 aₖ₋₁ − k 是正整数并且没有在数列中出现过，那么数列的第 k 项 aₖ 为 aₖ₋₁ − k ，否则为 aₖ₋₁ + k；
  • 小杨想知道 Recaman 数列的前 n 项从小到大排序后的结果。手动计算非常困难，小杨希望你能帮他解决这个问题。

输入格式 ​

第一行，一个正整数 n。

输出格式 ​

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

输入样例1 ​
text
5
输出样例1 ​
text
1 2 3 6 7
输入样例2 ​
text
12
输出样例2 ​
text
1 2 3 6 7 12 13 20
样例解释 ​

对于样例1，n = 5：

  • a₁ = 1；
  • a₁ − 2 = −1 不是正整数，因此 a₂ = a₁ + 2 = 3；
  • a₂ − 3 = 0 不是正整数，因此 a₃ = a₂ + 3 = 6；
  • a₃ − 4 = 2 是正整数且未出现过，因此 a₄ = 2；
  • a₄ − 5 = −3 不是正整数，因此 a₅ = a₄ + 5 = 7；
  • 将 a₁, a₂, a₃, a₄, a₅ 从小到大排序后的结果为 1 2 3 6 7。

数据范围 ​

对于所有数据点，保证 1 ≤ n ≤ 3000。

解题思路 ​

参考程序 ​

2. 字符排序 ​

题目描述 ​

小杨有 n 个仅包含小写字母的字符串 s₁, s₂, …, sₙ。
小杨想将这些字符串按一定顺序排列后拼接到一起构成字符串 t，并满足：

  • 对于所有的 j < i，均有 tⱼ ≤ tᵢ（字典序非降）。

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

输入格式 ​

第一行包含一个正整数 T，代表测试数据组数。
对于每组测试数据，第一行包含一个正整数 n，含义如题面所示。
之后 n 行，每行包含一个字符串 sᵢ。

输出格式 ​

对于每组测试数据，如果存在满足条件的排列顺序，输出 1，否则输出 0。

输入样例1

text
3
3
aa
ac
de
1
abc
2
ba
ab

输出样例1

text
1
1
0

样例解释

  • 第一组可排为 aa ac de → aaacde，满足非降序。
  • 第三组无论怎样排列均无法得到非降序字符串，故输出 0。

数据范围 ​

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

解题思路 ​

参考程序 ​

编程启蒙 · 竞赛培训 · 机器人教育

扳手亿维科创中心 | 管理员 [email protected]