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

GESP-Python五级 题库

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

根据下面Python代码的注释,横线处应填入(     )。

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

有关下面Python代码正确的是(     )。

A
checkNum() 函数定义错误
B
最后一行代码将 isEven 作为 checkNum() 参数将导致错误
C
最后一行代码执行后将输出 True
D
触发异常
答案与解析
正确答案:C
这道题暂未补解析。
题目详情
143 单选题 适中 GESP编程能力等级认证 ·GESP-Python五级 · 综合练习

有关下面Python代码正确的是(     )。

A
checkNum() 函数定义错误
B
倒数第 行代码将 isOdd 作为 checkNum() 参数将导致错误
C
最后一行代码将 Add 作为 checkNum() 参数将导致错误
D
倒数两行代码执行后都将没有错误
答案与解析
正确答案:D
这道题暂未补解析。
题目详情
144 单选题 适中 GESP编程能力等级认证 ·GESP-Python五级 · 综合练习

下面代码执行后的输出是(     )。

A
4#3#2#2#4
B
4#3#2#2#1#5
C
4#3#2#1#2#4
D
4#3#2#1#2#5
答案与解析
正确答案:D
这道题暂未补解析。
题目详情
145 单选题 适中 GESP编程能力等级认证 ·GESP-Python五级 · 1.1 素数与合数

下面Python代码中的 isPrimeA() 和 isPrimeB() 都用于判断参数 是否为素数,有关其时间复杂度的正确说法是(     )。

A
isPrimeA() 的最坏时间复杂度是0(N) , isPrimeB() 的最坏时间复杂度是0(logN) , isPrimeA() 优于isPrimeB()
B
isPrimeA() 的最坏时间复杂度是0(N) , isPrimeB() 的最坏时间复杂度是 0(N1/2), isPrimeB() 优于isPrimeA()
C
isPrimeA() 的最坏时间复杂度是 0(N1/2), isPrimeB() 的最坏时间复杂度是 0(N), isPrimeA() 优于isPrimeB()
D
isPrimeA() 的最坏时间复杂度是 0(logN), isPrimeB() 的最坏时间复杂度是 0(N), isPrimeB() 优于isPrimeB()
答案与解析
正确答案:B
这道题暂未补解析。
题目详情
146 单选题 适中 GESP编程能力等级认证 ·GESP-Python五级 · 7.1 归并排序

下面Python代码用于归并排序,其中 merge() 函数被调用次数为(     )。

A
0
B
1
C
6
D
7
答案与解析
正确答案:C
这道题暂未补解析。
题目详情
147 单选题 适中 GESP编程能力等级认证 ·GESP-Python五级 · 7.1 归并排序

在上题的归并排序算法中,代码

Left, Right = mergeSort(listData[:Middle]),

mergeSort(listData[Middle:]) 涉及到的算法有(     )。

A
搜索算法
B
分治算法
C
贪心算法
D
递推算法
答案与解析
正确答案:B
这道题暂未补解析。
题目详情
148 单选题 适中 GESP编程能力等级认证 ·GESP-Python五级 · 7.1 归并排序

归并排序算法的基本思想是(     )。

A
将数组分成两个子数组,分别排序后再合并。
B
随机选择一个元素作为枢轴,将数组划分为两个部分。
C
从数组的最后一个元素开始,依次与前一个元素比较并交换位置。
D
比较相邻的两个元素,如果顺序错误就交换位置。
答案与解析
正确答案:A
这道题暂未补解析。
题目详情
149 单选题 适中 GESP编程能力等级认证 ·GESP-Python五级 · 综合练习

有关下面Python代码的说法正确的是(     )。

A

上述代码构成单向链表

B

上述代码构成双向链表

C

上述代码构成循环链表

D

上述代码构成指针链表

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

题关于Python 实现的单链表、双链表和循环链表,下列说法正确的是()。

A
在Python 实现的单链表中,若已知任意结点对象的引用,则可以在O(1)时间内删除该结点。
B
Python 实现的循环链表中一定不存在值为None 的引用属性。
C
在Python 实现的循环双链表中,尾结点对象的next 属性值一定为None。
D
在Python 实现的带头结点的循环单链表中,判定链表是否为空只需判断头结点对象的next 属性是否引用头结点自身(即head.next is head)。
答案与解析
正确答案:D
这道题暂未补解析。
题目详情
151 单选题 适中 GESP编程能力等级认证 ·GESP-Python五级 · 未分类

双向循环链表中要在结点p 之前插入新结点s(均非空),以下操作正确的是()。

