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

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

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

一、单选题

1. 单选题

在升序数组 nums 中寻找目标值 target,下列程序可以填入的是( )

class Search(object):
	def search(self, nums, target):
		left, right = 0, len(nums) - 1
		while left <= right:
			________________________________________
			if nums[mid] == target:
				return mid
			elif nums[mid] > target:
				right = mid - 1
			else:
				left = mid + 1
		return -1


  • A mid = (right + left) // 2 + left
  • B mid = (right - left) // 2 + left
  • C mid = (right - left) // 2 -right
  • D mid = (right + left) // 2 - left
查看答案与解析
答案:B
解析:

nums数组是升序的,我们从中找target,采用二分查找,所以这个空应该是:mid取left位置和right位置的中间位置,所以为mid=(right-left)//2+left , 还需要注意整除。

2. 单选题

500个病毒样本中,已知有一个是病毒检测呈阳性,用试纸测试阳性病毒以后,试纸在3天以后会变色,用试纸测试时间不计,三天以后要出结果,请问最少用多少个试纸能够找出哪一个病毒样本有毒()

  • A 499
  • B 250
  • C 9
  • D 125
查看答案与解析
答案:C
解析:

可以考虑分治,把500个样本分成两组,每组250个,进行测试,这样的话可以排除250个阴性样本,然后再把剩下的250个样本分成两组,继续进行上述操作,这样的话可以每次排除掉当前一般样本,所以9次即可得到答案。

3. 单选题

一名收银员,给顾客找零,找零的目标是给出确定金额的同时,使用尽可能少的硬币。有不同面额的硬币:1分,5分,10分,25分.如果需要给顾客准确的零钱77分,同时使用最少的硬币下列程序中横线应该填写( )。

def coin_change(amount, coins):
	result = []
	for coin in sorted(coins, reverse=True):
		while amount >= coin:
			___________________
			result.append(coin)
	return result
	
coins = [1, 5, 10, 25]
amount = 63


  • A amount -= coin
  • B amount <= coin
  • C amount >= coin
  • D amount += coin
查看答案与解析
答案:A
解析:

因为要用尽可能少的硬币,对于coins数组,从大到小排序之后取用,如果当前给顾客的领钱,可以用coin,那么就amount-=coin,否则就看下一个coin。

4. 单选题

下列程序是素数筛的程序,横线处应该填上( )。

def sieve(n):
	if n < 2:
		return []
	prime = [True] * (n+1)
	prime[0] = prime[1] = False
	for i in range(2, int(math.sqrt(n)) + 1):
		if prime[i]:
			_______________________
				prime[j] = False
	return [p for p in range(2, n+1) if prime[p]]
for prime in sieve_of_eratosthenes(100):
	print(prime)


  • A for j in range(i, n+1, i):
  • B for j in range(ii, 1, n):
  • C for j in range(ii, n+1, i):
  • D for j in range(i, n, i):
查看答案与解析
答案:C
解析:

第7行判断如果当前i是质数,则i的倍数都不是质数,所以这个地方是要枚举i的所有的倍数,注意右边界。

5. 单选题

下面程序是埃氏筛的一个实现,横线处应该填写( )。

n = 10**8
s = [0]*(n+1)
k=0
for i in range(2,n+1):
	if s[i]==0:
		k+=1
		___________________________
			s[j]=1


  • A for i in range(i*i,n+1,i):
  • B for j in range(i*i,n,j):
  • C for j in range(i*i,n+1,i):
  • D for j in range(j*j,n+1,i):
查看答案与解析
答案:C
解析:

第5行判断如果当前i是质数;则i的倍数都不是质数,所以这个地方是要枚举i的所有的倍数,注意右边界。

6. 单选题

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

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。

7. 单选题

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

  • A 2050
  • B 2059
  • C 2047
  • D 2044
查看答案与解析
答案:C
解析:

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

8. 单选题

下面程序是对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循环。

9. 单选题

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

  • 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]表述的可能是编号,所以不用动。

10. 单选题

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

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的长度。

11. 单选题

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

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最合适。

12. 单选题

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

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即可。

13. 单选题

