Python编程四级 题库
换位密码法是将明文中的字符位置通过一定的规则重新排列从而得到密文的一种加密方法。某换位密码法加密方法如下:先把明文按照固定长度(4位一组)进行分组,然后对每一组的字符进行换位操作,从而得到密文。例如, 字符串"ceit",使用密钥1432进行加密时,首先将字符串以 4 个字符为一组进行分组,然后对每组的字符进行换位,第1个和第3个字符位置不变,把第2个字符和第4个字符交换位置,从而得到密文"ctie"。小张编写的程序如下,请完善划线处的代码:
def jiami(yw,key):
result = ''
for i in range(0, ① ,len(key)):
s1=yw[i:i+ len(key) ]
for j in range( ② ):
result = result + ③
return result
yw= input('请输入待加密的明文:')
key= input('请输入密钥:')
mw= ④
print(mw)
运行结果如下图所示:
![]()
def jiami(yw,key):
result = ''
for i in range(0,len(yw),len(key)):
s1=yw[i:i+len(key)]
for j in range(len(key)):
result = result + s1[int(key[j])-1]
return result
yw= input('请输入待加密的明文:')
key= input('请输入密钥:')
mw= jiami(yw,key)
print(mw)评分标准:
(1)len(yw);(2分)
(2)len(key);(3分)
(3)s1[int(key[j])-1];(4分)
(4)jiami(yw,key)。(3分)
一张长方形的纸,长m米,宽n米(长宽均为整数),现在要把它刚好裁成一些正方形(边长是整数),有几种裁法,如果要使裁得的正方形面积最大,可以裁多少块。小明学习了递归后,编写程序如下,首先输入长方形的长和宽,计算出结果。请完善划线处的代码:
def tj(a,b):
c = 0
minn = ①
if a > b:
minn = b
for i in range(1,minn+1):
if a % i == 0 and b % i == 0:
c = ②
return c
def gcd(a,b):
if b == 0:
return a
return ③
chang = int(input('输入长方形的长 (单位cm)'))
kuan = int(input('输入长方形的宽 (单位cm)'))
bianchang = gcd(chang,kuan)
total = ④
num = tj(chang,kuan)
print('------------结果如下-------------')
print('有{}种裁法'.format(num))
print('裁得的正方形面积最大边长是{}cm,可以裁{}块'.format(bianchang,total))
运行后的结果如下图所示:


