首页 › 题库 › Python编程考级 › 2.1 创建函数

Python编程四级 题库

共 142 道题 ,第 7 / 8 页 · 按题型筛选,点「查看答案」核对解析
章节 2.1 创建函数 清除
121 简答题 偏难 Python编程考级 ·Python编程四级 · 2.1 创建函数

乘客问题

某路公共汽车,总共有八站,从一号站发车时车上已有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分)

题目详情
122 简答题 偏难 Python编程考级 ·Python编程四级 · 2.1 创建函数

时钟问题

小明上学时间是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分)

题目详情
123 简答题 偏难 Python编程考级 ·Python编程四级 · 2.1 创建函数

对称字符串

对称字符串是指从左往右读和从右往左读是一样的字符串。小方同学学习了递归思想后,利用递归思想来解决对称问题。在一串包含大小写字符和数字等字符组成的字符串中,他首先筛选出只包含大小写字符组成的字符串,然后判断该字符串是否是对称字符串。他编写的代码如下,请完善划线处的代码。

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分)

题目详情
124 简答题 偏难 Python编程考级 ·Python编程四级 · 2.1 创建函数

角谷猜想

所谓角谷猜想,是指对于任意一个正整数,如果是奇数,则乘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分)

题目详情
125 简答题 偏难 Python编程考级 ·Python编程四级 · 2.1 创建函数

在编写抽奖程序时,为了保证一个人只有一次中奖机会,要检查新抽出来的数字是不是已经被抽中过了。

一种办法是将已经中过奖的人员编号存放在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


题目详情
126 简答题 偏难 Python编程考级 ·Python编程四级 · 2.1 创建函数

乘法运算等于多个加法运算的和。比如,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


题目详情
127 简答题 偏难 Python编程考级 ·Python编程四级 · 2.1 创建函数

外卖送餐服务越来越受到人们的喜爱,外卖小哥们也成了路上的一道风景。

当顾客使用外卖软件点餐时,会出现一个预计送达时间,包括了餐厅制作食物的时间,路上的骑行时间等等。

一种常用的计算路上骑行时间的方法是用曼哈顿距离(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))


题目详情
128 简答题 偏难 Python编程考级 ·Python编程四级 · 2.1 创建函数

有一群兔子,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)


题目详情
129 简答题 偏难 Python编程考级 ·Python编程四级 · 2.1 创建函数

利用分治思想,给定一个顺序表,编写一个求出其最大值的程序。

根据上述算法思想,补全下列代码。

输入输出示例:当顺序表是 [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分)

题目详情
130 简答题 偏难 Python编程考级 ·Python编程四级 · 2.1 创建函数

现有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分)

题目详情
131 简答题 偏难 Python编程考级 ·Python编程四级 · 2.1 创建函数

求最小值

利用分治算法,求一个非空整数列表中的最小值。补全以下代码。

算法说明:将列表不断二分,直到子列表长度小于等于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的情况,避免无限递归。
通过切片将列表分为左右两部分,分别求最小值后合并结果。

题目详情
132 简答题 偏难 Python编程考级 ·Python编程四级 · 2.1 创建函数

二分查找

小明在学习二分查找后,编写程序实现查找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 = ',')

确定二分查找的中间索引计算方式;每次循环计算中点位置并将该位置值加入遍历记录;比较中点值与目标值决定搜索区间:若相等则查找成功并返回;若中点值大于目标值则调整右边界;若中点值小于目标值则调整左边界;循环直到区间无效;最后根据返回标志判断是否找到目标。输入目标值后调用函数获取遍历序列和查找结果,按格式输出过程数据。

题目详情
133 简答题 偏难 Python编程考级 ·Python编程四级 · 2.1 创建函数

密码安全性

密码离不开大家的生活,各类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('密码不符合安全要求')
题目详情
134 简答题 偏难 Python编程考级 ·Python编程四级 · 2.1 创建函数

智能家居系统

在智能家居系统中,我们可以通过中央控制系统来管理各个房间的智能灯。为了简化问题,假设每个房间有一个智能灯,其状态用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
题目详情
135 简答题 偏难 Python编程考级 ·Python编程四级 · 2.1 创建函数

回文单词

某同学收集了很多单词,不同的单词之间用'-'拼接在一起,如'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分)

题目详情
136 简答题 偏难 Python编程考级 ·Python编程四级 · 2.1 创建函数

素数是指大于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分)

题目详情
137 简答题 偏难 Python编程考级 ·Python编程四级 · 2.1 创建函数

猜价格

爸爸五一旅游回来给小明购买了一文创礼物,问能否用最少的次数猜出礼物的价格。提示该礼物的价格在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分)

题目详情
138 简答题 偏难 Python编程考级 ·Python编程四级 · 2.1 创建函数

垃圾分类

为了响应国家“绿色环保,健康生活”的号召,某小区安装了智能垃圾桶,能自动识别垃圾类型并分类。请你完善以下程序,实现垃圾自动分类功能。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分)

题目详情
139 简答题 偏难 Python编程考级 ·Python编程四级 · 2.1 创建函数

无人机社团

小明参加了一个无人机社团,现有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分

题目详情
140 简答题 偏难 Python编程考级 ·Python编程四级 · 2.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分)

题目详情