#G098. GESP level4 真题模拟1

GESP level4 真题模拟1

GESP level4 - 真题模拟1

  1. 运行下面代码片段的结果是( )。
    int y = 24;
    int x = 20;
    int* p = &x;
    int* q = &y;
    p = q;
    {{ select(1) }}
  • x将赋值为24
  • y将赋值为20
  • p将指向y的地址
  • q将指向x的地址
  1. 在C++中,( )正确定义一个名为student的结构体,其中包含一个name字符数组和一个age整数? {{ select(2) }}
  • struct student { char name[20]; int age; };
  • student struct { char name[20]; int age; };
  • student struct { string name; int age; };
  • struct student { char[20] name; int age; };
  1. 在C++中,( )正确声明了一个3行4列的二维数组。 {{ select(3) }}
  • int arr[3, 4];
  • int arr[3][4];
  • int arr[4][3];
  • int arr(3, 4);
  1. 运行如下代码会输出( )。
    int value = 100;
    void print1() {
    int value = 50;
    cout << value << " ";
    cout << ::value << " ";
    }
    void print2() {
    cout << value << " ";
    }
    int main() {
    print1();
    print2();
    return 0;
    }
    {{ select(4) }}
  • 100 100 100
  • 50 50 50
  • 50 100 100
  • 50 50 100
  1. 小杨在整理一副扑克牌的所有红心扑克牌,使其从小到大排列。他的做法是:最开始抓到第1张扑克牌被认为已经排好序;然后抓第2张扑克牌,将其插入至有序部分的正确位置;不断循环步骤,每次将新抓到扑克牌插入至有序部分,直至抓完所有扑克牌,这样抓牌结束时就完成了扑克牌的排序。小杨这种整理扑克牌的方式与( )排序的方式最接近。 {{ select(5) }}
  • 冒泡排序
  • 插入排序
  • 选择排序
  • 直接排序
  1. 以下哪种情况是使用插入排序的合适场景? {{ select(6) }}
  • 数据量非常大,且乱序严重
  • 希望获得稳定排序,但不要求实时性
  • 数据几乎有序,只需少量调整
  • 想在交换次数最少的前提下排好大数组
  1. 给定如下代码,下面描述错误的是( )。
    struct Person {
    std::string name;
    int age;
    struct Address {
    std::string street;
    std::string city;
    };
    Address address;
    };
    {{ select(7) }}
  • 结构Person内嵌套结构Address
  • Person有一个Address类型的address成员
  • 一个Person类型的变量p的address的初始化可以写成:p.address.street = "123 Main St"; p.address.city = "Anytown";
  • 结构的嵌套可以减少命名冲突,因此可以不必控制嵌套层次
  1. 假设int arr[2][3] = {{1,2,3},{4,5,6}};,则arr[1][2]的值是( )。 {{ select(8) }}
  • 2
  • 3
  • 5
  • 6
  1. 下面( )正确定义了二维数组。 {{ select(9) }}
  • int arr[3,4];
  • int arr[3][4];
  • int arr(3,4);
  • int a[3-4];
  1. 给定如下算法,其时间复杂度为( )。
    bool f(int arr[], int n, int target) {
    for (int i = 0; i < (1 << n); i++) {
    int sum = 0;
    for (int j = 0; j < n; j++) {
    if (i & (1 << j)) {
    sum += arr[j];
    }
    }
    if (sum == target)
    return true;
    }
    return false;
    }
    {{ select(10) }}
  • O(n²)
  • O(n×2ⁿ)
  • O(2ⁿ)
  • O(n×log n)
  1. 下面关于排序稳定性的描述,正确的是( )。 {{ select(11) }}
  • 稳定性指算法的时间复杂度恒定
  • 稳定排序保证相同元素的相对顺序不变
  • 选择排序是稳定排序
  • 插入排序不是稳定排序
  1. 下面哪种方式不能实现将字符串"Happy Spring!"输出重定向到文件log.txt ( )。 {{ select(12) }}
  • freopen("log.txt", "w", stdout);
    </li>
    </ul>
    

    cout << "Happy Spring!" << endl; fclose(stdout);

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

      outFile << "Happy Spring!" << endl; outFile.close();

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

        cout << "Happy Spring!" << endl; outFile.close();

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

          streambuf* org_cout = cout.rdbuf(); cout.rdbuf(log_file.rdbuf()); cout << "Happy Spring!" << endl; cout.rdbuf(org_cout);

          </p>
          1. 函数是C++中的核心概念,用于封装可重用的代码块。 {{ select(13) }}
          • 正确
          • 错误
          1. 在C++中,函数的返回类型可以省略,默认为int。 {{ select(14) }}
          • 正确
          • 错误
          1. 结构体的成员默认是public访问权限。 {{ select(15) }}
          • 正确
          • 错误
          1. 假设整数数组arr[4] = {0,1,2,3}的第一个元素在内存中的地址为0x7ffee4065820,经过int* p = arr; p += 1;后,指针p的值是1。 {{ select(16) }}
          • 正确
          • 错误
          1. 二维数组作为函数参数时,必须显式指定所有维度的大小。 {{ select(17) }}
          • 正确
          • 错误
          1. 递推是一种通过已知的初始值和递推公式,逐步求解目标值的算法。 {{ select(18) }}
          • 正确
          • 错误
          1. 考虑最坏情况下冒泡排序算法的时间复杂度,T(n)为待排序数字的数目为n的复杂度,则其递推关系式为T(n) = T(n-1) + n,T(0) = 1。 {{ select(19) }}
          • 正确
          • 错误
          1. 插入排序在最好情况(已有序)下的时间复杂度是O(n²)。 {{ select(20) }}
          • 正确
          • 错误
          1. 对数组arr[] = {4,3,1,5,2}进行升序排序,执行第一轮选择排序后数组arr中的内容是{1, 4, 3, 5, 2}。 {{ select(21) }}
          • 正确
          • 错误
          1. 未捕获异常会调用std::terminate终止程序。 {{ select(22) }}
          • 正确
          • 错误
          1. 冒泡排序的平均时间复杂度为O(n²),但最优情况下为O(n)。 {{ select(23) }}
          • 正确
          • 错误
          1. 冒泡排序和插入排序都是稳定的排序算法。 {{ select(24) }}
          • 正确
          • 错误
          1. 选择排序是稳定的排序算法。 {{ select(25) }}
          • 正确
          • 错误