2024年3月GESP等级认证C++编程五级真题

最新推荐文章于 2024-10-09 19:41:46 发布

@小码农

最新推荐文章于 2024-10-09 19:41:46 发布

阅读量821

点赞数 18

文章标签： java 算法 javascript

本文链接：https://blog.csdn.net/m0_67260462/article/details/137082134

版权

2024年3月GESP认证C++编程五级真题试卷

题目总数：27 总分数：100

选择题

第 1 题单选题

唯⼀分解定理描述的内容是 ( ) ?

A.任意整数都可以分解为素数的乘积

B.每个合数都可以唯⼀分解为⼀系列素数的乘积

C.两个不同的整数可以分解为相同的素数乘积

D.以上都不对

第 2 题单选题

贪⼼算法的核⼼思想是 ( ) ?

在每⼀步选择中都做当前状态下的最优选择

在每⼀步选择中都选择局部最优解

在每⼀步选择中都选择全局最优解

以上都对

第 3 题单选题

下⾯的 C++代码⽚段⽤于计算阶乘。请在横线处填⼊（），实现正确的阶乘计算。

1 int factorial(int n) {
2 if (n == 0 || n == 1) {
3  return 1;
4 } else {
5          // 在此处填入代码
6 }
7 }

return n * factorial(n - 1);

return factorial(n - 1) / n;

return n * factorial(n);

return factorial(n / 2) * factorial(n / 2);

第 4 题单选题

下⾯的代码⽚段⽤于在双向链表中删除⼀个节点。请在横线处填⼊（），使其能正确实现相应功能。

1 void deleteNode(DoublyListNode*& head, int value) {
2  DoublyListNode* current = head;
3  while (current != nullptr && current->val != value) {
4   current = current->next;
5  }
6  if (current != nullptr) {
7   if (current->prev != nullptr) {
8     ____________________________________ // 在此处填入代码
9   } else {
10    head = current->next;
11  }
12  if (current->next != nullptr) {
13   current->next->prev = current->prev;
14  }
15  delete current;
16  }
17 }

if (current->next != nullptr) current->next>prev = current->prev;

current->prev->next = current->next;

delete current->next;

current->prev = current->next;

第 5 题单选题

辗转相除法也被称为 ( )

⾼斯消元法

费马定理

欧⼏⾥德算法

⽜顿迭代法

第 6 题单选题

下⾯的代码⽚段⽤于计算斐波那契数列。该代码的时间复杂度是 ( ) ?

1 Int fibonacci(int n) {
2  if (n <= 1) {
3   return n;
4  } else {
5   return fibonacci(n - 1) + fibonacci(n - 2);
6  }
7 }

0(1)

0(n)

0(2n )

o(1og n)

第 7 题单选题

下⾯的代码⽚段⽤于将两个⾼精度整数进⾏相加。请在横线处填⼊（），使其能正确实现相应功能。

1 string add(string num1, string num2) {
2  string result;
3  int carry = 0;
4  int i = num1.size() - 1, j = num2.size() - 1;
5  while (i >= 0 || j >= 0 || carry) {
6   int x = (i >= 0) ? num1[i--] - '0 ' : 0;
7   int y = (j >= 0) ? num2[j--] - '0 ' : 0;
8   int sum = x + y + carry;
9   carry = sum / 10;
10                             
11 }
12  return result;
13 }

 result = to_string(sum % 10) + result;

 result = to_string(carry % 10) + result;

result = to_string(sum / 10) + result;

 result = to_string(sum % 10 + carry) + result;

第 8 题单选题

给定序列：1 ，3 ，6 ，9， 17 ，31 ，39 ，52 ，61 ，79 ，81 ，90 ，96 。使⽤以下代码进⾏⼆分查找查找元素82时，需要循环多少次，即最后输出的times值为（）。

1 int binarySearch(const std::vector<int>& arr, int target) {
2  int left = 0;
3  int right = arr.size() - 1;
4  int times = 0;
5  while (left <= right) {
6   times ++;
7   int mid = left + (right - left) / 2;
8   if (arr[mid] == target) {
9    cout << times << endl;
10   return mid;
11   } else if (arr[mid] < target) {
12    left = mid + 1;
13   } else {
14    right = mid - 1;
15   }
16  }
17  cout << times << endl;
18  return -1;
19 }

第 9 题单选题

下⾯的代码⽚段⽤于判断⼀个正整数是否为素数。请对以下代码进⾏修改，使其能正确实现相应功能。 ( )

1 bool isPrime(int num) {
2  if (num < 2) {
3   return false;
4  }
5  for (int i = 2; i * i < num; ++i) {
6   if (num % i == 0) {
7    return false;
8   }
9  }
10  return true;
11 }

num < 2 应该改为 num <= 2

循环条件 i * i < num 应该改为 i * i <= num

循环条件应该是 i <= num

循环体中应该是 if (num % i != 0)

第 10 题单选题

在埃拉托斯特尼筛法中，要筛选出不⼤于n的所有素数，最外层循环应该遍历什么范围 ( ) ?

1 vector<int> sieveOf Eratosthenes(int n) {
2  std::vector<bool> isPrime(n + 1, true);
3  std::vector<int> primes;
4                      {
5   if (isPrime[i]) {
6    primes.push_back(i);
7    for (int j = i * i; j <= n; j += i) {
8     isPrime[j] = false;
9     }
10   }
11  }
12  for (int i = sqrt(n) + 1; i <= n; ++i) {
13   if (isPrime[i]) {
14    primes.push_back(i);
15   }
16  }
17  return primes;
18 }

for (int i = 2; i <= n; ++i)

for (int i = 1; i < n; ++i)

for (int i = 2; i <= sqrt(n); ++i)

for (int i = 1; i <= sqrt(n); ++i)

第 11 题单选题

素数的线性筛法时间复杂度为（）。

O（n）

O（nloglogn）

O（nlogn）

O（n2）

第 12 题单选题

归并排序的基本思想是（）。

动态规划

分治

贪⼼算法

回溯算法

第 13 题单选题

在快速排序中，选择的主元素（pivot）会影响算法的（）。

不影响

时间复杂度

空间复杂度

时间复杂度和空间复杂度

第 14 题单选题

递归函数在调⽤⾃⾝时，必须满⾜（），以避免⽆限递归？

有终⽌条件

函数参数递减（或递增）

函数返回值固定

以上都对

第 15 题单选题

假设给定链表为: 1→3→5→7→nullptr ，若调⽤searchValue(head, 5) ，函数返回值为（）。

1 int searchValue(ListNode* head, int target) {
2  while (head != nullptr) {
3   if (head->val == target) {
4    return 1;
5   }
6   head = head->next;
7  }
8  return 0;
9 }

返回1

返回0

死循环，⽆法返回

返回 - 1