首页 › 试卷 › GESP编程能力等级认证 › GESP-Python五级 › 2025年3月CCF-GESP编程能力等级认证Python编程五级真题

2025年3月CCF-GESP编程能力等级认证Python编程五级真题 VIP

GESP-Python五级 共 27 题 2025 年 含标准答案与解析
返回试卷列表
本页为整卷浏览:先自己做一遍,再展开「查看答案与解析」核对。

一、单选题

1. 单选题

链表不具备的特点是( )。

  • A 可随机访问任何一个元素
  • B 插入、删除操作不需要移动元素
  • C 无需事先估计存储空间大小
  • D 所需存储空间与存储元素个数成正比
查看答案与解析
答案:A
这道题暂未补解析。
2. 单选题

双向链表中每个结点有两个指针域 prev 和 next ,分别指向该结点的前驱及后继结点。设 p 指向链表中的一个结点,它的前驱结点和后继结点均非空。现要求删除结点 p ,则下述语句中错误的是( )。

  • A
    class Node:
    	def __init__(self, value):
    		self.value = value
    		self.prev = None
    		self.next = None
    
    if p.next:
    	p.next.prev = p.prev
    if p.prev:
    	p.prev.next = p.next
    p = None
  • B
    class Node:
    	def __init__(self, value):
    		self.value = value
    		self.prev = None
    		self.next = None
    
    if p.next:
    	p.next.next = p.prev
    if p.prev:
    	p.prev.next = p.next
    p = None
  • C
    class Node:
    	def __init__(self, value):
    		self.value = value
    		self.prev = None
    		self.next = None
    
    if p.next:
    	p.next.prev = p.prev
    if p.prev:
    	p.prev.next = p.prev
    p = None
  • D
    class Node:
    	def __init__(self, value):
    		self.value = value
    		self.prev = None
    		self.next = None
    
    if p.next:
    	p.next.prev = p.next
    if p.prev:
    	p.prev.next = p.next
    p = None
查看答案与解析
答案:A
这道题暂未补解析。
3. 单选题

假设双向循环链表包含头尾哨兵结点(不存储实际内容),分别为 head 和 tail ,链表中每个结点有两个指针域 prev 和 next ,分别指向该结点的前驱及后继结点。下面代码实现了一个空的双向循环链表,横线上应填的最佳代码是( )。

class ListNode:
	def __init__(self, val=None):
		self.data = val
		self.prev = None
		self.next = None

class LinkedList:
	def __init__(self):
		self.head = ListNode()
		self.tail = ListNode()
_______________________
_______________________


def init_linked_list():
	return LinkedList()
  • A self.head.next = self.tailself.tail.prev = self.head
  • B self.head.next = self.tailself.tail.next = self.head
  • C self.head.next = self.headself.tail.prev = self.tail
  • D self.head.prev = self.tailself.tail.next = self.head
查看答案与解析
答案:A
这道题暂未补解析。
4. 单选题

用以下辗转相除法(欧几里得算法)求gcd(84, 60)的步骤中,第二次调用gcd()函数计算的数是( )。

def gcd(a, b):
	big = max(a, b)
	small = min(a, b)
	if big % small == 0:
		return small
	return gcd(small, big % small)
  • A 84和60
  • B 60和24
  • C 24和12
  • D 12和0
查看答案与解析
答案:B
这道题暂未补解析。
5. 单选题

根据唯一分解定理,下面整数的唯一分解是正确的( )。

  • A 18 = 3 × 6
  • B 28 = 4 × 7
  • C 36 = 2 × 3 × 6
  • D 30 = 2 × 3 × 5
查看答案与解析
答案:D
这道题暂未补解析。
6. 单选题

下述代码实现素数表的线性筛法,筛选出所有小于等于 的素数,横线上应填的最佳代码是( )。

