首页 › 题库 › GESP编程能力等级认证 › GESP-Python五级

GESP-Python五级 题库

共 296 道题 ,第 1 / 15 页 · 按题型筛选,点「查看答案」核对解析
1 单选题 适中 GESP编程能力等级认证 ·GESP-Python五级 · 4.1 单链表

对如下定义的循环单链表,`print_list` 函数横线处填写()。

class Node:
def __init__ (self , data) :
    self.data = data
    self.next = None
def create_list(value) :
    head = Node(value)
    head.next = head
    return head
def insert_tail(head , value) :
    p = head
    while p.next != head:
        p = p.next
    node = Node(value)
    node.next = head
    p.next = node
def print_list(head) :
    # 填空位置
    while True:
        print(p.data , end="  ")
        p = p.next
        if p == head :
            break
    print()
A
if head is None: return p.next = head
B
if head is None: return p = head.next
C
if head is None: return p = head
D
if head.next is None: return p = head
答案与解析
正确答案:C
循环单链表打印需要先初始化遍历指针p,若表头不为空则令p=head,题目选项缺失C、D,标准答案为C,核心逻辑是先给p赋值链表起始节点才能进入循环打印。
题目详情
2 单选题 适中 GESP编程能力等级认证 ·GESP-Python五级 · 综合练习

区块链技术是比特币的基础。在区块链中,每个区块指向前一个区块,构成链式列表,新区块只能接在链尾,不允许在中间插入或删除。下面代码实现插入区块添加函数,则横线处填写()。

class Block :
def __init__ (self , idx , data , prev_block) :
    self.index = idx
    self.data = data
    self.prev = prev_block
class Blockchain:
def __init__ (self) :
    self.tail = None
def init(self) :
    genesis_block = Block(0 , "Genesis Block " , None)
    self.tail = genesis_block
def add_block(self , data) :
    # 填空位置
def clear(self) :
    cur = self.tail
    while cur is not None:
        prev_block = cur.prev
        cur.prev = None
        cur = prev_block
    self.tail = None
def print_chain(self) :
    cur = self.tail
    chain = []
    while cur is not None:
        chain.append(f"Block {cur.index}: {cur.data}")
        cur = cur.prev
    for block_info in reversed(chain) :
        print(block_info)
A
new_block = Block(self.tail.index, data, self.data)
B
new_block = Block(self.tail.index + 1 , data , self.tail) self.tail = new_block
C
new_block = Block(self .tail .index, data+1, self.data) self .tail = new_block
D
new_block = Block(self .tail .index , data , self .tail) self.tail.data = new_block
答案与解析
正确答案:B
新增区块序号为尾区块序号+1,前驱指向原尾区块,最后更新链表尾指针为新块;A参数self.data错误,逻辑不成立。
题目详情
3 单选题 适中 GESP编程能力等级认证 ·GESP-Python五级 · 4.1 单链表

下面关于单链表和双链表的描述中,正确的是()。

class DNode:
    def __init__(self, data):
        self.data = data
        self.prev = None
        self.next = None
def delete_dnode(node):
    if node.prev:
        node.prev.next = node.next
    if node.next:
        node.next.prev = node.prev
    node.prev = None
    node.next = None
class SNode:
    def __init__(self, data):
        self.data = data
        self.next = None
def delete_snode(head, node):
    if head is None or node is None:
        return
    prev = head
    while prev.next != node:
        prev = prev.next
    prev.next = node.next
    node.next = None
A
双链表删除指定节点是O(n),单链表是O(1)
B
双链表删除指定节点是O(n) ,单链表是O(1)
C
双链表删除指定节点是O(1) ,单链表是O(n)
D
双链表删除指定节点是O(n) ,单链表是O(n)
答案与解析
正确答案:C
已知目标节点指针时,双链表可直接访问前驱完成删除O(1);单链表需要遍历找到前驱节点,复杂度O(n)。
题目详情
4 单选题 适中 GESP编程能力等级认证 ·GESP-Python五级 · 1.3 同余与模运算

假设我们有两个数 a = 38 和 b = 14 ,它们对模 m 同余, 即a ≡ b (mod m)。以下哪个值不可能是 m?

