#G079. GESP level4 2024年12月四级试卷

GESP level4 2024年12月四级试卷

GESP level4 - 2024年12月四级试卷

  1. 下面的语句中,( )正确定义了一个计算浮点数的平方(x² = x×x)的函数,并成功调用该函数。 {{ select(1) }}
  • float square(float x) {
      return x * x;
    </li>
    </ul>
    

    } float area = square(2);

    </p>
    • square(float x) {
        return x * x;
      </li>
      </ul>
      

      } float area = square(2);

      </p>
      • void square(float x) {
          return x * x;
        </li>
        </ul>
        

        } area = square(2.0);

        </p>
        • void square(float x) {
            x * x;
            return;
          </li>
          </ul>
          

          } area = square(2);

          </p>
          1. 下面代码的描述中,正确的是( )。
            void n_chars(char c, int n) {
            while (n-- > 0)
            cout << c;
            }
            char my_char = 'w';
            int times = 5;
            n_chars(my_char, times);
            {{ select(2) }}
          • 代码执行结束后,times的值为0
          • n是形参,times是实参
          • n是实参,times是形参
          • 代码最后一行换成n_chars(times, my_char);也可以
          1. 给定以下代码,执行后变量a的值为( )。
            void func(int& x) {
            x = x * 2;
            }
            int a = 5;
            func(a);
            {{ select(3) }}
          • 5
          • 10
          • 15
          • 20
          1. 运行下面代码,屏幕上输出是( )。
            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;
            {{ select(4) }}
          • 0.2
          • 0.5
          • 1.2
          • 1.5
          1. 运行下面代码片段后,x和p的结果分别是( )。
            int x = 20;
            int</em> p = &x;
            *p = *p + 2;
            {{ select(5) }}
          • 20 20
          • 20 22
          • 22 20
          • 22 22
          1. 下面的描述中,( )不能正确定义一个名为Student的结构体以及一个包含20个元素的结构数组。 {{ select(6) }}
          • struct Student {
              string name;
              int age;
              float score;
            </li>
            </ul>
            

            }; struct Student students[20];

            </p>
            • struct Student {
                string name;
                int age;
                float score;
              </li>
              </ul>
              

              }; Student students[20];

              </p>
              • struct Student {
                  string name;
                  int age;
                  float score;
                </li>
                </ul>
                

                }; Student* students = new Student[20];

                </p>
                • struct Student {
                    string name;
                    int age;
                    float score;
                  </li>
                  </ul>
                  

                  }; Student students = new Student[20];

                  </p>
                  1. 假定整型是32位,对⼀个 ⾏ 列的⼆维整数数组array ,假设数组第⼀个元素在内存中的地址为0x7ffee4065820 ,则第2⾏第2个元素的地址&array[1][1] 为( )。
                    int array[2][3] = {{0, 1, 2}, {3, 4, 5}};
                    {{ select(7) }}
                  • 0x7ffee4065824
                  • 0x7ffee4065828
                  • 0x7ffee406582c
                  • 0x7ffee4065830
                  1. 下面( )正确定义二维数组。 {{ select(8) }}
                  • int a[3][];
                  • int a[][];
                  • int a[][4];
                  • int a[][2] = {{1,2},{1,2},{3,4}};
                  1. 下面代码采用递推算法来计算斐波那契数列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;
                    }
                    {{ select(9) }}
                  • result = f1 + f2;
                    </li>
                    </ul>
                    

                    f1 = f2; f2 = result;

                    </p>
                    • result += f1 + f2;
                      </li>
                      </ul>
                      

                      f1 = f2; f2 = result;

                      </p>
                      • result += f1 + f2;
                        </li>
                        </ul>
                        

                        f2 = result; f1 = f2;

                        </p>
                        • result = f1 + f2;
                          </li>
                          </ul>
                          

                          f2 = result; f1 = f2;

                          </p>
                          1. 下面关于排序算法(冒泡排序、插入排序和选择排序)的描述中,不正确的是( )。 {{ select(10) }}
                          • 冒泡排序基于元素交换实现,需借助临时变量;插入排序基于元素赋值实现,因此冒泡排序的计算开销通常比插入排序更高。
                          • 选择排序在任何情况下的时间复杂度都为O(n²)。
                          • 冒泡排序在任何情况下的时间复杂度都为O(n²)。
                          • 如果给定数据部分有序,插入排序通常比选择排序效率更高。
                          1. 冒泡排序的第一轮操作是从左到右遍历数组,通过两两比较相邻元素,将当前最大的元素移动到末尾。给定数组arr[] = {4, 1, 3, 1, 5, 2},执行第一轮冒泡排序后数组arr中的内容为( )。 {{ select(11) }}
                          • 1, 4, 3, 1, 5, 2
                          • 1, 3, 1, 4, 2, 5
                          • 1, 4, 3, 1, 2, 5
                          • 4, 1, 3, 1, 5, 2
                          1. 给定如下代码,其时间复杂度为( )。
                            int cellRecur(int n) {
                            if (n == 1)
                            return 1;
                            return cellRecur(n - 1) + cellRecur(n - 1) + 1;
                            }
                            {{ select(12) }}
                          • O(n²)
                          • O(2ⁿ)
                          • O(1)
                          • O(n)
                          1. 下面代码实现了插入排序函数,则横线上应填写( )。
                            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;
                            }
                            }
                            {{ select(13) }}
                          • 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;
                          1. 下面哪种方式不能实现将字符串"Welcome to GESP!"输出重定向到文件log.txt ( )。 {{ select(14) }}
                          • freopen("log.txt", "w", stdout);
                            </li>
                            </ul>
                            

                            cout << "Welcome to GESP!" << endl; fclose(stdout);

                            </p>
                            • std::ofstream outFile("log.txt");
                              </li>
                              </ul>
                              

                              outFile << "Welcome to GESP!" << endl; outFile.close();

                              </p>
                              • std::ofstream outFile("log.txt");
                                </li>
                                </ul>
                                

                                cout << "Welcome to GESP!" << endl; outFile.close();

                                </p>
                                • ofstream log_file("log.txt");
                                  </li>
                                  </ul>
                                  

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

                                  </p>
                                  1. 运行下面的代码,将出现什么情况?( )
                                    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;
                                    }
                                    {{ select(15) }}
                                  • 屏幕上输出Caught: Runtime error occurred
                                  • 屏幕上输出Caught an unknown exception
                                  • 程序调用std::terminate()
                                  • 编译错误
                                  1. 在C++中,下面代码可以正确定义指针和初始化指针。
                                    int* ptr;
                                    *ptr = 10;
                                    {{ select(16) }}
                                  • 正确
                                  • 错误
                                  1. 一个函数必须在调用之前既声明又定义。 {{ select(17) }}
                                  • 正确
                                  • 错误
                                  1. 函数参数可以通过值传递、引用传递和指针传递,这样函数内对参数的修改可以直接修改传入变量的值。 {{ select(18) }}
                                  • 正确
                                  • 错误
                                  1. int arr[3][]是一个正确的二维数组的声明。 {{ select(19) }}
                                  • 正确
                                  • 错误
                                  1. 递推是一种通过已知的初始值和递推公式,逐步求解目标值的算法。 {{ select(20) }}
                                  • 正确
                                  • 错误
                                  1. 某算法的递推关系式为T(n) = T(n-1) + n(n为正整数)及T(0) = 1,则该算法的时间复杂度为O(n²)。 {{ select(21) }}
                                  • 正确
                                  • 错误
                                  1. 冒泡排序的平均时间复杂度为O(n²),但最优情况下为O(n)。 {{ select(22) }}
                                  • 正确
                                  • 错误
                                  1. 冒泡排序和插入排序都是稳定的排序算法。 {{ select(23) }}
                                  • 正确
                                  • 错误
                                  1. 选择排序是稳定的排序算法。 {{ select(24) }}
                                  • 正确
                                  • 错误
                                  1. 在C++语言中,如果一个函数可能抛出异常,那么一定要在try子句里调用这个函数。 {{ select(25) }}
                                  • 正确
                                  • 错误