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

GESP-Python五级 题库

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

下列程序中,使用了二分查找算法,横线处应该填写的是()。

def search(arr, x):
	low = 0
	high = len(arr) - 1
	while low <= high:
		__________________
		if arr[mid] == x:
			return mid
		elif arr[mid] > x:
			high = mid - 1
		else:
			low = mid + 1
	return -1


A
mid = (low - high) // 2
B
mid = (low + high) // 2
C
mid = (low + high) / 2
D
mid = (low - high) / 2
答案与解析
正确答案:B

首先排除C和D,应该是要整除才对,mid应该要取low和high的中间位置,所以应该是(low+high)//2。

题目详情
82 单选题 适中 GESP编程能力等级认证 ·GESP-Python五级 · 综合练习

正整数1024的所有约数的和为多少( )。

A
2050
B
2059
C
2047
D
2044
答案与解析
正确答案:C

1024=210,所以约数和为(20+21+22+23……+210)=211−1。

题目详情
83 单选题 适中 GESP编程能力等级认证 ·GESP-Python五级 · 1.3 同余与模运算

下面程序是对n!进行唯一分解,横线处应该填入的是( )。

def unique_fac(n):
	print(n, '=', end='')
	for i in range(2, n + 1):
		_____________________________
			print(' {}*'.format(i), end='')
			n //= i
		if n % i == 0 and i == n:
			print(' {}'.format(i), end='')
			break
	
unique_fac(math.factorial(5))


A
while n % i != 0 and i != n:
B
while n % i == 0 and i == n:
C
while n % i == 0 and i != n:
D
while n % i != 0 and i == n:
答案与解析
正确答案:C

11行用math.factorial函数计算阶乘,阶乘传参为n,枚举2~n的所有数字,对于每个数字进行拆分,第4行填写:如果当前的n是i的倍数就记录答案,然后n//i,因为n可能包含多个i,所以用while循环。

题目详情
84 单选题 适中 GESP编程能力等级认证 ·GESP-Python五级 · 综合练习

假设有⼀些物品,每个物品都有⾃⼰的重量,我们需要将这些物品装⼊箱⼦中,每个箱⼦也有⾃⼰的重量限制。贪⼼算法每次都选择重量最轻的物品放⼊当前最轻的箱⼦中,如果箱⼦可以装下,就放⼊;如果箱⼦不能装下,就尝试下⼀个箱⼦,直到找到可以放⼊的箱⼦。下列贪⼼算法程序中,横线处应该填⼊的是( )。

A
if not taken[i] and box[0] >= items[i]:
B
if not taken[0] and box[0] >= items[i]:
C
if not taken[i] and box[i] >= items[0]:
D
if not taken[0] and box[0] >= items[i]:
答案与解析
正确答案:A

boxes按照箱子的重量限制排序,items也从小到大排序,定义标记数组taken,枚举每个物品,然后标记已经访问过,然后枚举所有的箱子,如果当前箱子的剩余容量能放开当前物品,则放入当前箱子中,并更新当前箱子的容量,且boxes[j][1]表述的可能是编号,所以不用动。

题目详情
85 单选题 适中 GESP编程能力等级认证 ·GESP-Python五级 · 7.1 归并排序

下列归并算法程序中,横线处应该填入的是( )。

def merge_sort(arr):
	if len(arr) <= 1:
		return arr
	mid = len(arr) // 2
	left = arr[:mid]
	right = arr[mid:]
	merge_sort(left)
	merge_sort(right)
	return merge(left, right)

def merge(left, right):
	result = []
	i, j = 0, 0
	———————————————————————————————
		if left[i] < right[j]:
			result.append(left[i])
			i += 1
		else:
			result.append(right[j])
			j += 1
	result += left[i:]
	result += right[j:]
	return result


A
while i > len(left) and j < len(right):
B
while i < len(left) and j > len(right):
C
while i > len(left) and j > len(right):
D
while i < len(left) and j < len(right):
答案与解析
正确答案:D

merge_sort函数是递归分的过程,merge函数是合并两个有序序列的过程,对于left和right这两个数组合并,所以应该是i<left的长度,j<right的长度。

题目详情
86 单选题 适中 GESP编程能力等级认证 ·GESP-Python五级 · 7.2 快速排序

下列快速排序算法中,横线处应该填入的是( )。

def quick(arr):
	if len(arr) <= 1:
		return arr
		
	____________________
	left = [x for x in arr if x < p]
	middle = [x for x in arr if x == p]
	right = [x for x in arr if x > p]
	return quick(left) + middle + quick(right)