A
3
B
4
C
6
D
9
答案与解析
正确答案:D
同余要求m整除两数差值,38-14=24;24能被3、4、6整除,不能被9整除,因此m不能为9。
题目详情
5 单选题 适中 GESP编程能力等级认证 ·GESP-Python五级 · 1.2 最大公约数与最小公倍数

下面代码实现了欧几里得算法,下面有关说法,错误的是()。

def gcd1(a: int , b : int) -> int :
    return a if b == 0 else gcd1(b , a % b)
def gcd2(a: int , b : int) -> int :
    while b != 0 :
        temp = b
        b = a % b
        a = temp
    return a
A
gcd1() 实现为递归方式。
B
gcd2() 实现为迭代方式。
C
当数值较大时, gcd1() 实现会多次调用自身,需要较多额外的辅助空间。
D
当数值较大时, gcd1() 的实现比 gcd2() 执行效率更高。
答案与解析
正确答案:D
递归会产生函数调用栈开销,迭代无需栈空间,同等数据下迭代gcd2效率更高,D描述错误。
题目详情
6 单选题 适中 GESP编程能力等级认证 ·GESP-Python五级 · 1.4 质因数分解

唯一分解定理描述的内容是()。

A
任何正整数都可以表示为两个素数的和。
B
任何大于1的合数都可以唯一分解为有限个质数的乘积。
C
两个正整数的最大公约数总是等于它们的最小公倍数除以它们的乘积。
D
所有素数都是奇数。
答案与解析
正确答案:B
唯一分解定理(算术基本定理):大于1的正整数均可唯一拆分为质数乘积;A是哥德巴赫猜想,C公式颠倒,2是偶素数故D错。
题目详情
7 单选题 适中 GESP编程能力等级认证 ·GESP-Python五级 · 1.1 素数与合数

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

def linear_sieve(n) :
    if n < 2 :
        return []
    is_prime = [True] * (n + 1)
    is_prime[0] = is_prime[1] = False
    primes = []
    for i in range(2 , n + 1) :
        if is_prime[i] :
            primes.append(i)
        for j in range(len(primes)) :
            p = primes[j]
            if i * p > n:
                break
            # 填空位置
            if i % p == 0 :
                break
    return primes
A
is_prime [i * p] = False
B
is_prime [i] = False
C
is_prime [i * p] = True
D
is_prime [i + p] = False
答案与解析
正确答案:A
线性筛核心:将i*p标记为合数,填入`is_prime[i*p] = False`。
题目详情
8 单选题 适中 GESP编程能力等级认证 ·GESP-Python五级 · 综合练习

下列关于排序的说法,正确的是( )。

A
快速排序是稳定排序
B
归并排序通常是稳定的
C
插入排序是不稳定排序
D
冒泡排序不是原地排序
答案与解析
正确答案:B
归并排序是稳定排序;快排不稳定、插入排序稳定、冒泡排序属于原地排序。
题目详情
9 单选题 适中 GESP编程能力等级认证 ·GESP-Python五级 · 7.1 归并排序

下面代码实现了归并排序。下述关于归并排序的说法中,不正确的是( )。

def merge(arr, temp, l, mid, r):
    i = l
    j = mid + 1
    k = l
    while i <= mid and j <= r:
        if arr[i] <= arr[j]:
            temp[k] = arr[i]
            i += 1
        else:
            temp[k] = arr[j]
            j += 1
        k += 1
    while i <= mid:
        temp[k] = arr[i]
        i += 1
        k += 1
    while j <= r:
        temp[k] = arr[j]
        j += 1
        k += 1
    for p in range(l, r + 1):
        arr[p] = temp[p]
def merge_sort(arr, temp, l, r):
    if l >= r:
        return
    mid = l + (r - l) // 2
    merge_sort(arr, temp, l, mid)
    merge_sort(arr, temp, mid + 1, r)
    merge(arr, temp, l, mid, r)
def merge_sort_wrapper(arr):
    if not arr:
        return []
    temp = [0] * len(arr)
    merge_sort(arr, temp, 0, len(arr) - 1)
    return arr