A
s.next=pp .prev=sq.next=ss .prev=q
B
s .prev=ps.next=p.next p.next.prev=sp.next=s
C
s.next=ps .prev=p .prev p.prev.next=sp .prev=s
D
s.next=ps .prev=nullptrp .prev=s
答案与解析
正确答案:C
这道题暂未补解析。
题目详情
152 单选题 适中 GESP编程能力等级认证 ·GESP-Python五级 · 未分类

下面函数删除单向链表中val == x 的节点,并且使用哑结点统一对头结点和中间节点的删除操作。横线处应填()。

A
cur = cur.next
B
cur.next = cur.next.next
C
cur.next = None
D
cur.next = nullptr
答案与解析
正确答案:B
使用哑结点后,当前指针cur从dummy开始,遍历链表。当cur.next存在时,判断其值是否等于x。若相等,则通过修改cur.next指向其下下个节点跳过目标节点,此时不应移动cur,因为下一个节点可能仍需删除。若不相等,则将cur向前移动一个节点。循环继续直到遍历结束。返回dummy.next作为新头节点。填空处位于删除操作后的分支,需决定删除后cur的移动行为。
题目详情
153 单选题 适中 GESP编程能力等级认证 ·GESP-Python五级 · 未分类

对如下代码实现的欧几里得算法(辗转相除法),调用gcd(48 , 18) 得到的调用序列为()。

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


A
gcd(48 ,18) -> gcd(18 ,12) -> gcd(12 ,6) -> gcd(6 ,0)
B
gcd(48 ,18) -> gcd(30 ,18) -> gcd(12 ,18)
C
gcd(48 ,18) -> gcd(18 ,30) -> gcd(30 ,6)
D
gcd(48 ,18) -> gcd(12 ,18) -> gcd(6 ,12)
答案与解析
正确答案:A
函数gcd接收两个参数a和b,当b不为0时,递归调用gcd(b, a % b);每次递归将原b作为新的a,原a对b取模的结果作为新的b。初始调用为gcd(48, 18),进入递归过程:首先计算48 % 18得12,生成下一层调用gcd(18, 12);接着计算18 % 12得6,生成gcd(12, 6);再计算12 % 6得0,生成gcd(6, 0);此时b为0,递归终止,返回当前a的值。整个调用链由连续取模操作驱动,每一步的第二个参数均为前一步的模运算结果,直到模为0停止。
题目详情
154 单选题 适中 GESP编程能力等级认证 ·GESP-Python五级 · 未分类

下面代码实现了欧拉(线性)筛,横线处应填写()。

def euler_sieve_for(n):
    if n < 2:
        return []
    is_composite = [False] * (n + 1)
    primes = []

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

        for j in range(len(primes)):  # 填空处
            p = primes[j]
            if i * p > n:
                break
            is_composite[i * p] = True
            if i % p == 0:
                break
    return primes


A
for j in range(len(primes+1)):
B
for j in range(len(primes)+1):
C
for j in range(len(primes)):
D
for j in range(len(primes)-1):
答案与解析
正确答案:C
函数目标是生成不超过n的质数列表。使用欧拉筛时,每个合数仅被其最小质因子筛去。外层循环遍历2到n的整数i,内层循环遍历已记录的质数列表primes中的元素p。当i能被p整除时,说明p是i的最小质因子,之后的合数将由更大的i处理,因此立即break。若i为质数,则加入primes。is_composite数组用于标记合数,避免重复筛选。内层循环需遍历当前全部已得质数,故循环范围应为primes的有效索引区间。j作为索引变量,应覆盖0到len(primes)-1的所有值,确保访问每个已知质数p = primes[j]。循环上限为len(primes),下限为0,步长为1,因此range参数应为len(primes)。
题目详情
155 单选题 适中 GESP编程能力等级认证 ·GESP-Python五级 · 未分类

埃氏筛中将内层循环从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 <=n; j +=i
        for j in range(i * i, n + 1, i):
            is_composite[j] = True

    return primes


A
因为2*i 一定不是合数
B
i*i 一定是质数
C
小于i*i 的i 的倍数已被更小质因子筛过
D
这样可以把时间复杂度降为O(n)
答案与解析
正确答案:C
埃氏筛法标记合数时,对于当前质数i,其倍数中需被筛去的合数从i*i开始。因小于i*i的i的倍数可表示为k*i(k < i),其中k必有小于i的质因子,这些倍数已在处理更小质数时被标记。内层循环跳过2*i、3*i等直至i*i,是因它们已被先前步骤覆盖。时间复杂度仍为O(n log log n),未降至O(n)。i*i不一定是质数,且2*i在i>1时为合数。
题目详情
156 单选题 适中 GESP编程能力等级认证 ·GESP-Python五级 · 未分类