下面代码是寻找水仙花数的程序,横线处应该填写的代码是( )。【是指一个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)次方 。

14. 单选题

对于正整数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互质的数字。

15. 单选题

下列程序输出的是( )。

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取第一个字符,然后继续递归,所以最后输出的结果是倒序输出。

二、判断题

16. 判断题

(-1) mod 127和126 mod 127 的结果是一样的

  • A对
  • B错
查看答案与解析
答案:对
解析:

取模和取余是不一样的,取模正数之后应该是一个非负数,应该是126。

17. 判断题

一个数的反码,实际上是这个数对于一个模的同余数

  • A对
  • B错
查看答案与解析
答案:对
解析:

1的反码表示是1111 1110。在不看符号位的情况下,111 1110=126。

-1在模127的情况下,和126同余,也就是(-1) ≡ 126 (mod 127)

而我们考虑2-1,其实是等价于2+126 (mod 127)

所以一个数的反码,实际上是这个数对于一个模的同余数

18. 判断题

1997和615用欧几里得算法计算最大公约数的过程如下:

1997/615=3(余152)
615/152=4(余7)
152/7=21(余5)
7/5=1(余2)
5/2=2(余1)
2/1=2(余0)
得出最大公约是是1


  • A对
  • B错
查看答案与解析
答案:对
解析:

欧几里得算法也是辗转相除法,两个整数的最大公约数等于其中较小的数和两数相除余数的最大公约数

19. 判断题

欧几里得算法适用于实数

  • A对
  • B错
查看答案与解析
答案:错
解析:

欧几里得算法也是辗转相除法,一直在用取余操作,而实数没法取余。

20. 判断题

每个大于1的整数可以唯一地写成质数的乘积的形式

  • A对
  • B错
查看答案与解析
答案:对
解析:

唯一分解定理概念:任意大于等于2的整数,都可以唯一分解位若干个质数的幂次方的乘积的形式。

21. 判断题

贪婪算法的复杂度通常是线性的,即O(n),其中n是输入的大小

  • A对
  • B错
查看答案与解析
答案:对
解析:

宏观考虑的话,在不考虑其他如排序这样的运算的情况下,贪心算法通常是线性的,就是一次考虑每一个物品的最优情况即可。

22. 判断题

归并排序的时间复杂度为O(n log n)

  • A对
  • B错
查看答案与解析
答案:对
解析:

归并排序是基于分治思想的,时间复杂度为O(nlogn)。

23. 判断题

根据同余计算,可以推导出(a∗b)%m=(a%m∗b%m)%m

  • A对
  • B错
查看答案与解析
答案:对
解析:

乘法同余定理概念式。

24. 判断题

二分查找算法的复杂度通常表示为O(log n),其中n是数组的长度

  • A对
  • B错
查看答案与解析
答案:对
解析:

二分查找的时间复杂度为O(logn)。

25. 判断题

def(十六进制) = 103231(五进制)

  • A对
  • B错
查看答案与解析
答案:错
解析:

def(16进制)=3567(10进制)= 103232(5进制)

三、简答题

26. 简答题

小杨的武器

时间限制:1.0 s

内存限制:512.0 MB

题面描述

小杨有n种不同的武器,他对第i种武器的初始熟练度为c。

小杨会依次参加m场战斗,每场战斗小杨只能且必须选择一种武器使用,假设小杨使用了第i种武器参加了第j场战斗,战斗前该武器的熟练度为ci′,则战斗后小杨对该武器的熟练度会变为ci′+a。需要注意的是,aj可能是正数,0或负数,这意味着小杨参加战斗后对武器的熟练度可能会提高,也可能会不变,还有可能降低。

小杨想请你编写程序帮他计算出如何选择武器才能使得m场战斗后,自己对n种武器的熟练度的最大值尽可能大。

输入格式

第一行包含两个正整数n,m,含义如题面所示。

第二行包含n个正整数c1,c2,...,cn,代表小杨对武器的初始熟练度。

第三行包含m个正整数a1,a2,...,am,代表每场战斗后武器熟练度的变化值。

输出格式

输出一个整数,代表m场战斗后小杨对n种武器的熟练度的最大值最大是多少。