A
归并排序的平均复杂度是 O(nlogn)。
B
归并排序需要O(n) 的额外空间。
C
归并排序在最坏情况的时间复杂度是 O(n²)。
D
归并排序适合大规模数据。
答案与解析
正确答案:C
归并排序最好、平均、最坏复杂度均为O(nlogn),C描述错误。
题目详情
10 单选题 适中 GESP编程能力等级认证 ·GESP-Python五级 · 2.1 多项式复杂度

下述python代码实现了快速排序算法,最差情况时间复杂度是()。

def partition(arr, low, high):
    i = low
    j = high
    pivot = arr[low]
    while i < j:
        while i < j and arr[j] >= pivot:
            j -= 1
        while i < j and arr[i] <= pivot:
            i += 1
        if i < j:
            arr[i], arr[j] = arr[j], arr[i]
    arr[i], arr[low] = arr[low], arr[i]
    return i
def quick_sort(arr, low, high):
    if low >= high:
        return
    p = partition(arr, low, high)
    quick_sort(arr, low, p - 1)
    quick_sort(arr, p + 1, high)
def quick_sort_wrapper(arr):
    if not arr:
        return []
    quick_sort(arr, 0, len(arr) - 1)
    return arr
A
O(n)
B
O(logn)
C
O(n²)
D
O(nlogn)
答案与解析
正确答案:C
有序/逆序数组做快排,每次划分只分出一个元素,递归深度n,时间复杂度O(n²)。
题目详情
11 单选题 适中 GESP编程能力等级认证 ·GESP-Python五级 · 综合练习

下面代码尝试在有序数组中查找第一个大于等于 x 的元素位置。如果没有大于等于 x 的元素,返回数组长度。以下说法正确的是( )。

def lower_bound(arr, x):
    l = 0
    r = len(arr)
    while l < r:
        mid = l + (r - l) // 2
        if arr[mid] >= x:
            r = mid
        else:
            l = mid + 1
    return l
A
上述代码逻辑正确
B
上述代码逻辑错误, while 循环条件应该用 l <= r
C
上述代码逻辑错误, mid 计算错误
D
上述代码逻辑错误,边界条件不对
答案与解析
正确答案:A
原题二分查找实现标准左边界查找逻辑,代码逻辑无错误。
题目详情
12 单选题 适中 GESP编程能力等级认证 ·GESP-Python五级 · 综合练习

小杨要把一根长度为 L 的木头切成 K 段,使得每段长度小于等于 x。已知每切一刀只能把一段木头分成两段,他用二分法找到满足条件的最小 x( x 为正整数),则横线处应填写( )。

def check(L , K , x) :
    cuts = (L - 1) // x
    return cuts <= K
def binary_cut(L , K) :
    l = 1
    r = L
    while l < r:
        # 填空位置
    return l
if __name__ == "__main__" :
    L = 10
    K = 2
    result = binary_cut(L , K)
    print(result)
A
mid = l + (r) // 2 if check(L , K , mid+1) : r = mid else: l = mid + 1
B
mid = l + ( r - l) // 2 if check(L , K , mid) : r = mid else: l = mid + 1
C
mid = l + ( r - l) // 2 if check(L+1 , K , mid) : r = mid else: l = mid + 1
D
mid = l + ( r - l) // 2 if check(L+1 , K , mid) : r = mid else: l = mid
答案与解析
正确答案:A
二分求满足条件最小值模板,mid计算、判断mid+1收缩右边界,A逻辑匹配题意;C/D错误传入L+1,B收缩逻辑不对。
题目详情
13 单选题 适中 GESP编程能力等级认证 ·GESP-Python五级 · 综合练习

根据下面代码,以下说法正确的是()。

def factorial1(n) :
    if n <= 1 :
        return 1
    return n * factorial1(n - 1)
def factorial2(n) :
    result = 1
    while n > 1 :
        result *= n
        n -= 1
    return result
A
上面两种实现方式的时间复杂度相同,都为O(n)
B
上面两种实现方式空间复杂度相同,都为O(1)
C
函数 factorial1() 的时间复杂度为 O(2ⁿ),函数 factorial2() 的时间复杂度为 O(1)
D
上面两种实现方式空间复杂度相同,都为O(n)
答案与解析
正确答案:A
递归阶乘、迭代阶乘均循环n次,时间复杂度均O(n);递归空间O(n),迭代O(1),B、D错误,C时间复杂度描述错误。
题目详情
14 单选题 适中 GESP编程能力等级认证 ·GESP-Python五级 · 8.1 贪心思想