评分标准:
(1)a;(2分)
(2)c + 1;(2分)
(3)gcd(b,a%b);(3分)
(4)(chang // bianchang) * (kuan // bianchang)或等价答案。(3分)
商超采用会员制,客户的消费信息如会员号、姓名和积分如下表所示,小方的爸爸想编写一个客户信息管理系统,其中有一个功能是:输入会员号,查询该会员的积分。

小方知道后,就跃跃欲试,他首先从数据库读取客户信息到列表data中,其中data[i][0]存储第i条记录的会员号,data[i][1]存储第i条记录的姓名,data[i][2]存储第i条记录的积分;他首先将数组data中数据按会员号升序排序,然后用二分查找算法查找会员号对应的积分信息。代码如下,完善划线处的代码:
def bubble_sort(d):
for i in range(len(d)-2):
for j in range(len(d)-1, ① ,-1):
if d[j][0] < d[j-1][0]:
d[j],d[j-1] = d[j-1],d[j]
def bin_ search(d, key):
i,j = 0, len(d)-1
while i <= j:
m=(i +j)//2
if ② :
return m
if key > d[m][0]:
i = m+1
else:
j = m-1
return -1
#从数据库读取会员信息存列表data中,代码略
data=[[8011,'张飞',12345],[8012,'李强',34512],[7812,'李好',45321]]
bubble_sort(data)
key = int(input('输入会员号:'))
m = ③
if m!=-1:
print (data[m][1],'先生/女士:您的积分是:',data[m][2])
else:
print('该会员号不正确')
def bubble_sort(d):
for i in range(len(d)-2):
for j in range(len(d)-1, i,-1):
if d[j][0] < d[j-1][0]:
d[j],d[j-1] = d[j-1],d[j]
def bin_search(d, key):
i,j = 0, len(d)-1
while i <= j:
m=(i +j)//2
if d[m][0] == key:
return m
if key > d[m][0]:
i = m+1
else:
j = m-1
return -1
#从数据库读取会员信息存列表data中,代码略
data=[[8011,'张飞',12345],[8012,'李强',34512],[7812,'李好',45321]]
bubble_sort(data)
key = int(input('输入会员号:'))
m = bin_search(data,key)
if m!=-1:
print (data[m][1],'先生/女士:您的积分是:',data[m][2])
else:
print('该会员号不正确')评分标准:
(1)i;(2分)
(2)d[m][0] == key;(3分)
(3)bin_search(data,key)。(3分)
已知某c的第n项计算步骤如下:

小明编写程序计算第n项的结果。首先从键盘输入n,然后利用上述递推关系计算结果,请完善划线处的代码。
def fc(n):
if n ==1:
①
else:
a=6*n-1
b=8*n+3
return ②
m=int(input("请输入一个整数:"))
if not isinstance(m,int): #判断输入的m是否为整数
print('请输入一个整数')
else:
print( ③ )
#参考程序:
def fc(n):
if n ==1:
return 1
else:
a=6*n-1
b=8*n+3
return a*fc(n-1)/b
m=int(input("请输入一个整数:"))
if not isinstance(m,int): #判断输入的m是否为整数
print('请输入一个整数')
else:
print(fc(m))评分标准:
(1)return 1;(3分)
(2)a*fc(n-1)/b;(3分)
(3)fc(m)。(2分)
说明:本题中已知c的第n项计算公式,第1项时c的值为1,第2项可以由第1项的基础上用公式计算,程序中编写了函数fc实现计算c的结果,在函数fc中,第1项时返回1,故①处代码是return 1 ;函数fc中②处代码是计算第n的数据,由递推公式可知该处代码是a*fc(n-1)/b ,③处代码是将输入的第m项调用函数fc计算结果,故该处的代码是fc(m)。
从键盘上分别输入要查找和替换的字符串,对文本文件进行查找与替换,替换后保存到新的文本文件中。
思路:输入待查找字符串s,需查找子字符串key和替换字符串new,通过调用自定义函数replace实现替换。完善划线处代码。
s = input("请输入待查找的字符串:")
key = input("请输入需查找的子字符串:")
new = input("请输入要替换的字符串:")
def findstr(key, s, begin):
for i in range(begin,len(s) - len(key) + 1):
if s[i: ① ]== key:
return i
return -1
def replace(key, new, s):
begin = 0
while begin < ② :
pos = findstr(key,s, begin)
if pos ==-1:
break
else:
s = s[0:pos]+ new + s[pos + len(key): ③ ]
begin = pos + len(key)
return s
rst = ④ #调用函数替换字符
print(rst)
#参考程序:
s = input("请输入待查找的字符串:")
key = input("请输入需查找的子字符串:")
new = input("请输入要替换的字符串:")
def findstr(key, s, begin):
for i in range(begin,len(s) - len(key) + 1):
if s[i:i+len(key)]== key:
return i
return -1
def replace(key, new, s):
begin = 0
while begin < len(s)-len(key)+ 1:
pos = findstr(key,s, begin)
if pos ==-1:
break
else:
s = s[0:pos]+ new + s[pos + len(key):len(s)]
begin = pos + len(key)
return s
rst = replace(key,new,s) #调用函数替换字符
print(rst)评分标准:
(1)i+len(key) 或等价答案;(3分)
(2)len(s)-len(key)+ 1 或等价答案;(3分)
(3)len(s) 或等价答案;(3分)
(4)replace(key,new,s) 或等价答案。(3分)
一个列表中存在n个数据,可以用分治算法来找到其中的最小值。具体过程如下:如果列表元素的个数小于等于2的时候,经过一个判断就找到其中的最小值,所以可以先把数据从中间划分为左右两部分,然后通过递归把每一部分再划分为左右两部分,直到数据规模小于等于2的时候,返回结果,然后通过递归到最后为两个数据对比,我们就可以找到最小值。
请根据以上算法过程,补全代码。
# 求列表中小于两个元素的最小值
def get_min(number):
if len(number) == 1:
return ①
else:
if number[1] > number[0]:
return number[0]
else:
return number[1]
def solve(number):
n = len(number)
if n <= 2:
return get_min(number)
else:
# 将整个列表分为左右两部分
left_list, right_list = ② , number[n//2:]
# 递归(树),分治
left_min, right_min = solve(left_list), ③
return get_min([left_min, right_min])
test_list = [5, 11, 3, 2, 7, 9]
print(solve(test_list))
#参考程序: # 求列表中小于两个元素的最小值 def get_min(number): if len(number) == 1: return number[0] else: if number[1] > number[0]: return number[0] else: return number[1] def solve(number): n = len(number) if n <= 2: return get_min(number) else: # 将整个列表分为左右两部分 left_list, right_list = number[:n//2], number[n//2:] # 递归(树),分治 left_min, right_min = solve(left_list), solve(right_list) return get_min([left_min, right_min]) test_list = [5, 11, 3, 2, 7, 9] print(solve(test_list))
评分标准:
(1)number[0];(2分)
(2)number[:n//2];(3分)
(3)solve(right_list)。(3分)
比岁数问题
有5个人坐在一起,问第五个人多少岁?他说比第4个人大2岁。问第4个人岁数,他说比第3个人大2岁。问第三个人,又说比第2人大两岁。问第2个人,说比第一个人大两岁。
最后问第一个人,他说是10岁。请问第五个人多大?
请运用递归算法完成以下代码。
def age(n):
if ① :
c = 10
else:
c = ②
return c
print(age( ③ ))
# 参考程序: def age(n): if n==1: # 1. c=10 else: c=age(n-1)+2 # 2. return c print(age(5)) # 3.
评分标准:
(1)n==1或等效答案;(3分)
(2)age(n - 1) + 2或等效答案;(4分)
(3)5或等效答案。(3分)
回文素数
回文素数是指一个不小于 11 的自然数 n 从左向右和从右向左读,其结果值相同且是素数,即称 n 为回文素数。一种求解的方法是先判断一个自然数是否为回文数,再判断它是否为素数。如果两个判断都成立,则该自然数是回文素数。请补全代码,找出自然数 1000 以内的所有回文素数。
#判断是否为素数
def ① (n):
for i in range(2,n):
if ② :
break
else:
return True
#判断是否为回文数
def HuiWenShu(n):
n=str(n)
if n== ③ :
return True
else:
return False
for i in range(11,1001):
if ZhiShu(i)==True ④ :
print('{}是回文素数!'.format(i))
#判断是否为素数
def ZhiShu(n):
for i in range(2,n):
if n%i==0:
break
else:
return True
#判断是否为回文数
def HuiWenShu(n):
n=str(n)
if n==n[::-1]:
return True
else:
return False
for i in range(11,1001):
if ZhiShu(i)==True and HuiWenShu(i)==True:
print('{}是回文素数!'.format(i))(1)ZhiShu 或等效答案;(2 分)
(2)n%i==0 或等效答案;(2 分)
(3)n[::-1] 或等效答案;(4 分)
(4)and HuiWenShu(i)==True 或等效答案。(4 分)
劳动实践基地
育才学校的劳动实践基地是一个巨大的矩形,参与劳动实践的同学们每次只能种一个正方形地块,每种一个正方形时所花的体力值是正方形的周长,本学期种过的地不可以再种,同学们想使用最少的体力值去种完这块田地,请帮助计算花费最小的体力值。
输入格式
两个正整数 x,y,表示田地的长和宽。
输出格式
输出最小体力值。
输入样例1
1 10
输出样例1
40
输入样例2
2 2
输出样例2
8
def solve(x, y):
if x == y:
return ①
if x > y:
a, b = x, y
else:
a, b = ②
if ③ :
return 4 * a
else:
return 4 * a + solve( ④ , b)
n, m = map(int, input().split())
print(solve(n, m))
def solve(x, y): if x == y: return x * 4 if x > y: a, b = x, y else: a, b = y, x if a % b == 0: return 4 * a else: return 4 * a + solve(a - b * (a//b), b) n, m = map(int, input().split()) print(solve(n, m))
(1)x * 4 或等效答案;(2分)
(2)y, x 或等效答案;(2分)
(3)a % b == 0 或等效答案;(2分)
(4)a - b * (a//b) 或等效答案。(2分)
约瑟夫环
2024年春节联欢晚会上,刘谦表演了一个纸牌魔术,深受观众欢迎。这个魔术的内容其实是一个经典的约瑟夫环问题,相当于n张牌形成一个环,依次循环报数,每次报到m的那一张牌扔掉,直到剩下最后一张牌。小智编写了以下程序来模拟8张牌的淘汰过程,请补充完成该程序。
def Josephus(num,gap):
location_list = [a for a in range(1,num+1)]
if num == 1 :
①
else:
index = 0
for i in ② :
index = (index + gap - 1 )% ③
print("本次淘汰的牌为:",location_list[index])
del location_list[index]
print( "最后剩下的牌为:",location_list[ ④ ])
Josephus(8,2)
def Josephus(num,gap):
location_list = [a for a in range(1,num+1)]
if num == 1 :
return
else:
index = 0
for i in range(num-1):
index = (index + gap - 1 )%len(location_list)
print("本次淘汰的牌为:",location_list[index])
del location_list[index]
print( "最后剩下的牌为:",location_list[0])
Josephus(8,2)(1)return 或等效答案;(2分)
(2)range(num-1) 或等效答案;(4分)
(3)len(location_list) 或等效答案;(4分)
(4)0 或等效答案。(2分)
数学游戏
校园里流行一种新的数学游戏:每次邀请两个同学参加,第一个同学先从1和2中挑一个数字,第二个同学可以在对方的基础上选择加1或者加2,然后又轮到第一个同学,他也可以选择加1或者加2,之后再把选择权交给对方,就这样交替地选择加1或者加2,谁先加到20,谁就赢了。小智编写了以下程序,分析总共存在多少种可能出现的情形。请补充完成该程序。
def act(n):
if n == 1 or ① :
return 1
sn = ②
return ③
tn = act( ④ )
print("总共存在%d种可能出现的情形。"%tn)
def act(n):
if n == 1 or n == 2:
return 1
sn = act(n-1) + act(n-2)
return sn
tn = act(20)
print("总共存在%d种可能出现的情形。"%tn)评分标准:
(1)n == 2 或等效答案;(2分)
(2)act(n-1) + act(n-2) 或等效答案;(2分)
(3)sn 或等效答案;(2分)
(4)20 或等效答案。(2分)
乘客问题
某路公共汽车,总共有八站,从一号站发车时车上已有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))质数是一个大于1的自然数,除了1和它本身外,不能被其他自然数整除。下面的程序设计中,先自定义一个函数,用来判断一个数是否为质数。然后,通过键盘输入一个数,调用所编写的函数,判断该输入的数是否为质数。请根据上述设计思想,完成程序段中划线处的填空。
def findprime(m):
for i in range(2,m):
if _______①:
return False
else:
return ________ ②
n = int(input('请输入一个数:'))
if _______③:
print("该数是质数.")
else:
print("该数不是质数.")
参考答案:
① m % i ==0 (3分)
② True (3分)
③ findprime(n) (4分)
def findprime(m):
for i in range(2,m):
if m % i==0:
return False
else:
return True
n = int(input('请输入一个数:'))
if findprime(n):
print("该数是质数.")
else:
print("该数不是质数.")有一群兔子,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)