Python 四级题库（编程题）

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

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)

3：

设计一个算法，将一个正整数分解质因数。

程序分析：对n进行分解质因数，应先找到一个最小的质数k，然后按下述步骤完成：
                    (1)如果这个质数恰等于n，则说明分解质因数的过程已经结束，输出即可。
                    (2)如果n>k，但n能被k整除，则应打印出k的值，并用n除以k的商,

作为新的正整数n，重复执行第一步。
                    (3)如果n不能被k整除，则用k+1作为k的值，重复执行第一步。

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

输入输出示例：当n=105，输出：105= 3*5*7

                      当n=60，输出：60= 2*2*3*5

def fun(n):

    print(‘%d=’%n,end=’ ‘)

    for i in    ①   :

        while n!=i:

            if n>i and   ②   :

                print(i,end=’*’)

                   ③   

            else:

                break

        else:

               ④   

            break

if __name__ == “__main__”:

    while True:

        num=input(“输入一个正整数：”)

        if not num.isdigit():

            break

        fun(int(num))

4:

质数是一个大于1的自然数，除了1和它本身外，不能被其他自然数整除。下面的程序设计中，先自定义一个函数，用来判断一个数是否为质数。然后，通过键盘输入一个数，调用所编写的函数，判断该输入的数是否为质数。请根据上述设计思想，完成程序段中划线处的填空。

 

def findprime(m):

    for i in range(2,m):

        if _______①:

            return False    

        else:

            return ________ ②

n = int(input(‘请输入一个数:’))

if  _______③:

    print(“该数是质数.”)

else:

    print(“该数不是质数.”)

5:

随机生成的10个在[1,100)范围内整数存入列表；输入一个待查找的整数k，运用二分法在列表中查找k，根据查找状态输出对应的结果，请将程序补充完整。

from random import randint

def b(s,v):

    top=0

    last=len(s)

    while  ①_

        mid=(top+last)//2

        if v==s[mid]:

            return mid

        elif v>s[mid]:

             ②_

        elif v<s[mid]:

            last=mid-1

    return None

 

s=[randint(1,100) for i in range(10)]

s.sort()

print(s)

k=int(input())

ans=b(s,k)

if  ③_

    print(‘找到，下标是：’,ans)

else:

    print(‘没有找到这个数！’)

 

运行结果1：

[13, 25, 27, 41, 52, 66, 67, 69, 72, 75]

72

找到，下标是： 8

 

运行结果2：

[9, 15, 16, 19, 27, 31, 43, 64, 84, 93]

20

没有找到这个数！

6:

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

7:

在编写抽奖程序时，为了保证一个人只有一次中奖机会，要检查新抽出来的数字是不是已经被抽中过了。
一种办法是将已经中过奖的人员编号存放在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

8:

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

9:

外卖送餐服务越来越受到人们的喜爱，外卖小哥们也成了路上的一道风景。
当顾客使用外卖软件点餐时，会出现一个预计送达时间，包括了餐厅制作食物的时间，路上的骑行时间等等。
一种常用的计算路上骑行时间的方法是用曼哈顿距离(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分钟