给定有 n 个任务,每个任务有截止时间和利润,每个任务耗时 1 个时间单位、必须在截止时间前完成,且每个时间槽最多做 1 个任务。为了在规定时间内获得最大利润,可以采用贪心策略,即按利润从高到低排序,尽量安排,则横线处应填写( )。

class Task:
    def __init__(self, deadline, profit):
        self.deadline = deadline
        self.profit = profit
def sort_by_profit(tasks):
    tasks.sort(key=lambda x: x.profit, reverse=True)
def max_profit(tasks):
    sort_by_profit(tasks)
    max_time = 0
    for task in tasks:
        if task.deadline > max_time:
            max_time = task.deadline
    slot = [False] * (max_time + 1)
    total_profit = 0
    for task in tasks:
        t = task.deadline
        while t >= 1:
            if not slot[t]:
                # 填空处完整代码
                slot[t] = True
                total_profit += task.profit
                break
            t -= 1
    return total_profit
A
slot [t] = True total_profit += task .profit break
B
slot [t] = True total_profit += task .profit
C
slot[t] = False total_profit += task .profit break
D
slot [t] = True total_profit -= task .profit
答案与解析
正确答案:A
标准任务调度贪心,排序后倒序查找空闲时间槽,对应选项A代码逻辑。
题目详情
15 单选题 适中 GESP编程能力等级认证 ·GESP-Python五级 · 3.1 高精度加法

下面代码实现了对两个数组表示的正整数的高精度加法(数组低位在前),则横线上应填写()。

def add(a, b):
    c = []
    carry = 0
    i = 0
    while i < len(a) or i < len(b):
        if i < len(a):
            carry += a[i]
        if i < len(b):
            carry += b[i]
        # 填空位置
        c.append(carry % 10)
        carry = carry // 10
        i += 1
    if carry:
        c.append(carry)
    return c
A
c .append(carry % 10)
B
c .append(carry % 10) carry = carry // 10
C
carry = carry // 10
D
c .append(carry // 10) carry = carry % 10
答案与解析
正确答案:B
高精度加法核心:逐位相加+进位更新,标准答案为B。 二、判断题(每题 2 分,共 20 分)
题目详情
16 单选题 适中 GESP编程能力等级认证 ·GESP-Python五级 · 4.1 单链表

下面的python代码实现给定单链表头结点 head 和一个整数 val ,删除链表中所有结点值等于 val 的节点,并返回新的头结点,则横线处填写()。

A

B

C

D

答案与解析
正确答案:C
这道题暂未补解析。
题目详情
17 单选题 适中 GESP编程能力等级认证 ·GESP-Python五级 · 4.1 单链表

下列python代码用Floyd判断一个单链表中是否存在环,链表的头节点为 head ,即用两个指针在链表上前进: slow 每次走 1 步, fast 每次走 2 步,若存在环, fast 终会追上 slow (相遇);若无环, fast 会先到达 nullptr。横线上应填写( )。

A

B

C

D

答案与解析
正确答案:A
这道题暂未补解析。
题目详情
18 单选题 适中 GESP编程能力等级认证 ·GESP-Python五级 · 综合练习

下列代码用于判断一个数是否为完全数(即等于它的真因子之和的数,如6=1+2+3),哪个选项是正确的实现?

A

if i != n / i:

B

if i != n // i:

C

if i = n // i:

D

if i == n // i:

答案与解析
正确答案:B
这道题暂未补解析。
题目详情
19 单选题 适中 GESP编程能力等级认证 ·GESP-Python五级 · 1.2 最大公约数与最小公倍数

以下代码计算两个数的最大公约数(GCD),横线上应填写( )。

A

b

B

a

C

temp

D

a+b

答案与解析
正确答案:B
这道题暂未补解析。
题目详情
20 单选题 适中 GESP编程能力等级认证 ·GESP-Python五级 · 综合练习

下面的代码实现埃拉托斯特尼筛法(埃氏筛),横线处应填入( )。

A

i

B

i+1

C

i*2

D

i*i

答案与解析
正确答案:D
这道题暂未补解析。
题目详情