A
p = arr[len() // 2]
B
p = arr[len(arr)+1 // 2]
C
p = arr[len(arr)-1 // 2]
D
p = arr[len(arr) // 2]
答案与解析
正确答案:D

p是基准值,接下来我们要把比p小的值放到p的左边,比p大的放到p的右边,p的取值应该是arr数组中的随意一个值即可,ABC选项都有越界的风险,所以D最合适。

题目详情
87 单选题 适中 GESP编程能力等级认证 ·GESP-Python五级 · 5.2 二分答案

下列二分枚举算法中,{ }处应该填入的程序是({}不算做程序的一部分)( )。

def binary_search(arr, x):
	low = 0
	high = len(arr) - 1
	while low <= high:
		{
		 }
	return -1


A
mid = (low + high) // 2
if arr[mid] == x:
	return mid
elif arr[mid+1] > x:
	high = mid - 1
else:
	low = mid + 1
B
mid = (low + high) // 2
if arr[mid] != x:
	return mid
elif arr[mid+1] > x:
	high = mid - 1
else:
	low = mid + 1
C
mid = (low + high) // 2
if arr[mid] == x:
	return mid
elif arr[mid] > x:
	high = mid - 1
else:
	low = mid + 1
D
mid = (low + high) // 2
if arr[mid] != x:
	return mid
elif arr[mid] > x:
	high = mid - 1
else:
	low = mid + 1
答案与解析
正确答案:C

对于有序序列arr,从中找x的位置,判断arr[mid+1]是不正确的,所以排序AB,然后如果arr[mid]==x,应该是找到了x的位置,直接return mid即可。

题目详情
88 单选题 适中 GESP编程能力等级认证 ·GESP-Python五级 · 综合练习

下面代码是寻找水仙花数的程序,横线处应该填写的代码是( )。【是指一个n位数(n≥3),其每位数字的n次幂之和等于它本身】

def is_narcissistic_num(num):
	str_num = str(num)
	num_digits = len(str_num)
	————————————————————————————
	return num == sum_of_powers
	
for i in range(100, 10000):
	if is_narcissistic_num(i):
		print(i, "是水仙花数")


A
sum_of_powers = sum(int(digit) ** num_digits for digit in num)
B
sum_of_powers = sum(int(digit) ** num for digit in str_num)
C
sum_of_powers = sum(int(num) ** num_digits for digit in str_num)
D
sum_of_powers = sum(int(digit) ** num_digits for digit in str_num)
答案与解析
正确答案:D

str_num是把num转成string类型的,也就是要拆位,num_digits是位数。

应该是要枚举所有位数字str_num,然后计算他的(num_digits)次方 。

题目详情
89 单选题 适中 GESP编程能力等级认证 ·GESP-Python五级 · 综合练习

对于正整数n,欧拉函数f(n),表示小于或等于n的正整数中与n互质的数的数目,例如f(8)=4。f(100)=( )。

A
50
B
55
C
45
D
40
答案与解析
正确答案:D

找互质的数,不如找不互质的数字,也就是gcd不等于1的情况,也就是把100质因数分解2252,也就是说2的倍数和5的倍数都是和100不互质的,2的倍数有50个,5的倍数有20个,2和5的公倍数被计算了两次,所以再考虑10的倍数,一共10个,剩下40个与100互质的数字。

题目详情
90 单选题 适中 GESP编程能力等级认证 ·GESP-Python五级 · 综合练习

下列程序输出的是( )。

def reverse(string):
	if len(string) == 0:
		return
	temp = string[0]
	reverse(string[1:])
	print(temp, end='')
string = "chen a dai"
reverse(string)


A
chen a dai
B
dai a chen
C
iad a nehc
D
chenadai
答案与解析
正确答案:C

temp取第一个字符,然后继续递归,所以最后输出的结果是倒序输出。

题目详情
91 单选题 适中 GESP编程能力等级认证 ·GESP-Python五级 · 综合练习

在Python中,print((c for c in “GESP”))的输出是( )。

A
(‘G’, ‘E’, ‘S’, ‘P’)
B
[‘G’, ‘E’, ‘S’, ‘P’]
C
{‘G’, ‘E’, ‘S’, ‘P’}
D

以上选项均不正确

答案与解析
正确答案:D

在Python中,表达式 print((c for c in “GESP”)) 的输出是一个生成器对象,而不是元组、列表或集合。生成器对象在被打印时会输出其表示形式,即 <generator object>,而不是生成器中的元素。所以,正确的答案是:以上选项均不正确,因为生成器对象本身不会输出其中的元素,而是输出生成器对象的描述信息。

题目详情
92 单选题 适中 GESP编程能力等级认证 ·GESP-Python五级 · 7.2 快速排序

下面有关快速排序的说法,错误的是( )。

A
快速排序算法通常采用递归实现。
B
快速排序算法是一种稳定排序算法。
C
如果被排序数组或者list已排序或逆序,其时间复杂度是 O(N^2)
D
快速排序是一种原地(in-place)排序算法。
答案与解析
正确答案:B

正确。快速排序通常通过递归将数组分割成子数组来实现。

错误。快速排序是一种不稳定排序算法。在排序过程中,相同元素的相对位置可能会改变。

正确。最坏情况下,如果数组已经有序或者逆序,快速排序的时间复杂度可能达到O(N²),尤其是当选择的基准元素不合适时。

正确。快速排序通过交换数组中的元素来排序,不需要额外的空间,因此是一种原地排序算法。

因此,选项B错误,快速排序算法不是稳定排序算法。

题目详情
93 单选题 适中 GESP编程能力等级认证 ·GESP-Python五级 · 综合练习

内排序有不同的类别,从排序算法的实现思路上考虑,下面哪种排序算法和插入排序是同一类?( )

A
希尔排序
B
快速排序
C
堆排序
D
冒泡排序
答案与解析
正确答案:A

从排序算法的实现思路上来看,插入排序与希尔排序属于同一类别,因为它们都是通过逐步构建有序序列来完成排序的。具体解释如下:插入排序:逐步将未排序的元素插入到已排序的部分,直到整个序列有序。希尔排序:是插入排序的改进版本,通过将序列分成若干个子序列进行插入排序,逐步缩小子序列的间隔,最终完成排序。

因此,正确答案是:希尔排序

题目详情
94 单选题 适中 GESP编程能力等级认证 ·GESP-Python五级 · 综合练习

下面Python代码用于求斐波那契数列,该数列第1、2项为1,以后各项均是前两项之和。函数Fibo()属于()。

def Fibo(N):
	if N == 1 or N == 2:
		return 1
		
	fiboList = [1, 1]
	for i in range(2, N):
		fiboList.append(fiboList[i - 1] + fiboList[i - 2])
		
	return fiboList[N-1]
A
枚举算法
B
贪心算法
C
迭代算法
D
递归算法
答案与解析
正确答案:C

递归算法:递归算法通常是指函数调用自身来解决问题。虽然斐波那契数列可以使用递归实现,但是该代码中并没有直接使用递归调用,而是使用了迭代循环来计算每一项的值。

迭代算法:迭代算法是通过循环重复计算的方法来解决问题。该函数通过for 循环迭代计算斐波那契数列的各项,因此属于迭代算法。

枚举算法:枚举算法通常是列举所有可能的情况来解决问题,这个概念与斐波那契数列的求解方法不相关。

贪心算法:贪心算法是通过每一步选择最优解来达到整体最优解的方法。斐波那契数列的计算不涉及贪心选择过程。

综上所述,根据代码实现方式,函数 Fibo(N) 属于:迭代算法

题目详情
95 单选题 适中 GESP编程能力等级认证 ·GESP-Python五级 · 综合练习

下面Python代码用于将输入金额换成最少币种组合方案,其实现算法是( )。

def findCoins(coins, Money):
	coins_used = []
	for coin in coins:
		while Money >= coin:
			coins_used.append(coin)
			Money -= coin
	return coins_used
	
coins = [100, 50, 20, 10, 5, 2, 1] #货币种类,单位相同
M = int(input()) #输入换算的金额
coins_needed = find_coins(coins, M)

result = [(c,coins_needed.count(c)) for c in coins]
result = [x for x in result if x[1] > 0]
A
枚举算法
B
贪心算法
C
迭代算法
D
递归算法
答案与解析
正确答案:B

枚举算法:枚举算法通常是通过穷举所有可能情况来解决问题。该代码并没有枚举所有可能的解决方案,而是通过一种确定性的方法找出最少币种组合方案。

贪心算法:贪心算法是通过每一步选择当前状态下最优的解决方案来达到整体最优的目标。在该代码中,通过每次选择当前金额能够覆盖的最大面额货币来实现找零,属于贪心算法的思想。

迭代算法:迭代算法是通过重复迭代来逐步逼近问题的解。该代码使用了循环来逐步减少剩余金额并记录所使用的货币,因此也可以称为迭代算法。

递归算法:递归算法是通过函数调用自身来解决问题。虽然找零问题可以使用递归解决,但是该代码并没有使用递归调用的方式。

根据代码实现方式和思想,最符合描述的是:贪心算法

题目详情
96 单选题 适中 GESP编程能力等级认证 ·GESP-Python五级 · 综合练习

有关下面Python的代码,错误的是( )。

def count_if(iterData,*,key=None):
	if key == None:
		return len(iterData)
		
	Count = 0
	for i in iterData:
		Count += bool(key(i))
	return Count
A
执行 print(count_if(range(100))) 将输出 100
B
执行 print(count_if(range(-10,10), key = abs)) 将输出 19
C
执行 print(count_if(range(-100,10),key = lambda x:x > 5)) 将输出 4
D
代码 Count += bool(key(i)) 存在错误
答案与解析
正确答案:D

这个函数count_if 的作用是计算满足条件的元素个数。它接受一个可迭代对象iterData 和一个关键字参数key,如果key 为None,则返回iterData 的长度;否则,遍历iterData 中的每个元素,通过key 函数判断是否满足条件(即bool(key(i)) 返回True),然后累加满足条件的个数并返回。

现在来逐个分析选项:

执行print(count_if(range(100))) 将输出100

正确。如果没有提供key 参数,函数会返回 iterData 的长度,即 range(100) 包含 100 个元素,所以输出是 100。

执行print(count_if(range(-10,10), key = abs)) 将输出19

正确。这里使用了key = abs,表示计算绝对值,所以在范围-10 到9 内(不包括10),共有19 个元素的绝对值大于0,因此输出是19。

执行print(count_if(range(-100,10), key = lambda x: x > 5)) 将输出4

正确。这里使用了一个lambda函数作为key,判断元素是否大于5。在范围-100 到9 内,有-99, -98, -97, …, 6 共计4 个元素满足条件大于5。

代码Count += bool(key(i)) 存在错误

错误。这部分代码的逻辑是正确的,它使用bool(key(i)) 来判断元素是否满足条件,并将满足条件的结果转换为True 或False,然后累加到Count 中。

因此,根据以上分析,错误的选项是:代码Count += bool(key(i)) 存在错误

题目详情
97 单选题 适中 GESP编程能力等级认证 ·GESP-Python五级 · 综合练习

在下面的Python代码中,最后一行用于输出小于0的list,横线处不能填入的代码是( )。

def LT(a, b):
	return a < b
	
lstData = list(range(-100,100))
print(___________________________)
A
[x for x in lstData if x < 0 ]
B
list(filter(lambda x: x < 0, lstData))
C
list(filter(LT(x,0), lstData))
D
[x for x in lstData if LT(x, 0)]
答案与解析
正确答案:C

在给定的代码和选项中,我们需要选择能够正确输出小于0的列表的选项。

首先,我们看一下每个选项的含义和正确性:

[x for x in lstData if x < 0]

正确。这是列表推导式的语法,用于筛选出 lstData 中小于0的元素并生成一个新的列表。

list(filter(lambda x: x < 0, lstData))

正确。使用 filter 函数结合 lambda 表达式,筛选出 lstData 中小于0的元素并生成一个新的列表。

list(filter(LT(x, 0), lstData))

错误。在这里,LT(x, 0) 并不是一个合法的表达式。filter 函数的第一个参数需要是一个函数或者 None,而 LT(x, 0) 表达式没有定义 x,因此这行代码会抛出错误。

[x for x in lstData if LT(x, 0)]

正确。这也是列表推导式的语法,筛选出 lstData 中小于0的元素并生成一个新的列表。LT(x, 0) 是一个函数调用,用于判断 x 是否小于0。

综上所述,正确答案是:

list(filter(LT(x, 0), lstData))

因为这行代码会导致语法错误,无法正确输出小于0的列表。

题目详情
98 单选题 适中 GESP编程能力等级认证 ·GESP-Python五级 · 综合练习

汉字的unicode编码界于0x4E00和0x9FA5之间。下面Python的代码用于读取红楼们和水浒传文本。如果要能完整阅读这两本小说,求出需要认识的汉字集合,横线处应填入代码是( )。

shzFile = open("水浒传.txt", "r", encoding = "utf-8")
hlmFile = open("红楼梦.txt", "r", encoding = "utf-8")
sSet = set(shzFile.read())
hSet = set(hlmFile.read())
shzFile.close()
hlmFile.close()

print(________________________________)
A
{x for x in (sSet + hSet) if 0x4E00 <= ord(x) <= 0x9FA5 }
B
{x for x in (sSet | hSet) if 0x4E00 <= x <= 0x9FA5 }
C
{x for x in (sSet + hSet) if 0x4E00 <= x <= 0x9FA5 }
D
{x for x in (sSet | hSet) if 0x4E00 <= ord(x) <= 0x9FA5 }
答案与解析
正确答案:D

{x for x in (sSet + hSet) if 0x4E00 <= ord(x) <= 0x9FA5}错误。sSet + hSet 是集合的合并操作,不是按字符拼接,所以这种语法是不正确的。

{x for x in (sSet | hSet) if 0x4E00 <= x <= 0x9FA5}错误。sSet | hSet 是集合的并集操作,它不会按照字符处理,因此无法进行Unicode编码的比较。

{x for x in (sSet + hSet) if 0x4E00 <= x <= 0x9FA5}错误。同样的问题,sSet + hSet 不是合适的操作。

{x for x in (sSet | hSet) if 0x4E00 <= ord(x) <= 0x9FA5}正确。sSet | hSet 是集合的并集操作,生成了包含两本书中所有字符的集合。然后,通过 ord(x) 获取字符 x 的Unicode编码,检查它是否在 0x4E00 到 0x9FA5 的范围内。

因此,正确的答案是:{x for x in (sSet | hSet) if 0x4E00 <= ord(x) <= 0x9FA5}这段代码将打印出两本小说中所有汉字的集合,使得我们能够了解需要认识的汉字范围。

题目详情
99 单选题 适中 GESP编程能力等级认证 ·GESP-Python五级 · 综合练习

求回文子字符串,如:在ABCDDCBAXz中,DD、CDDC、BCDDCB、ABCDDCBA均为回文子字符串。下面Python代码是其实现,横线处应填入的代码是( )。

srcStr = input()

symList = [] #保存回文子字符串
for i in range(len(srcStr)):
	for j in range(i + 2, len(srcStr) + 1):
		subStr = ___________
		if subStr == _____________:
			symList.append(subStr)

for i in sorted(symList, key = lambda x: len(x)):
	print(i)
A
srcStr[i:j] , subStr[::-1]
B
srcStr[i:j] , subStr[j:i:-1]
C
srcStr[i+2:j] , subStr[j-1:i:-1]
D
srcStr[i:j+2] , subStr[j-1:i-1:-1]
答案与解析
正确答案:A

srcStr[i:j], subStr[::-1]这里 srcStr[i:j] 获取子字符串,subStr[::-1] 是将 subStr 反转。这是正确的填充。

题目详情
100 单选题 适中 GESP编程能力等级认证 ·GESP-Python五级 · 2.1 多项式复杂度

上面代码的时间复杂度是( )。

A
O(logN)
B
O(NlogN)
C
O(N)
D
O(N^2)
答案与解析
正确答案:A

这段代码的主要操作是:

1、两层嵌套循环:外层循环遍历字符串的每个字符作为子字符串的起点,内层循环则从这个起点开始,尝试所有可能的子字符串长度(直到字符串末尾)。

外层循环:for i in range(len(srcStr)),执行次数为n(n 是字符串长度)。

内层循环:for j in range(i + 2, len(srcStr) + 1),对于外层循环的每次迭代,内层循环的次数大致为n - i - 1(因为从i+2 开始到字符串末尾)。

2、内层循环的累加:如果我们把内层循环的每次迭代都加起来,我们会发现这是一个等差数列的和,大致为n + (n-1) + (n-2) + … + 2 + 1,这个和是n(n+1)/2 - 1,但在分析时间复杂度时,我们更关心的是它的阶(order),即O(n^2)。

3、其他操作:虽然代码中还有回文检查和排序操作,但这些操作的时间复杂度相对于内层循环的O(n^2) 来说是可以忽略的(特别是当考虑到平均情况和最坏情况时的实际影响)。

因此,我们可以简单地说,这段代码的时间复杂度是O(n^2),其中n 是输入字符串的长度。这意味着随着输入字符串长度的增加,算法的执行时间将呈平方级增长。

题目详情