Python编程四级 题库
未来居民社区设计有一个机器人服务中心,假如某社区有若干栋住宅楼,每栋楼的位置可以由坐标(x,y)表示,其中x坐标表示居民楼的东西向位置,y坐标表示居民楼的南北向位置。这里约定,社区中任意2点(x1,y1)和(x2,y2)的之间的距离使用数值|x1-x2|+|y1-y2|来度量。要求为社区选择建立机器人服务中心的最佳位置,使各个居民点到机器人服务中心的距离总和最小。以下是机器人服务中心的选址程序,采用取各坐标中位数的方法来确定中心位置,请补充完成该程序。
注:中位数的含义:一组按大小顺序排列起来的数据中处于中间位置的数。当有奇数个数据时,中位数就是中间那个数;当有偶数个数据时,中位数就是中间那两个数的平均数。
n=int(input("请输入居民楼总数:"))
hx=[]
hy=[]
for i in range(n):
x,y = map(int,input("请输入居民楼的x和y坐标:").split(","))
hx. append(x)
hy. append(y)
hx = sorted( ① )
hy = sorted( ② )
if n%2 == 0: #偶数情况,求中位数
sn = int(n/2)
x0 = int((hx[sn]+hx[sn-1])/2)
y0 = int((hy[sn]+hy[sn-1])/2)
else: #奇数情况,求中位数
sn = int((n-1)/2)
x0 = ③
y0 = ④
sumx=0
sumy=0
for j in hx:
dx =abs(x0-j)
sumx += dx
for k in hy:
dy = abs(y0-k)
sumy += dy
print("选址点的坐标是:(%d,%d)"%(x0,y0))
print("选址到各楼的累计距离是:",sumx+sumy)
#参考程序:
n=int(input("请输入居民楼总数:"))
hx=[]
hy=[]
#x,y = input("请输入居民楼的x和y坐标:").split(",")
for i in range(n):
x,y = map(int,input("请输入居民楼的x和y坐标:").split(","))
hx.append(x)
hy.append(y)
hx=sorted(hx) #对输入坐标进行排序
hy=sorted(hy)
if n%2 == 0: #偶数情况,求中位数
sn = int(n/2)
x0 = int((hx[sn]+hx[sn-1])/2)
y0 = int((hy[sn]+hy[sn-1])/2)
else: #奇数情况,求中位数
sn = int((n-1)/2)
x0 = hx[sn]
y0 = hy[sn]
sumx=0
sumy=0
for j in hx:
dx =abs(x0-j)
sumx += dx
for k in hy:
dy = abs(y0-k)
sumy += dy
print("选址点的坐标是:(%d,%d)"%(x0,y0))
print("选址到各楼的累计距离是:",sumx+sumy)评分标准:
(1)hx;(2分)
(2)hy;(2分)
(3)hx[sn];(3分)
(4)hy[sn]。(3分)
统计高分问题
小张在学习对分查找后,想利用该思路来实践一下,加深对该算法的理解。于是他按老师的要求,统计期末考试成绩,总分比他高的同学有多少个?
他的思路是,首先将全区所有学生的成绩降序排序,然后利用对分查找思想解决。他编写的代码如下,请完善划线处的代码。
cj =[654,643,621,612,609,606,...]#学生成绩存列表cj并已经降序排序
def dfsearch(key):
i =0; j=len(cj)-1
while i<=j:
m =(i+j)//2
if cj[m]>key:
①
else:
j-= 1
return ②
key = int(input('输入待查找的成绩'))
pos = ③
print('高于',key,'分的人数有',pos)
# 参考程序:
cj = [654, 643, 621, 612, 609, 606, ...] # 学生成绩存储在列表cj中,并已经按降序排序
def dfsearch(key): # 定义函数dfsearch,接受一个参数key
i = 0 # 初始化变量i为0
j = len(cj) - 1 # 初始化变量j为列表cj的长度减1
while i <= j: # 当i小于等于j时,进行循环查找
m = (i + j) // 2 # 计算中间位置的索引
if cj[m] > key: # 如果列表cj的第m个元素大于key
i += 1 # 1. 将i增加1,继续向右查找
else: # 否则,列表cj的第m个元素小于等于key
j -= 1 # 将j减少1,继续向左查找
return i # 2. 结束函数
key = int(input('输入待查找的成绩')) # 用户输入待查找的成绩,并将其转换为整数类型赋值给key
pos = dfsearch(key) # 3. 调用dfsearch函数,传入key作为参数,并将返回值赋值给pos
print('高于', key, '分的人数有', pos) # 输出结果,显示高于key分数的人数评分标准:
(1)i += 1或等价表达式;(2分)
(2)i或等价表达式;(3分)
(3)dfsearch(key)或等价表达式。(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分)
数学证明问题
上世纪中期,校园里流行一种数学游戏,其规则十分简单:任意取一个自然数,若它是奇数,则把它乘以3加上1,若它是偶数,则除以2。按此规则进行下去,经过若干步的计算就能得到自然数1。这个数学现象至今都没有得到完全的证明,但是可以编程来验证它的正确性。
实现上述功能的部分程序代码如下,请补充完成空白处的内容。
step = 1
midlist = []
def subwork(n):
global step
if n == 1:
return step
elif n % 2 == 0:
n = ①
midlist. append(n)
step += 1
subwork( ② )
return step
elif n % 2 != 0:
n = ③
midlist. ④
step += 1
subwork( ⑤ )
return step
cur_num = int(input("请输入一个数字:"))
subwork(cur_num)
print(midlist)
print(step)
# 参考程序:
step = 1 # 定义变量step并初始化为1
midlist = [] # 定义空列表midlist
def subwork(n): # 定义函数subwork,接受一个参数n
global step # 声明在函数内部使用全局变量step
if n == 1: # 如果n等于1
return step # 返回step的值
elif n % 2 == 0: # 如果n为偶数
n = n // 2 # 1. 将n除以2
midlist.append(n) # 将n添加到midlist列表中
step += 1 # 将step加1
subwork(n) # 2. 递归调用subwork函数,传入新的n值
return step # 返回step的值
elif n % 2 != 0: # 如果n为奇数
n = n * 3 + 1 # 3. 将n乘以3再加1
midlist.append(n) # 4. 将n添加到midlist列表中
step += 1 # 将step加1
subwork(n) # 5. 递归调用subwork函数,传入新的n值
return step # 返回step的值
cur_num = int(input("请输入一个数字:")) # 用户输入一个数字,将其转换为整数类型并赋值给cur_num
subwork(cur_num) # 调用subwork函数,传入cur_num作为参数
print(midlist) # 输出midlist列表的内容
print(step) # 输出step的值评分标准:
(1)n / /2或等效答案;(3分)
(2)n或等效答案;(2分)
(3)n * 3 + 1或等效答案;(3分)
(4)append(n)或等效答案;(2分)
(5)n 或等效答案。(2分)
数的分解
给出一个正整数 a,要求分解成若干个正整数的乘积,即 a=a1×a2×a3×... ×an,并且 1<a1≤a2≤a3≤...≤an,问这样分解的种类有多少。注意到 a=a 也是一种分解。
例如,8 可以分解成 8=2*2*2,8=2*4,8=8 总共 3 种。
代码如下,完善划线处的代码:
def fun(x, y=2):
if x == 1:
global ans
①
for i in range(y, x+1):
if ② :
fun(x//i,i)
lst = [2, 8, 9, 20] #测试数据
for i in lst:
ans = 0
③
print(ans)
程序运行结果如下:
1
3
2
4
def fun(x, y=2): if x == 1: global ans ans += 1 for i in range(y, x+1): if x % i == 0: fun(x//i, i) lst = [2, 8, 9, 20] #测试数据 for i in lst: ans = 0 fun(i) print(ans)
(1)ans += 1 或等效答案;(2 分)
(2)x % i == 0 或等效答案;(3 分)
(3)fun(i) 或等效答案。(3 分)
购物组合
小明单位发了 100 元的购物卡,小明到超市买三类洗化用品:洗发水(15 元)、香皂(2 元)、牙刷(5 元)。要把 100 元正好花掉,可有哪些购买组合?
def gouwu(money):
for i in range(0,money//15+1):
for j in range(0,money//2+1):
for k in range(0, ① ):
if ② :
print('可选择的购买组合:\t 购买洗发水 {} 瓶,香皂 {} 块,牙刷 {}个。'.format( ③ ))
gouwu(100)
def gouwu(money):
for i in range(0,money//15+1):
for j in range(0,money//2+1):
for k in range(0,money//5+1):
if i*15+j*2+k*5==money:
print('可选择的购买组合:\t 购买洗发水 {} 瓶,香皂 {} 块,牙刷 {}个。'.format(i,j,k))
gouwu(100)(1)money//5+1 或等效答案;(3 分)
(2) i*15+j*2+k*5==money 或等效答案;(4 分)
(3) i,j,k 或等效答案。(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 分)
计算问题
从1到n的数字(包含n),分别计算出能被k整除的数字之和与不能被k整除的数字之和,并输出它们差的绝对值,完成下列程序。
n=int(input("n="))
k=int(input("k="))
s1,s2=0,0
for i in range(1, ① ):
if( ② ==0):
s1= ③
else:
s2= ④
print( ⑤ )
n=int(input("n="))
k=int(input("k="))
s1,s2=0,0
for i in range(1,n+1):
if(i%k==0):
s1=s1+i
else:
s2=s2+i
print(abs(s1-s2))
(1)n+1 或等效答案;(2分)
(2)i%k 或等效答案;(2分)
(3)s1+i 或等效答案;(2分)
(4)s2+i 或等效答案;(2分)
(5)abs(s1-s2) 或等效答案。(2分)
劳动实践基地
育才学校的劳动实践基地是一个巨大的矩形,参与劳动实践的同学们每次只能种一个正方形地块,每种一个正方形时所花的体力值是正方形的周长,本学期种过的地不可以再种,同学们想使用最少的体力值去种完这块田地,请帮助计算花费最小的体力值。
输入格式
两个正整数 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分)
日期问题
小明同学学习Python的函数后,想动手利用函数来解决生活中的问题。于是他突发奇想,输入日期,统计这一天是这一年的第几天。其中,闰年指年份能被4整除但不能被100整除,或者仅能够被400整除。编写的代码如下,请完善划线处的代码。
def isRn(year): #判断year是否闰年
if ① or year % 400 == 0:
return 1
return 0
def jsDays(data): #计算日期data在这一年是第几天
s = 0
year = int(data[:4])
month = int(data[4:6])
day = int(data[6:])
for i in range( ② ):
s += days[i]
s += day
if month > 2 and ③ :
s += 1
return s
def checkRq(data): #判断输入的日期是否正确
month = int(data[4:6])
day = int(data[6:])
if month <1 or month >12:
return 0
if days[month-1]<day or day <1:
return 0
return 1
days = [31,28,31,30,31,30,31,31,30,31,30,31] #定义每个月的天数
rq = input('输入年月日,格式如:20240102\n')
if checkRq(rq):
d = ④
print(rq,'是这一年的第',d,'天')
else:
print(rq,'输入的日期有错误')
def isRn(year): #判断year是否闰年
if year % 4 ==0 and year % 100 != 0 or year % 400 == 0:
return 1
return 0
def jsDays(data): #计算日期data在这一年是第几天
s = 0
year = int(data[:4])
month = int(data[4:6])
day = int(data[6:])
for i in range(month-1):
s += days[i]
s += day
if month > 2 and isRn(year):
s += 1
return s
def checkRq(data): #判断输入的日期是否正确
month = int(data[4:6])
day = int(data[6:])
if month <1 or month >12:
return 0
if days[month-1]<day or day <1:
return 0
return 1
days = [31,28,31,30,31,30,31,31,30,31,30,31] #定义每个月的天数
rq = input('输入年月日,格式如:20240102\n')
if checkRq(rq):
d = jsDays(rq)
print(rq,'是这一年的第',d,'天')
else:
print(rq,'输入的日期有错误')评分标准:
(1)year % 4 == 0 and year % 100 != 0 或等效答案;(3分)
(2)month-1 或等效答案;(3分)
(3)isRn(year) 或等效答案;(3分)
(4)jsDays(rq) 或等效答案。(3分)
数学游戏
校园里流行一种新的数学游戏:每次邀请两个同学参加,第一个同学先从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("该数不是质数.")