下面程序的运行结果为()。

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)


A
2
B
3
C
4
D
5
答案与解析
正确答案:B
函数 check 接收四个参数:n 表示数组长度,a 为升序排列的数值数组,k 为目标数量,dist 为最小距离。遍历数组 a,统计满足相邻元素差值不小于 dist 的元素个数 cnt,返回 cnt 是否大于等于 k。函数 solve 对数组 a 排序后,使用二分查找确定最大化的最小距离。左边界 l 初始化为 0,右边界 r 初始化为数组最大值与最小值之差。在二分过程中,计算中点 mid,通过 check 函数判断是否存在至少 k 个元素,其相邻元素间距离不小于 mid。若满足条件,则尝试增大距离;否则减小距离。循环持续至区间收敛。
题目详情
157 单选题 适中 GESP编程能力等级认证 ·GESP-Python五级 · 未分类

在升序数组中查找第一个大于等于x 的位置,下面循环中横线应填()。

def lowerBound(a, x):
    l = 0
    r = len(a)
    while l < r:
        mid = l + (r - l) // 2
        if a[mid] >= 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)}")


A
r = mid
B
r = mid - 1
C
l = mid
D
l = mid + 1
答案与解析
正确答案:A
使用二分查找在升序数组中定位第一个大于等于x的位置。初始化左指针l为0,右指针r为数组长度。循环条件为l < r,取中点mid = (l + r) // 2。若a[mid] >= x,则mid可能是解,将r更新为mid以保留该位置;否则a[mid] < x,说明mid及左侧均不可能满足条件,将l更新为mid + 1以排除该区域。循环结束时l即为首个满足条件的位置。填空处位于a[mid] >= x分支内,需维护右边界向左收缩的逻辑。
题目详情
158 单选题 适中 GESP编程能力等级认证 ·GESP-Python五级 · 未分类

关于递归函数调用,下列说法错误的是()。

A
递归调用层次过深时,可能会耗尽栈空间导致栈溢出
B
尾递归函数可以通过编译器优化来避免栈溢出
C
所有递归函数都可以通过循环结构来改写,从而避免栈溢出
D
栈溢出发生时,程序会抛出异常并可以继续执行后续代码
答案与解析
正确答案:D
递归函数调用时,每次调用都会在调用栈中创建新的栈帧,保存局部变量和返回地址。调用层次过深会导致栈空间耗尽,引发栈溢出。尾递归在特定条件下可被编译器优化为迭代形式,复用栈帧,避免栈空间持续增长。理论上,所有递归逻辑均可转换为循环结构,通过显式维护状态数据实现等价功能。栈溢出属于运行时严重错误,触发后程序控制流中断,无法保证后续代码的正常执行路径。
题目详情
159 单选题 适中 GESP编程能力等级认证 ·GESP-Python五级 · 未分类

给定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()


A
l = mid + 1 和 r = mid - 1
B
r = mid - 1 和l = mid + 1
C
l = mid + 1 和 r = mid
D
l = mid - 1 和 r = mid + 1
答案与解析
正确答案:A
使用二分查找确定最大可能长度。左边界为1,右边界为最长木头的长度。每次取中点作为候选长度,通过check函数验证是否能切出至少m段。若可以,则尝试更大的长度,更新左边界;否则尝试更小的长度,更新右边界。循环直至区间收敛,得到最大可行解。
题目详情
160 单选题 适中 GESP编程能力等级认证 ·GESP-Python五级 · 未分类

下面代码用分治求“最大连续子段和”,其时间复杂度为()。

import sys
def solve(a , l , r):
    if l == r:
        return a [l]
    mid = l + (r - l) // 2
    left = solve(a , l , mid)
    right = solve(a , mid + 1 , r)
    sum_val = 0
    lmax = -sys .maxsize - 1
    for i in range(mid , l - 1 , -1):
        sum_val += a [i]
        lmax = max (lmax , sum_val)
    sum_val = 0
    rmax = -sys .maxsize - 1
    for i in range(mid + 1 , r + 1):
        sum_val += a [i]
        rmax = max (rmax , sum_val)
    return max(left , right , lmax + rmax)

if __name__ == "__main__":
    a1 = [-2 , 1 , -3 , 4 , -1 , 2 , 1 , -5 , 4]
    print(solve(a1 , 0 , len(a1)-1))
    a2 = [-5 , -3 , -1 , -4]
    print(solve(a2 , 0 , len(a2)-1))
    a3 = [10]
    print(solve(a3 , 0 , 0))
A
O(n2)
B
O(nlogn)
C
O(logn)
D
O(n)
答案与解析
正确答案:B
这道题暂未补解析。
题目详情