理论卷2026年3月GESP等级认证(Python) · 五级

GESP Python 5级 2026.03

满分 100 · 及格 60 · 时长 60 分钟 · 共 27 题 (单选15 / 判断10 / 编程题2)

试卷阅览 · 免费预览前 10 题 · 交卷后可查看答案与解析

单选题号 #8534

分值 2

关于 Python 实现的单链表、双链表和循环链表，下列说法正确的是（）。

在 Python 实现的单链表中，若已知任意结点对象的引⽤，则可以在 $O(1)$ 时间内删除该结点。

Python 实现的循环链表中⼀定不存在值为 None 的引⽤属性。

在 Python 实现的循环双链表中，尾结点对象的 next 属性值⼀定为 None。

在 Python 实现的带头结点的循环单链表中，判定链表是否为空只需判断头结点对象的 next 属性是否引⽤头结点⾃⾝（即 head.next is head）。

单选题号 #8535

分值 2

双向循环链表中要在结点 $p$ 之前插⼊新结点 $s$ （均⾮空），以下操作正确的是（）。

pythons.next = pp.prev = sq.next = ss.prev = q

pythons.prev = ps.next = p.nextp.next.prev = sp.next = s

pythons.next = ps.prev = p.prevp.prev.next = sp.prev = s

pythons.next = ps.prev = nullptrp.prev = s

单选题号 #8536

分值 2

下⾯函数删除单向链表中 val == x 的节点，并且使⽤哑结点统⼀对头结点和中间节点的删除操作。横线处应填（）。

class Node:
 def __init__(self, val):
 self.val = val
 self.next = None

def eraseAll(head, x):
 dummy = Node(0)
 dummy.next = head 
 cur = dummy 
 while cur.next: 
 if cur.next.val == x:
 _____________________ # 填空处
 else:
 cur = cur.next 
 return dummy.next

cur = cur.next

cur.next = cur.next.next

cur.next = None

cur.next = nullptr

单选题号 #8537

分值 2

对如下代码实现的欧⼏⾥得算法（辗转相除法），调⽤ gcd(48, 18) 得到的调⽤序列为（）。

def gcd(a, b):
 if b == 0:
 return a
 else:
 return gcd(b, a % b)

$gcd(48, 18) \rightarrow gcd(18, 12) \rightarrow gcd(12, 6) \rightarrow gcd(6, 0)$

$gcd(48, 18) \rightarrow gcd(30, 18) \rightarrow gcd(12, 18)$

$gcd(48, 18) \rightarrow gcd(18, 30) \rightarrow gcd(30, 6)$

$gcd(48, 18) \rightarrow gcd(12, 18) \rightarrow gcd(6, 12)$

单选题号 #8538

分值 2

下⾯代码实现了欧拉（线性）筛，横线处应填写（）。

def euler_sieve_for(n):
 if n n:
 break
 is_composite[i * p] = True
 if i % p == 0:
 break
 return primes

for j in range(len(primes + 1)):

for j in range(len(primes) + 1):

for j in range(len(primes)):

for j in range(len(primes) - 1):

单选题号 #8539

分值 2

埃⽒筛中将内层循环循环从 j = i*i 开始⽽不是 j = 2*i的主要原因是（）。

def eratosthenes_sieve_for(n):
 if n < 2:
 return []
 is_composite = [False] * (n + 1)
 primes = []
 for i in range(2, n + 1):
 if is_composite[i]:
 continue
 primes.append(i)
 
 # 用 for 循环模拟 C++ 的 j = i*i; j \le n; j += i
 for j in range(i * i, n + 1, i):
 is_composite[j] = True
 
 return primes

因为 2*i ⼀定不是合数

i*i⼀定是质数

⼩于 i*i 的 i 的倍数已被更⼩质因⼦筛过

这样可以把时间复杂度降为 $O(n)$

单选题号 #8540

分值 2

下⾯程序的运⾏结果为（）。

def check(n, a, k, dist):
 cnt = 1 
 last = a[0] 
 
 for i in range(1, n):
 if a[i] - last >= dist:
 cnt += 1
 last = a[i]
 
 return cnt >= k

def solve(n, a, k):
 a.sort() 
 
 l = 0
 r = a[-1] - a[0] 
 
 while l < r:
 mid = (l + r + 1) // 2 
 if check(n, a, k, mid):
 l = mid
 else:
 r = mid - 1
 
 return l

if __name__ == "__main__":
 a = [1, 2, 8, 4, 9]
 n = 5
 k = 3
 result = solve(n, a, k)
 print(result)

$2$

$3$

$4$

$5$

单选题号 #8541

分值 2

在升序数组中查找第⼀个⼤于等于 $x$ 的位置，下⾯循环中横线应填（）。

def lowerBound(a, x):
 l = 0
 r = len(a) 
 while l = x:
 r = mid
 else:
 l = mid + 1
 return l
if __name__ == "__main__":
 a1 = [1, 3, 5, 7, 9]
 x1 = 5
 print(f"数组 {a1} 中第一个 ≥ {x1} 的位置：{lowerBound(a1, x1)}")

r = mid

r = mid - 1

l = mid

l = mid + 1

单选题号 #8542

分值 2

关于递归函数调⽤，下列说法错误的是（）。

递归调⽤层次过深时，可能会耗尽栈空间导致栈溢出。

尾递归函数可以通过编译器优化来避免栈溢出。

所有递归函数都可以通过循环结构来改写，从⽽避免栈溢出。

栈溢出发⽣时，程序会抛出异常并可以继续执⾏后续代码。

单选题号 #8543

分值 2

给定 n 根⽊头，第 i 根长度为 a[i]。要切成不少于 m 段等长⽊段，求最⼤可能长度，则横线上应填（）。

def check(a, m, x):
 cnt = 0
 for length in a:
 if x == 0: 
 return True
 cnt += length 
 if cnt >= m: 
 return True
 return cnt >= m

def main():
 import sys
 input = sys.stdin.read().split()
 idx = 0
 n = int(input[idx])
 idx += 1
 m = int(input[idx])
 idx += 1
 
 a = []
 mx = 0
 for _ in range(n):
 num = int(input[idx])
 idx += 1
 a.append(num)
 mx = max(mx, num)
 
 l = 1
 r = mx
 ans = 0
 
 while l <= r:
 mid = l + (r - l) // 2
 if check(a, m, mid):
 ans = mid 
 _______________
 else:
 _______________
 print(ans)

if __name__ == "__main__":
 main()

l = mid + 1 和 r = mid - 1

r = mid - 1 和 l = mid + 1

l = mid + 1 和 r = mid

l = mid - 1 和 r = mid + 1

🔒

已解锁前 10 题

第 11~27 题（共 17 题）需开通题库会员或使用积分包作答

本卷为 VIP 试卷：需开通题库会员（无限刷）或购买积分包（每题 1 积分）；已购长期正课学员自动享有权益