Python编程四级 题库
乘客问题
某路公共汽车,总共有八站,从一号站发车时车上已有n位乘客,到了第二站先下一半乘客,再上来了六位乘客,到了第三站也先下一半乘客,再上来了五位乘客,以后每到一站都先下车上已有的一半乘客,再上来了乘客比前一站少一个......,到了终点站车上还有乘客6人,问发车时车上的乘客有多少?根据递归思想,编写自定义函数完成该程序功能,完善空白处代码。
def num(i):
if i == 8:
return ①
else:
return ②
print( ③ )
def num(i): if i == 8: return 6 else: return (num(i+1)-8+i)*2 print(num(2))
终点站时车上的乘客数为6,分析与上一站前乘客数关系,可得递归公式为:num()=(num(i+1)-8+i)*2,因为首站为发车站,所以到第二站时车上的乘客数目即为发车时车上的乘客数。
评分标准:
(1)6 或等效答案;(2分)
(2)(num(i+1)-8+i)*2 或等效答案;(5分)
(3)num(2) 或等效答案。(3分)
时钟问题
小明上学时间是8:00,放学时间不固定,他很想知道从上学到放学,时钟的时针、分针和秒针一共有多少次指向了3点钟的位置。他尝试编写了如下程序,请你完善划线处的代码,计算出在h点s分放学时,三个时针分别经过3点位置的次数,用一个元组表示各指针经过3点位置的次数 (时针次数,分针次数,秒针次数) ,并输出。
def fn(h1, m1 ,h2 ,m2 ):
if(h2<15):
①
else:
hc=1
th= ②
if( ③ ):
mc= th+1
else:
mc=th
sc= ④
return (hc,mc,sc)
h=int(input("h="))
s=int(input("s="))
print(fn(8,0,h,s))
def fn(h1, m1 ,h2 ,m2 ):
if(h2<15):
hc=0
else:
hc=1
th= h2-h1
if(m2>=15):
mc= th+1
else:
mc=th
sc=th*60+(m2-m1)
return (hc,mc,sc)
h=int(input("h="))
s=int(input("s="))
print(fn(8,0,h,s))评分标准:
(1)hc=0 或等效答案;(3分)
(2)h2-h1 或等效答案;(3分)
(3)m2>=15 或等效答案;(3分)
(4)th*60+(m2-m1) 或等效答案。(3分)
对称字符串
对称字符串是指从左往右读和从右往左读是一样的字符串。小方同学学习了递归思想后,利用递归思想来解决对称问题。在一串包含大小写字符和数字等字符组成的字符串中,他首先筛选出只包含大小写字符组成的字符串,然后判断该字符串是否是对称字符串。他编写的代码如下,请完善划线处的代码。
def getzf(yw): #筛选出原始字符串yw中大写小写字符组成的字符串
rst = ''
for i in yw:
if 'z'>=i >='a' or 'Z'>=i >='A':
①
return rst
def nxzf(data): #生成字符串data的逆序字符串
if len(data) == 1:
return data[0]
return ②
yw =input('请输入字符串')
yw = getzf(yw)
nxzfc = nxzf(yw)
if ③ :
print('原字符串中存在对称字符串',yw)
else:
print('不存在对称字符串')
def getzf(yw): #筛选出原始字符串yw中大写小写字符组成的字符串
rst = ''
for i in yw:
if 'z'>=i >='a' or 'Z'>=i >='A':
rst+=i
return rst
def nxzf(data): #生成字符串data的逆序字符串
if len(data) == 1:
return data[0]
return nxzf(data[1:])+data[0]
yw =input('请输入字符串')
yw = getzf(yw)
nxzfc = nxzf(yw)
if nxzfc == yw:
print('原字符串中存在对称字符串',yw)
else:
print('不存在对称字符串')评分标准:
(1)rst += i 或 rst= rst +i 或等效答案;(2分)
(2)nxzf(data[1:])+data[0] 或等效答案;(3分)
(3)nxzfc == yw 或等效答案。(3分)
角谷猜想
所谓角谷猜想,是指对于任意一个正整数,如果是奇数,则乘3加1,如果是偶数,则除以2,得到的结果再按照上述规则重复处理,最终总能够得到1。如,假定初始整数为5,计算过程分别为16、8、4、2、1。程序要求输入一个整数,求经过多少次可得到自然数1。 根据题意,请完善划线处的代码。
def fun(n, cnt):
if ① :
print(cnt)
return
else:
if n % 2 == 0:
n //=2
②
else:
③
fun(n, cnt+1)
fun(5, ④ )
def fun(n, cnt): if n == 1: print(cnt) return else: if n % 2 == 0: n //=2 fun(n, cnt+1) else: n = n * 3 + 1 fun(n, cnt+1) fun(5, 0)
评分标准:
(1)n == 1 或等效答案;(3分)
(2)fun(n, cnt+1) 或等效答案;(2分)
(3)n = n * 3 + 1 或等效答案;(3分)
(4)0 或等效答案。(2分)
在编写抽奖程序时,为了保证一个人只有一次中奖机会,要检查新抽出来的数字是不是已经被抽中过了。
一种办法是将已经中过奖的人员编号存放在test_list里面,然后每抽出一个新的人员编号,判断它是否在中奖人员列表中。
如果没有在中奖人员列表中,说明中奖号码有效,并将它保存进中奖人员列表;如果已经在里面了,就再生成一个新的人员编号。
请你补全下面的代码,实现判断一个数字是否在列表中的功能。
#子问题算法(子问题规模为1)
def is_in_list(init_list,num):
if init_list[0] == num:
return True
else:
return False
#分治法
def find_out(init_list,num):
n = len(init_list)
if ____①______ #如果问题的规模等于1,直接解决
return is_in_list(init_list,num)
#分解(子问题规模为n/2)
left_list,right_list = _________②____________
#递归,分治,合并
res=find_out(left_list,num) __③__ find_out(right_list,num)
return res
if __name__ == "__main__":
#测试数据
test_list = [18,43,21,3,28,2,46,25,32,40,14,36]
#查找
print(_____④_____)
程序运行结果:
>>>True
(1) n==1: 或其他正确答案; (2分)
(2) init_list[:n//2],init_list[n//2:] 或其他正确答案; (2分)
(3) or 或其他正确答案; (2分)
(4) find_out(test_list,25) 或其他正确答案。 (2分)
参考程序:
#子问题算法(子问题规模为1) def is_in_list(init_list,num): if init_list[0] == num: return True else: return False #分治法 def find_out(init_list,num): n = len(init_list) if n == 1: #如果问题的规模等于1,直接解决 return is_in_list(init_list,num) #分解(子问题规模为n/2) left_list,right_list = init_list[:n//2],init_list[n//2:] #递归(树),分治,合并 res=find_out(left_list,num) or find_out(right_list,num) return res if __name__ == "__main__": #测试数据 test_list = [18,43,21,3,28,2,46,25,32,40,14,36] #查找 print(find_out(test_list,25)) #True
乘法运算等于多个加法运算的和。比如,3×2可以理解为3+3,也可以理解为2+2+2 。
下面的程序使用递归算法演示了计算两个自然数的乘积的过程。请你补全代码。
输入:分两次输入自然数num1,num2
输出:num1 × num2 = 乘积 def cheng_fa(num1,num2,value):
if ①
value += 0
else:
value += num1
②
value = cheng_fa(num1,num2,value)
return ③
num1=int(input('输入第1个数:'))
num2=int(input('输入第2个数:'))
value=0
value = cheng_fa(num1,num2,value)
print('{} X {} = {}'.format(num1,num2,value))
程序运行结果:
输入第1个数:3
输入第2个数:7
3 X 7 = 21
(1)num1==0 or num2==0: 或其他等效答案 ;(3分)
(2)num2 -= 1 或 num2=num2 - 1 或其他等效答案; (4分)
(3)value 。(3分)
参考程序:
def cheng_fa(num1,num2,value): if num1==0 or num2==0:
value += 0
else:
value += num1
num2 -= 1
value = cheng_fa(num1,num2,value)
return value
num1=int(input('输入第1个数:'))
num2=int(input('输入第2个数:'))
value=0
value = cheng_fa(num1,num2,value)
print('{} X {} = {}'.format(num1,num2,value))
程序运行结果:
输入第1个数:3
输入第2个数:7
3 X 7 = 21外卖送餐服务越来越受到人们的喜爱,外卖小哥们也成了路上的一道风景。
当顾客使用外卖软件点餐时,会出现一个预计送达时间,包括了餐厅制作食物的时间,路上的骑行时间等等。
一种常用的计算路上骑行时间的方法是用曼哈顿距离(manhatton distance)除以平均骑行速度。平面上点A(x1,y1)与点B(x2,y2)的曼哈顿距离为:|x1-x2|+|y1-y2|。
假设一名外卖小哥的平均骑行速度为30km/h。下面的程序模拟计算外卖小哥的路上骑行时间,请你补充完整。
输入:分两次输入A点和B点的坐标值
输出:A、B两点间的曼哈顿距离和路上骑行时间。
#求绝对值
def my_abs(n):
if ①
return n
else:
return ②
#主程序
v=30 #平均骑行速度
x1=float(input('输入A点的x坐标(米):'))
y1=float(input('输入A点的y坐标(米):'))
x2=float(input('输入B点的x坐标(米):'))
y2=float(input('输入B点的y坐标(米):'))
#计算曼哈顿距离mht
mht = ③
#计算路上骑行时间
time_on_the_road = ④
print('A、B两点的曼哈顿距离为{}米'.format(mht))
print('预计路上骑行时间需要{}分钟'.format(time_on_the_road))
程序运行结果:
输入A点的坐标(米),以逗号分隔:-1000,1000
输入B点的坐标(米),以逗号分隔:1000,-1000
A、B两点的曼哈顿距离为4000米
预计路上骑行时间需要8.0分钟
(1) n>0: 或 n>=0: (2分)
(2) -n (2分)
(3)my_abs(x1-x2)+my_abs(y1-y2) 或 sum([my_abs(x1-x2),my_abs(y1-y2)]) 或 sum((my_abs(x1-x2),my_abs(y1-y2))) 或其他等效答案; (4分)
(4)mht/1000/v*60 或 mht/(1000*v)*60 或 mht*60/1000/v 或 (mht*60)/(1000*v)或其他等效答案 。(4分)
参考程序:
#求绝对值
def my_abs(n):
if n>0:
return n
else:
return -n
#主程序
v=30 #平均骑行速度
x1,y1=eval(input('输入A点的坐标(米),以逗号分隔:'))
x2,y2=eval(input('输入B点的坐标(米),以逗号分隔:'))
#计算曼哈顿距离mht
mht = my_abs(x1-x2)+my_abs(y1-y2) #方法1
mht = my_abs(y1-y2)+my_abs(x1-x2) #方法2
mht = sum([my_abs(x1-x2),my_abs(y1-y2)]) #方法3
mht = sum((my_abs(x1-x2),my_abs(y1-y2))) #方法4
#计算路上骑行时间
time_on_the_road = mht/1000/v*60 #方法1
time_on_the_road = mht/(1000*v)*60 #方法2
time_on_the_road = mht*60/1000/v #方法3
time_on_the_road = (mht*60)/(1000*v) #方法4
print('A、B两点的曼哈顿距离为{}米'.format(mht))
print('预计路上骑行时间需要{}分钟'.format(time_on_the_road))有一群兔子,4个4个地数余1个,5个5个地数余2个,9个9个地数余7个,试问兔子有多少只?(请将程序补充完整)
def ①
while ②
if n%5==2:
break
n+=9
while True:
if ③
break
n+=45
print(n)
f(16)
参考答案:
① f(n):或等效答案;(4分)
② True:或等效答案;(4分)
③ n%4==1:或等效答案;(4分)
函数相关概念2分,自定义函数的创建与调用10分
def f(n): while True: if n%5==2: break n+=9 while True: if n%4==1: break n+=45 print(n) f(16)
利用分治思想,给定一个顺序表,编写一个求出其最大值的程序。
根据上述算法思想,补全下列代码。
输入输出示例:当顺序表是 [22,13,34,4,68,15,5,58,36],输出:68
def fun_max(num=list):
return max(num)
def fun(num):
n = ①
if n <= 2:
return ②
l_list, r_list = num[:n//2], num[n//2:]
l_max, r_max = ③
return fun_max( ④ )
if __name__ == "__main__":
alist = [22,13,34,4,68,15,5,58,36]
print(fun(alist))
参考程序:
def fun_max(num=list): return max(num) def fun(num): n = len(num) if n <= 2: return fun_max(num) l_list, r_list = num[:n//2], num[n//2:] l_max, r_max = fun(l_list), fun(r_list) return fun_max([l_max, r_max]) if __name__ == "__main__": alist = [22,13,34,4,68,15,5,58,36] print(fun(alist))
评分标准:
① len(num) 或等效答案; (2分)
② fun_max(num) 或等效答案; (2分)
③ fun(l_list), fun(r_list) 或等效答案; (2分)
④ [l_max, r_max] 或等效答案;(2分)
现有n个人依次围成一圈玩游戏,从第1个人开始报数,数到第m个人出局,然后从出局的下一个人开始报数,数到第m个人又出局,...,如此反复到只剩下最后一个是胜利者。设n个人的编号分别为1,2,...,n,打印出局的顺序。
根据上述算法思想,补全下列代码。
输入输出示例:当n=10,m=4,输出如下:
出局的人是: 4
出局的人是: 8
出局的人是: 2
出局的人是: 7
出局的人是: 3
出局的人是: 10
出局的人是: 9
出局的人是: 1
出局的人是: 6
最后胜利者是: 5
def fun(n,k):
L = list( ① )
if n == 1:
return
else:
x = 0
for i in ②
x = ③ - 1
print('出局的人是:',L[x])
del L[x]
if x < 0:
x = 0
print('最后胜利者是:', ④ )
fun(10,4)
参考程序:
def fun(n,k):
L = list(range(1,n+1))
if n == 1:
return
else:
x = 0
for i in range(n-1):
x = (x + k) % len(L) - 1
print('出局的人是:',L[x])
del L[x]
if x < 0:
x = 0
print('最后胜利者是:',L[0])
fun(10,4)评分标准:
① range(1,n+1) 或等效答案;(3分)
② range(n-1): 或等效答案;(3分)
③ (x + k) % len(L) 或等效答案;(3分)
④ L[0] 或等效答案;(3分)
求最小值
利用分治算法,求一个非空整数列表中的最小值。补全以下代码。
算法说明:将列表不断二分,直到子列表长度小于等于2,直接比较得出最小值,然后合并结果(返回两个子列表最小值中的较小者)。
def find_min(nums):
n = len(nums)
# 基线条件:问题规模足够小,直接求解
if n == 1:
return ①
elif n == 2:
return ②
# 分解:将大问题分成两个子问题
mid = n // 2
left_part = nums[:mid]
right_part = nums[mid:]
# 解决:递归求解子问题
left_min = find_min(left_part)
right_min = find_min(right_part)
# 合并:合并子问题的解
return ③
# 测试
test_list = [34, 12, 5, 78, 3, 56, 91, 23]
print('列表中的最小值是:', find_min(test_list))
def find_min(nums):
n = len(nums)
# 基线条件:问题规模足够小,直接求解
if n == 1:
return nums[0]
elif n == 2:
return nums[0] if nums[0] < nums[1] else nums[1]
# 分解:将大问题分成两个子问题
mid = n // 2
left_part = nums[:mid]
right_part = nums[mid:]
# 解决:递归求解子问题
left_min = find_min(left_part)
right_min = find_min(right_part)
# 合并:合并子问题的解
return left_min if left_min < right_min else right_min
# 测试
test_list = [34, 12, 5, 78, 3, 56, 91, 23]
print('列表中的最小值是:',find_min(test_list))① 返回列表唯一元素;
② 比较两个元素并返回较小者;
③ 比较左右两部分的最小值并返回较小者。
递归将原问题分解为规模更小的相同子问题,基线条件处理长度为1或2的情况,避免无限递归。
通过切片将列表分为左右两部分,分别求最小值后合并结果。
二分查找
小明在学习二分查找后,编写程序实现查找key所遍历的过程。如有原始数据是 12, 18, 27, 31, 46, 68, 75, 80, 90, 92,待查找的数据是90,打印输出key所遍历数分别是:
46,80,90。他编写的程序如下,完善划线处的代码。
def dfsearch(data,key): #二分法在data中查找key
p = [] #存放key所遍历数
flag = False
i,j = 0,len(data) - 1
while i <= j:
m = (i+j)//2
p.append(data[m])
if ① :
flag = True
return p,flag
elif data[m] > key:
j = ②
else:
i = ③
return p,flag
data = [12,18,27,31,46,68,75,80,90,92]
key = int(input())
rst,flag = ④
if flag:
print('原始数据是',data,'待查找的数据是',key,'\n找到,查找的数分别是:')
for i in rst:
print(i,end = ',')
else:
print('原始数据是',data,'待查找的数据是',key,'\n没有找到,查找的数分别是:')
for i in rst:
print(i,end = ',')
def dfsearch(data,key):#二分法在data中查找key
p = []#存放key所遍历数
flag = False
i,j = 0,len(data) - 1
while i <= j:
m = (i+j)//2
p.append(data[m])
if data[m] == key:
flag = True
return p,flag
elif data[m] > key:
j = m - 1
else:
i = m + 1
return p,flag
data = [12,18,27,31,46,68,75,80,90,92]
key = int(input())
rst,flag = dfsearch(data, key)
if flag:
print('原始数据是',data,'待查找的数据是',key,'\n找到,查找的数分别是:')
for i in rst:
print(i,end = ',')
else:
print('原始数据是',data,'待查找的数据是',key,'\n没有找到,查找的数分别是:')
for i in rst:
print(i,end = ',')确定二分查找的中间索引计算方式;每次循环计算中点位置并将该位置值加入遍历记录;比较中点值与目标值决定搜索区间:若相等则查找成功并返回;若中点值大于目标值则调整右边界;若中点值小于目标值则调整左边界;循环直到区间无效;最后根据返回标志判断是否找到目标。输入目标值后调用函数获取遍历序列和查找结果,按格式输出过程数据。
密码安全性
密码离不开大家的生活,各类APP中密码设置简单了,就容易造成损失。为此小明编写程序检测密码是否安全。安全密码的两个条件:①密码长度至少8位,②密码中数字、大写字母、小写字母和特殊符号(!@#$%^&*())这四类符号中必须有3项以上。比如,密码是 "ADa%9"(不包括双引号),运行程序后输出"密码不符合安全要求"。利用Python编写程序如下,完善划线处的代码。
def checkpwd(pwd):
c = [0] * 4
flag = False
if len(pwd) >= 8:
①
for i in pwd:
if ② :
c[0] = 1
elif i >='A' and i <= 'Z':
c[1] = 1
elif i >='a' and i <= 'z':
c[2] = 1
elif i in '!@#$%^&*()':
③
if ④ and flag:
return True
else:
return False
pwd = input('请输入密码')
if checkpwd(pwd):
print('密码符合安全要求')
else:
print('密码不符合安全要求')
def checkpwd(pwd):
c = [0] * 4
flag = False
if len(pwd) >= 8:
flag = True
for i in pwd:
if i in '0123456789':
c[0] = 1
elif i >='A' and i <= 'Z':
c[1] = 1
elif i >='a' and i <= 'z':
c[2] = 1
elif i in '!@#$%^&*()':
c[3] = 1
if sum(c) >=3 and flag:
return True
else:
return False
pwd = input('请输入密码')
if checkpwd(pwd):
print('密码符合安全要求')
else:
print('密码不符合安全要求')智能家居系统
在智能家居系统中,我们可以通过中央控制系统来管理各个房间的智能灯。为了简化问题,假设每个房间有一个智能灯,其状态用1表示开,0表示关。我们的任务是计算家里所有开着的灯的数量。我们将采用分治算法的思想来解决这个问题。
请补全以下代码,使用分治算法实现统计列表中开着的灯(值为1)数量的功能。
def count_lights_on(rooms):
# 如果列表为空,直接返回0
if not rooms:
return 0
# 如果列表只有一个元素,直接判断是否为开着的灯
if len(rooms) == 1:
return rooms[0]
# 将列表分为两部分
mid = ①
left_rooms = rooms[:mid]
right_rooms = rooms[mid:]
# 使用分治递归统计每部分开着的灯的数量
count_left = ②
count_right = count_lights_on(right_rooms)
# 返回总开着的灯的数量
return ③
# 示例测试
rooms = [1, 0, 1, 0, 1, 0, 1] # 1代表灯开着,0代表灯关着
print(count_lights_on(rooms)) # 输出应为4
def count_lights_on(rooms): # 如果列表为空,直接返回0 if not rooms: return 0 # 如果列表只有一个元素,直接判断是否为开着的灯 if len(rooms) == 1: return rooms[0] # 将列表分为两部分 mid = len(rooms) // 2 left_rooms = rooms[:mid] right_rooms = rooms[mid:] # 使用分治递归统计每部分开着的灯的数量 count_left = count_lights_on(left_rooms) count_right = count_lights_on(right_rooms) # 返回总开着的灯的数量 return count_left + count_right # 示例测试 rooms = [1, 0, 1, 0, 1, 0, 1] # 1代表灯开着,0代表灯关着 print(count_lights_on(rooms)) # 输出应为4
回文单词
某同学收集了很多单词,不同的单词之间用'-'拼接在一起,如'refer-level-face-',他发现有些单词如level,从左往右读和从右往左读该单词是一样的,称之为回文单词。他想统计他收集的单词中有多少个回文单词。步骤如下:(1)首先将单词按'-'分割出所有单词,(2)统计这些单词中回文单词的数量。编写的Python代码如下,完善划线处的代码。
def revstr(str):
if len(str) == 1:
return ①
else:
return ②
word = 'refer-level-face-'
wordlst = []
s = ''
for t in word:
if t !='-':
③
else:
wordlst.append(s)
s = ''
c = 0
for w in wordlst:
rev = revstr(w)
if ④ :
c += 1
print('对称的字符串个数有',c)def revstr(str):
if len(str) == 1:
return str
else:
return revstr(str[1:]) + str[0]
word = 'refer-level-face-'
wordlst = []
s = ''
for t in word:
if t !='-':
s += t
else:
wordlst.append(s)
s = ''
c = 0
for w in wordlst:
rev = revstr(w)
if w == rev:
c += 1
print('对称的字符串个数有',c)评分标准:
(1)str(或等效答案); (2分)
(2)revstr(str[1:]) + str[0](或等效答案);(3分)
(3)s += t 或 s = s + t(或等效答案); (2分)
(4)w == rev(或等效答案)。(3分)
素数是指大于1的自然数,且只能被1和它本身整除的数。孪生素数是指差值为2的两个素数,例如 (3, 5)、(11, 13) 等。问题:给定一个整数 n,请编写程序输出所有小于等于 n 的孪生素数对,按升序排列。 补全下列程序代码。
def is_prime(num): if ① : return False for i in range(2, num): if ② : return False return ③ def find(n): for i in range(2,n-1): if is_prime(i) and ④ : print(i, i + 2) n = int(input()) find(n)
def is_prime(num): if num < 2: # ① 小于2的数非素数 return False for i in range(2, num): if num % i == 0: # ② 存在因数则非素数 return False return True # ③ 通过所有检查则为素数 def find(n): for i in range(2, n - 1): if is_prime(i) and is_prime(i + 2): # ④ 检查孪生素数对 print(i, i + 2) n = int(input()) find(n)
评分标准:
(1)num < 2 (或等效答案);(3分)
(2)num % i == 0 (或等效答案);(3分)
(3)True (或等效答案);(3分)
(4)is_prime(i+2) (或等效答案)。(3分)
猜价格
爸爸五一旅游回来给小明购买了一文创礼物,问能否用最少的次数猜出礼物的价格。提示该礼物的价格在1-200之间,且是整数。小明编写如下Python程序解决该问题,输出结果中包含猜价格的过程以及猜的次数。请完善划线处的代码。
price = int(input()) #存礼物的实际价格
def sear(p,pmin,pmax):
i = pmin
j = pmax
s = ''
c = 0
while ① :
c = c + 1
m = (i + j)//2
if m == p:
s = s + str(m) + ','
②
elif m < p:
i = m + 1
else:
③
s = s + str(m) + ','
return s,c
pmin = 1
pmax = 200
rst , c = sear(price,pmin,pmax)
print('猜价格的过程是',rst)
print('一共猜了',c,'次就猜对价格')
price = int(input())#存礼物的实际价格
def sear(p,pmin,pmax):
i = pmin
j = pmax
s = ''
c = 0
while i <= j:
c = c + 1
m = (i + j)//2
if m == p:
s = s + str(m) + ','
break
elif m < p:
i = m + 1
else:
j = m - 1
s = s + str(m) + ','
return s,c
pmin = 1
pmax = 200
rst , c = sear(price,pmin,pmax)
print('猜价格的过程是',rst)
print('一共猜了',c,'次就猜对价格')评分标准:
(1)i <= j 或等效答案;(3分)
(2)break 或等效答案;(3分)
(3)j = m - 1 或等效答案。(2分)
垃圾分类
为了响应国家“绿色环保,健康生活”的号召,某小区安装了智能垃圾桶,能自动识别垃圾类型并分类。请你完善以下程序,实现垃圾自动分类功能。recycle = ["纸", "塑料瓶", "玻璃", "金属"]
harmfull = ["电池", "药品", "灯泡", "油漆"]
category = {1: "可回收垃圾", 2: "有害垃圾", 3: "其他垃圾"}
trash_lst = ["烟蒂", "药品", "金属"]
def judge(item):
if ① :
return 1
elif item in harmfull:
return 2
else:
return ②
def classify(trash):#通过字典键获取垃圾类型
i = judge(trash)
return ③
for trash_name in trash_lst:#判断垃圾类型
cate_name = ④ (trash_name)
print(f"{trash_name} 属于: {cate_name}")
输出效果:
烟蒂 属于: 其他垃圾
药品 属于: 有害垃圾
金属 属于: 可回收垃圾
recycle = ["纸", "塑料瓶", "玻璃", "金属"]
harmfull = ["电池", "药品", "灯泡", "油漆"]
category = {1: "可回收垃圾", 2: "有害垃圾", 3: "其他垃圾"}
trash_lst = ["烟蒂", "药品", "金属"]
def judge(item):
if item in recycle:
return 1
elif item in harmfull:
return 2
else:
return 3
def classify(trash):
i = judge(trash)
return category.get(i)
for trash_name in trash_lst:
cate_name = classify(trash_name)
print(f"{trash_name} 属于: {cate_name}")评分标准:
(1)item in recycle 或等效答案;(2分)
(2)3 或等效答案;(4分)
(3)category[i] 或category.get(i) 或等效答案;(4分)
(4)classify或等效答案。(2分)
无人机社团
小明参加了一个无人机社团,现有n架无人机,编号为1, 2, 3, ..., n,依照规则出队执行任务。规则:从队列中按顺序出队第 k 架无人机,直到剩下最后一架无人机时,它将完成最终任务。现在需要计算第m架被出队的无人机的编号,请补充完成该程序。
def solve(n, k, m): if ① : #递归终止条件:当排除第1架时 return (n + k - 1) % ② #计算首轮被排除的位置 else: return (solve( ③ ) + k) % n n, k, m = map(int, input().split()) print( ④ )
参考程序:
def solve(n, k, m): if m == 1: # ① 递归终止条件:当排除第1架时 return (n + k - 1) % n # ② 计算首轮被排除的位置 else: return (solve(n-1, k, m-1) + k) % n # ③ 递归缩小问题规模 n, k, m = map(int, input().split()) print(solve(n, k, m) + 1) # ④ 调整索引偏移(从1开始)
评分标准:
(1)m == 1 (或等效答案);(2分)
(2)n (或等效答案);(2分)
(3)n-1, k, m-1(或等效答案);(2分)
(4)solve(n, k, m) + 1(或等效答案)。(2分)说明:solve(n, k, m)给1分
岩浆活动
2024年,我国科学家通过对嫦娥六号月壤样品的分析研究,发现月球背面某区域的岩浆活动层数呈现递减规律:最上层有n层岩浆活动,下一层岩浆活动层数是上一层的三分之一(向下取整),直到层数小于等于1时停止。
此外,每层岩浆活动有一个厚度值,最上层厚度为t,下一层厚度为上一层的0.5倍。
请完善以下程序,计算该区域的总岩浆活动层数和总厚度。
def moon(n, t):
"""
计算月球某区域的总岩浆活动层数和总厚度
n: 最上层的岩浆活动层数
t: 最上层的岩浆活动厚度
return: (总层数, 总厚度)
"""
if ① :
return 1, t
else:
sub_layers, sub_thickness = moon(n // 3, ② )
return ③ , t + sub_thickness
# 测试代码
n = int(input("请输入最上层的岩浆活动层数:"))
t = float(input("请输入最上层的岩浆活动厚度:"))
total_layers, total_thickness = ④
print(f"该区域的总岩浆活动层数为:{total_layers}")
print(f"该区域的总岩浆活动厚度为:{total_thickness}")参考程序:
def moon(n, t):
"""
计算月球某区域的总岩浆活动层数和总厚度
n: 最上层的岩浆活动层数
t: 最上层的岩浆活动厚度
return: (总层数, 总厚度)
"""
if n <= 1:
return 1, t
else:
sub_layers, sub_thickness = moon(n // 3, t * 0.5)
return n + sub_layers, t + sub_thickness
# 测试代码
n = int(input("请输入最上层的岩浆活动层数:"))
t = float(input("请输入最上层的岩浆活动厚度:"))
total_layers, total_thickness = moon(n, t)
print(f"该区域的总岩浆活动层数为:{total_layers}")
print(f"该区域的总岩浆活动厚度为:{total_thickness}")评分标准:
(1)n <= 1(或等效答案);(2分)
(2)t * 0.5 (或等效答案);(3分)
(3)n + sub_layers (或等效答案);(3分)
(4)moon(n, t)(或等效答案)。(2分)