def sieve_linear(n):
	is_prime = [True] * (n + 1)
	primes = []

	if n < 2:
		return primes #

	is_prime[0] = is_prime[1] = False

	for i in range(2, n // 2 + 1):
		if is_prime[i]:
		primes.append(i)


	j = 0
	_____________________________________
		is_prime[i * primes[j]] = False
		if i % primes[j] == 0:
			break
		j += 1


	for i in range(n // 2 + 1, n + 1):
		if is_prime[i]:
		primes.append(i)

	return primes
  • A while j < len(primes) and j * primes[j] <= n:
  • B while j < len(primes) and i * primes[j] <= n:
  • C while j < len(primes) and j * primes[i] <= n:
  • D while i < len(primes) and i * primes[j] < n:
查看答案与解析
答案:B
这道题暂未补解析。
7. 单选题

在程序运行过程中,如果递归调用的层数过多,会因为( )引发错误。(2025.3五级)

  • A 系统分配的栈空间溢出
  • B 系统分配的堆空间溢出
  • C 系统分配的队列空间溢出
  • D 系统分配的链表空间溢出
查看答案与解析
答案:A
这道题暂未补解析。
8. 单选题

对下面两个函数,说法错误的是( )。

def factorialA(n):
	if n <= 1:
		return 1
	return n * factorialA(n - 1)

def factorialB(n):
	if n <= 1:
		return 1
	res = 1
	for i in range(2, n + 1):
		res *= i
	return res
  • A 两个函数的实现的功能相同。
  • B 两个函数的时间复杂度均为 。
  • C factorialA采用递归方式。
  • D factorialB采用递归方式。
查看答案与解析
答案:D
这道题暂未补解析。
9. 单选题

下算法中,( )是不稳定的排序。

  • A 选择排序
  • B 插入排序
  • C 归并排序
  • D 冒泡排序
查看答案与解析
答案:A
这道题暂未补解析。
10. 单选题

考虑以下python代码实现的快速排序算法,将数据从小到大排序,则横线上应填的最佳代码是( )。

def partition(arr, low, high):
	pivot = arr[high]
	i = low - 1

	for j in range(low, high):
	_________________________________

	arr[i + 1], arr[high] = arr[high], arr[i + 1]
	return i + 1

def quick_sort(arr, low, high):
	if low < high:
		pi = partition(arr, low, high)
		quick_sort(arr, low, pi - 1)
		quick_sort(arr, pi + 1, high)
  • A
    if arr[i] < pivot:
    	i += 1
    	arr[i], arr[j] = arr[j], arr[i]
  • B
    if arr[j] < pivot:
    	j += 1
  • C
    if arr[i] < pivot:
    	j += 1
    	arr[i], arr[i] = arr[j], arr[i]
  • D
    if arr[j] < pivot:
    	i += 1
    	arr[i], arr[j] = arr[j], arr[i]
查看答案与解析
答案:D
这道题暂未补解析。
11. 单选题

若用二分法在[1, 100]内猜数,最多需要猜( )次。

  • A 100
  • B 10
  • C 7
  • D 5
查看答案与解析
答案:C
这道题暂未补解析。
12. 单选题

下面的python代码实现了二分查找算法,在数组 arr 找到目标元素 target 的位置,则横线上能填写的最佳代码是( )。

def binary_search(arr, left, right, target):
	while left <= right:
		_________________________

		if arr[mid] == target:
			return mid
		elif arr[mid] < target:
			left = mid + 1
		else:
			right = mid - 1
	return -1
  • A mid = left + (right - left) // 2
  • B mid = left;
  • C mid = (left + right) // 2 + 1;
  • D mid = right;
查看答案与解析
答案:A
这道题暂未补解析。
13. 单选题

贪心算法的核心特征是( )。

  • A 总是选择当前最优解
  • B 回溯尝试所有可能
  • C 分阶段解决子问题
  • D 总能找到最优解
查看答案与解析
答案:A
这道题暂未补解析。
14. 单选题

函数 def find_max(arr, low, high): 计算数组中最大元素,其中数组 arr 从索引 low 到 high ,()正确实现了分治逻辑。

  • A
    def find_max(arr, low, high):
    	if low = high:
    		return arr[low]
    	mid = low + (high - low) // 2
    	left_max = find_max(arr, low, mid)
    	right_max = find_max(arr, mid, high)
    	return left_max if left_max > right_max else right_max
  • B
    def find_max(arr, low, high):
    	if low == high:
    		return arr[low]
    	mid = low + (high - low) // 2
    	left_max = find_max(arr, low, mid)
    	right_max = find_max(arr, mid, high)
    	return left_max if left_max > right_max else right_max
  • C
    def find_max(arr, low, high):
    	if low == high:
    		return arr[low]
    	mid = low + (high - low) // 2
    	left_max = find_max(arr, low, mid)
    	right_max = find_max(arr, mid - 1, high)
    	return left_max if left_max > right_max else right_max
  • D
    def find_max(arr, low, high):
    	if low == high:
    		return arr[low]
    	mid = low + (high - low) // 2
    	left_max = find_max(arr, low, mid)
    	right_max = find_max(arr, mid + 1, high)
    	return left_max if left_max > right_max else right_max
查看答案与解析
答案:D
这道题暂未补解析。
15. 单选题

小杨编写了一个如下的高精度乘法函数,则横线上应填写的代码为( )。

def multiply(a, b):
	m, n = len(a), len(b)
	c = [0] * (m + n)
	for i in range(m):
		for j in range(n):
			c[i + j] += a[i] * b[j]
	carry = 0
	for k in range(len(c)):
		————————————————————
		c[k] = temp % 10
		carry = temp // 10

	while len(c) > 1 and c[-1] == 0:
		c.pop()

	return c
  • A temp = c[k]
  • B temp = c[k] + carry
  • C temp = c[k] - carry
  • D temp = c[k] * carry
查看答案与解析
答案:B
这道题暂未补解析。

二、判断题

16. 判断题

单链表中删除某个结点 p (非尾结点),但不知道头结点,可行的操作是将 p 的值设为 p.next 的值,然后删除 p.next 。

  • A对
  • B错
查看答案与解析
答案:对
这道题暂未补解析。
17. 判断题

链表存储线性表时要求内存中可用存储单元地址是连续的。

  • A对
  • B错
查看答案与解析
答案:错
这道题暂未补解析。
18. 判断题

线性筛相对于埃拉托斯特尼筛法,每个合数只会被它的最小质因数筛去一次,因此效率更高。(2025.3五级)

  • A对
  • B错
查看答案与解析
答案:对
这道题暂未补解析。
19. 判断题

贪心算法通过每一步选择当前最优解,从而一定能获得全局最优解。(2025.3五级)

  • A对
  • B错
查看答案与解析
答案:错
这道题暂未补解析。
20. 判断题

递归函数必须具有一个终止条件,以防止无限递归。

  • A对
  • B错
查看答案与解析
答案:对
这道题暂未补解析。
21. 判断题

快速排序算法的时间复杂度与输入是否有序无关,始终稳定为 。

  • A对
  • B错
查看答案与解析
答案:错
这道题暂未补解析。
22. 判断题

归并排序算法的时间复杂度与输入是否有序无关,始终稳定为 。

  • A对
  • B错
查看答案与解析
答案:对
这道题暂未补解析。
23. 判断题

二分查找适用于对无序数组和有序数组的查找。

  • A对
  • B错
查看答案与解析
答案:错
这道题暂未补解析。
24. 判断题

小杨有10元去超市买东西,每个商品有各自的价格,每种商品只能买1个,小杨的目标是买到最多数量的商品。小杨采用的策略是每次挑价格最低的商品买,这体现了分治思想。

  • A对
  • B错
查看答案与解析
答案:错
这道题暂未补解析。
25. 判断题

归并排序算法体现了分治算法,每次将大的待排序数组分成大小大致相等的两个小数组,然后分别对两个小数组进行排序,最后对排好序的两个小数组合并成有序数组。

  • A对
  • B错
查看答案与解析
答案:对
这道题暂未补解析。

三、简答题

26. 简答题

平均分配

题目描述

小 A 有2n 件物品,小 B 和小 C 想从小 A 手上买走这些物品。对于第 i件物品,小 B 会以bi 的价格购买,而小 C 会以 ci的价格购买。为了平均分配这 2n件物品,小 A 决定小 B 和小 C 各自只能买走恰好n 件物品。你能帮小 A 求出他卖出这 2n件物品所能获得的最大收入吗?

输入格式

第一行,一个正整数n 。

第二行, 2n个整数b1,b2,...,b2n 。

第三行,2n 个整数 c1,c2,...,c2n。

输出格式

一行,一个整数,表示答案。


输入样例 1

3

1 3 5 6 8 10

2 4 6 7 9 11

输出样例 1

36

输入样例 2

2

6 7 9 9

1 2 10 12

输出样例 2

35

数据范围

对于20 % 的测试点,保证1 ≤n≤8。

对于另外20 % 的测试点,保证 0≤bi≤1,0≤ci≤1 。

对于所有测试点,保证 1 ≤n≤105,0≤bi≤109,0 ≤ci≤109 。

查看答案与解析
答案:<pre class="brush:python;toolbar:false">n = int(input()) b = list(map(int, input().split())) c = list(map(int, input().split())) d = [c[i] - b[i] for i in range(2 * n)] print(sum(b) + sum(sorted(d)[n:]))</pre>
这道题暂未补解析。
27. 简答题

原根判断

题目描述

小 A 知道,对于质数p 而言,p 的原根g 是满足以下条件的正整数:

·1<g<p

·gp-1 mod p=1

·对于任意1≤i<p-1 均有 gi mod p≠1。

其中a mod p 表示a 除以 p的余数。

小 A 现在有一个整数a ,请你帮他判断 a是不是p 的原根。

输入格式

第一行,一个正整数 T,表示测试数据组数。

每组测试数据包含一行,两个正整数a ,p 。

输出格式

对于每组测试数据,输出一行,如果 a是 p的原根则输出 Yes ,否则输出 No 。


输入样例

3
3 998244353
5 998244353
7 998244353

输出样例

Yes
Yes
No

数据范围

对于 40% 的测试点,保证3≤p≤103 。

对于所有测试点,保证1≤T≤20 ,3≤p≤109,1<a<p ,p为质数。

查看答案与解析
答案:<pre class="brush:python;toolbar:false">def fpw(b, e, p): if e == 0: return 1 r = fpw(b, e &gt;&gt; 1, p) return r * r * (b if e &amp; 1 else 1) % p def solve(): a, p = map(int, input().split()) phi, v = p - 1, p - 1 for i in range(2, int(phi ** 0.5) + 2): if v % i == 0: while v % i == 0: v //= i if fpw(a, phi // i, p) == 1: print("No") return if v &gt; 1: if fpw(a, phi // v, p) == 1: print("No") return print("Yes") [solve() for _ in range(int(input()))]</pre>
这道题暂未补解析。