输入样例

2 2
9 9
1 -1

输出样例

10

一种最优的选择方案为,第一场战斗小杨选择第一种武器,第二场战斗小杨选择第二种武器。

对于全部数据,保证有1≤n,m≤105,−104≤ci,ai≤104。

查看答案与解析
答案:<pre class="brush:python;toolbar:false">N = 100010 a = [0] * N c = [0] * N n, m = map(int, input().split()) mx = -10000 s = input().split() for i in range(1, n + 1): c[i] = int(s[i-1]) mx = max(mx, c[i]) s = input().split() for i in range(1, m + 1): a[i] = int(s[i-1]) for i in range(1, m + 1): if n == 1 or a[i] &gt; 0: mx += a[i] print(mx)</pre>
解析:

我们想让武器熟练度最大值尽可能大,所以我们可以贪心考虑把原本的最大值,加上所有的正的熟练度,这样他就会变得最大。

流程:读入n和m,然后读入一个字符串,这个字符串就是c的信息,我们转成int类型,并找出其中的最大值mx,然后再读入一个字符串,这个字符串就是a的信息,我们把这个字符串转成int类型,判断a数组,如果当前熟练度增加值为正数,则累加到最大值mx上。

特别的,如果n==1,也就是只有一个武器,所以每次只能用这一个,这种情况下即使是负数,也要累加上。

27. 简答题

挑战怪物

时间限制:1.0 s

内存限制:512.0 MB

题面描述

小杨正在和一个怪物战斗,怪物的血量为h,只有当怪物的血量恰好为 0 时小杨才能够成功击败怪物。

小杨有两种攻击怪物的方式:

·物理攻击。假设当前为小杨第i次使用物理攻击,则会对怪物造成2i−1点伤害。

·魔法攻击。小杨选择任意一个质数x(x不能超过怪物当前血量),对怪物造成x点伤害。由于小杨并不擅长魔法,他只能使用至多一次魔法攻击。

小杨想知道自己能否击败怪物,如果能,小杨想知道自己最少需要多少次攻击。


输入格式

第一行包含一个正整数t,代表测试用例组数。

接下来是t组测试用例。对于每组测试用例,第一行包含一个正整数h,代表怪物血量。

输出格式

对于每组测试用例,如果小杨能够击败怪物,输出一个整数,代表小杨需要的最少攻击次数,如果不能击败怪物,输出 -1。


输入样例

3
6
188
9999

输出样例

2
4
-1


对于第一组测试用例,一种可能的最优方案为,小杨先对怪物使用魔法攻击,选择质数 5 造成 5 点伤害,之后对怪物使用第 1 次物理攻击,造成21−1=1 点伤害,怪物血量恰好为 0,小杨成功击败怪物。

对于全部数据,保证有1≤t≤10,1≤h≤105。

查看答案与解析
答案:<pre class="brush:python;toolbar:false">prime = [] is_prime = [False] * 100010 def Eratosthenes(n): is_prime[0] = is_prime[1] = False for i in range(2, n + 1): is_prime[i] = True for i in range(2, n + 1): if is_prime[i]: prime.append(i) if i * i &gt; n: continue for j in range(i * i, n + 1, i): is_prime[j] = False Eratosthenes(100000) t = int(input()) for _ in range(t): tmp = 1 x = int(input()) ans = 0 while True: if is_prime[x]: ans += 1 break x -= tmp ans += 1 if x &lt;= 0: if x &lt; 0: ans = -1 break tmp *= 2 print(ans)</pre><p><br/></p>
解析:

考虑到物理攻击一定是1,2,4,……2i−1,这样枚举的,所以魔法攻击放到什么位置其实没有影响。

所以我们考虑如果当前x是质数,直接减质数结束即可,如果不是质数的话,就使用物理攻击即可。

流程:先用质数筛求质数,然后输入t,输入x,我们需要维护当前的物理攻击的值tmp,也就是1 2 4 ……,如果当前的x是质数,则直接结束,如果不是质数,则x-=tmp。

然后进行判断,如果x==0,则结束输出答案,如果x<0,则是没有答案的情况,输出-1