类型：函数
描述
写一个函数isPrime(n)用于判断一个数字n是不是素数，用户输入一个正整数，在一行内输出不大于该数的所有素数，各数后面用一个空格分隔。
输入格式
输入一个正整数
输出格式
不大于该数的所有素数，各数后面用一个空格分隔。
示例
输入：100
输出：2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97
标准答案
def isPrime(n): #判断素数的函数
if n < 2:
return False #0和1不是素数
for i in range(2, n):
if n % i == 0:
return False
break
else:
return True
num = int(input()) #接收用户输入并转成整数
for i in range(num):
if isPrime(i):
print(i,end=' ') #在同一行内输出结果，不换行，中间用空格分隔
类型：函数
描述
设计一个用二分法计算一个大于或等于 1 的实数 n 的平方根的函数sqrt_binary(n)，计算精度控制在计算结果的平方与输入的误差不大于1e-6。
注：初始区间取[0,n]
输入格式
输入一个实数 n（大于或等于1）
输出格式
第一行输出用自己设计的函数计算得到的平方根
第二行输出用math库开平方函数计算得到的平方根
示例
输入：5.0
输出：
2.2360679507255554
2.23606797749979
标准答案
import math
def sqrt_binary(num):
low, high= 0,num
while True:
x = (high + low)/2
if abs(x**2 - num)<=1e-6:
return x
elif x**2 - num<0:
low = x
else:
high = x
num = float(input())
if num >=0:
print(sqrt_binary(num))
print(math.sqrt(num))
else:
print('请输入一个非负数！')
类型：函数
描述
设计一个用二分法计算一个大于或等于 0 的实数 n 的平方根的函数sqrt_binary(n)，实数 n和计算精度控制由用户在同一行内输入，用逗号进行分隔，输出结果保留8位小数。当(abs(x * x - n) )小于或等于设定的精度时，近似认为 x * x == n。
注：初始区间取[0,n+0.25]
输入格式
在同 行内输入一个实数 n（大于或等于0）和一个代表精度的数字（可用1e-m格式输入），逗号间隔
输出格式
第一行输出用自己设计的函数计算得到的平方根
第二行输出用math库开平方函数计算得到的平方根
示例
输入：5.0,1e-7
输出：
2.23606796
2.23606798
标准答案
import math
def sqrt_binary(num, accuracy):
"""接收一个浮点数num和一个表示计算精度的浮点数accuracy为参数，用二分法计算浮点数的平方根x，
当 abs(x * x - num) <= accuracy时认为达到计算精度，以浮点数类型返回计算得到的平方根。"""
low, high = 0, num + 0.25 # 设定初始区间
while True: # 构建无限循环
x = (high + low) / 2 # 假设平方根落在区间的二分之一处，即中点
if abs(x * x - num) <= accuracy: # 当误差小于计算精度时，终止循环
return x # 返回当前的x值为平方根
elif x * x - num < 0: # 当前x的平方小于num时，平方根应该位于右侧区间
low = x # 以当前数值为区间下限，缩小区间为原来的一半
else: # 当前x的平方大于num时，平方根应该位于左侧区间
high = x # 以当前数值为区间上限，缩小区间为原来的一半
n, error = map(float, input().split(',')) # 输入浮点数 n 和计算精度
print('{:.8f}'.format(sqrt_binary(n, error))) # 调用二分法函数计算平方根
print('{:.8f}'.format(math.sqrt(n))) # 用math库中的sqrt()计算平方根
类型：函数
描述
我的微信ID是大写字母WHUT后面的数字是两个素数连在一起，大的在前，小的在后，如果我告诉你两数的乘积是多少，你能计算出我的ID号吗？
如果输入一个[0-9]之间的数字，你能统计出从1开始到我ID中的数字的序列里，一共出现多少次这个数字吗？
输入格式
第一行输入ID中两个素数的乘积
第二行输入一个[0-9]之间的数字
输出格式
第一行输出ID号
第二行输出数字的次数
输入输出示例
示例
输入：
196409
3
输出：
WHUT997197
599140
标准答案
def isPrime(n): # 判断参数 n 是否为素数的函数
if n < 2: # 小于2的数字都不是素数
return False
for i in range(2, int(n ** 0.5) + 1): # 根据素数定义判定是否是素数，是素数返回1
if n % i == 0: # 从 2到n-1中如果存在一个数是i，使n 可以整除i，则n不是素数
return False
else: # 若for循环未遇到return正常结束，则n是素数
return True
def checkId(n):
if n % 2 == 0 and isPrime(n // 2): # 如果n能被2整除，单独处理，提高效率
return int(str(n // 2) + str(2))
else:
for num in range(3,n//2+1,2): # 如果n不能被2整除，则两个素数不包括2，都是奇数
if isPrime(num) and n % num == 0 and isPrime(n // num): # isPrime(n // num)放在最后，利用短路效应，可以使大数的素数判定次数最少
return int(str(n // num) + str(num)) # 返回值转字符串拼接后再转整数
def countnumber(n,num):
m, countnum = 1, 0
while n//m > 0:
high, mod = divmod(n, m*10)
curNum, low = divmod(mod, m)
if curNum > num:
countnum += high*m + m
elif curNum == num:
countnum += high*m + low + 1
else:
countnum+= high*m
m = m*10
return countnum
if __name__ == '__main__':
n = int(input()) # 输入ID,整数，保证是两个素数的积
number = int(input()) # 输入0-9之间的一个数字
ID = checkId(n)
countNumber = countnumber(ID,number) # 统计 number的个数
print('WHUT' + str(ID))
print(countNumber)
# def occ3(n,num):
# s = 0
# for i in range(len(str(n))):
# x = int(str(n)[-i-1])
# s += n//10**(i+1)*10**i
# if x == num:
# s += n%10**i+1
# if x > num:
# s += 10**i
# return s
# def isPrime(n): #判断素数的函数
# if n < 2 or n % 2==0:
# return False #0、1、负数以及偶数都不是素数
# for i in range(3, int(n**0.5)+1,2):
# if n % i == 0: #能被2到其自身减1的数整除的数不是素数
# return False
# else:
# return True #for循环正常结束，未遇到return的数是素数
# n = int(input()) #接收用户输入并转成整数707829217
# number = int(input())
# for i in range(n):
# if isPrime(i) and n%i==0 and isPrime(n//i): #判断i和N-i是否同时是素数，同时保证两个数加和为N
# print("WHUT{}{}".format(n//i,i))
# break #找到一个符合条件的数就结束循环
# m = int(str(n//i)+str(i))
# print(occ3(m,number))
# print(three(m,number))
# m = int(str(n//i)+str(i))
# num=0
# for j in range(1,m+1):
# if number in str(j):
# num=num+str(j).count(number)
# print(num)
类型：函数
描述
回文素数是指一个数既是素数又是回文数。例如，131，既是素数又是回文数。 用户输入一个正整数 n , 请你在一行内输出从小到大排列的的前n个回文素数，数字后面用一个空格进行分隔。
输入格式
输入一个正整数
输出格式
符合要求的回文素数
示例
输入：10
输出：2 3 5 7 11 101 131 151 181 191
标准答案
def is_prime(n):
"""判断素数的函数,接收一个正整数为参数，参数是素数时返回True，否则返回False
减小判定区间，减少循环次数，提升效率。
"""
if n < 2:
return False # 0、1、负数以及偶数都不是素数
for i in range(2, int(n ** 0.5) + 1):
if n % i == 0: # 能被2到其根号n之间的整数整除的数不是素数
return False
else:
return True # for循环正常结束，未遇到return的数是素数
def palindromic(num):
"""接收一个数字为参数，判定其是否为回文数，返回布尔值。"""
if str(num) == str(num)[::-1]:
return True
else:
return False
def output_prime(num):
"""接收一个正整数num为参数，在一行中从小到大输出前num个回文素数。
函数无返回值
"""
i = 2 # 从最小的素数2开始测试
count = 0 # 计数器置0
while True: # 无限循环
if palindromic(i) and is_prime(i): # 先判断回文再判断素数，效率高
print(i, end=' ') # i为回文素数时输出i，输出后不换行
count = count + 1 # 每发现一个回文素数计数增加1
if count == num: # 如果找到回文素数数量与要求数量相同时
break # 结束循环
i = i + 1 # 测试下一个数字
if __name__ == "__main__":
n = int(input())
output_prime(n)
类型：函数
描述
反素数(逆向拼写的素数)是指一个将其逆向拼写后也是一个素数的非回文数。
例如：
13和31都是素数，且13和31都不是回文数，所以，13和31是反素数。
输入一个正整数 n , 请在同一行输出从小到大排列的的前n个反素数，每个数字后面加一个空格。
输入格式
输入一个正整数
输出格式
符合条件的反素数
示例
输入：
10
输出：
13 17 31 37 71 73 79 97 107 113
标准答案
def is_prime(n):
if n <= 1: # 小于2的数字单独处理
return True
for i in range(2, int(n ** (1 / 2) + 1)): # 根据素数定义判定是否是素数，是素数返回1
if n % i == 0:
return False
return True
def palindromic(num):
"""接收一个数字为参数，判定其是否为回文数，返回布尔值。"""
return str(num) == str(num)[::-1]
def reverse_num(num):
"""接收一个整数，返回其逆序字符串对应的整数"""
return int(str(num)[::-1])
def reverse_prime(number):
i = 2
count = 0
while True:
if not palindromic(i) and is_prime(i) and is_prime(reverse_num(i)):
print(i, end=' ') # i为回文素数时输出i，输出后不换行
count = count + 1
if count == number:
break
i = i + 1
if __name__ == "__main__":
n = int(input())
reverse_prime(n)
类型：函数
描述
数学领域著名的“哥德巴赫猜想”的大致意思是：任何一个大于2的偶数总能表示为两个素数之和。例如：24=5+19，其中5和19都是素数。本实验的任务是设计一个程序，验证20亿以内的偶数都可以分解成两个素数之和。输入一个大于2的正整数，当输入为偶数时，在一行中按照格式“N = p + q”输出N的素数分解，其中p 、 q均为素数且p ≤ q。因为这样的分解可能不唯一（例如24还可以分解为7+17），要求必须输出所有解中p最小的解。当输入为奇数时，输出'Data error!' 。
输入格式
输入一个大于2的正整数
输出格式
当输入为偶数时，按照格式“N = p + q”输出N的素数分解；当输入为奇数时，输出'Data error!' 。
示例
输入：36
输出：36 = 5 + 31
标准答案
def isPrime(n): #判断素数的函数
if n < 2:
return False #0和1不是素数
for i in range(2, n):
if n % i == 0:
return False
else:
return True
N = int(input()) #接收用户输入并转成整数
flag = False
if N % 2 == 0:
for i in range(N):
for j in range(N):
if isPrime(i) and isPrime(j) and i+j==N:
print("{} = {} + {}".format(N, i,N-i))
flag = True
break
if flag:
break
else:
print('Data error!')
'''
def isPrime(n): #判断素数的函数
if n < 2:
return False #0和1不是素数
for i in range(2, n):
if n % i == 0:
return False
else:
return True
N = int(input()) #接收用户输入并转成整数
if N % 2 == 0:
for i in range(N):
if isPrime(i) and isPrime(N - i) :
print("{} = {} + {}".format(N, i,N-i))
break
else:
print('Data error!')
'''
类型：函数
描述
侯先生每天都会爬楼梯锻炼身体，他爬楼梯的上跨步长有且仅有两种，或者一次上跨一级，或者一次上跨两级。
有一天侯先生想弄明白一个很难的问题：从最下面的平台开始到顶端的第n级一共有多少种走法呢？
例如n是2时，有两种走法：直接从平台上跨两步到第2级，或者从平台跨一步到1级再跨一步到第2级。
请你帮帮侯先生，给你n（1<=n<40）的值，你帮忙计算并输出有多少种爬到顶端的方法。
输入格式
输入n的值，n是1到40之间的整数。
输出格式
输出一共有多少种从平台到第n级台阶的走法。
输入输出示例：
示例1
输入:3
输出:3
示例2
输入:5
输出:8
标准答案
def upstrs(n):
if n==1:
return 1
elif n==2:
return 2
else:
return upstrs(n-1)+upstrs(n-2)
n=int(input())
print(upstrs(n))
类型：函数
描述
定义一个函数实现整数的幂运算，用以计算 x 的 n 次方。
输入格式
在一行内输入两个非负整数 x 和 n，数字间用空格分隔。
输出格式
x 的 n 次幂的运算结果
示例
输入：2 3
输出：8
标准答案
def power(x,n):
po=1
for i in range(n):
po=po*x
return po
x,n = map(int,input().split())
print(power(x,n))
类型：函数
描述
编写一个函数实现从 1 到 N 共 N 个数的累加
输入格式
一个正整数N
输出格式
计算结果
示例
输入：100
输出：5050
标准答案
def summ(n):
sum = 0
for i in range(1,n+1):
sum = sum + i
return sum
print(summ(int(input())))
类型：函数
描述
汉诺塔：汉诺塔（又称河内塔）问题是源于印度一个古老传说的益智玩具。大梵天创造世界的时候做了三根金刚石柱子，在一根柱子上从下往上按照大小顺序摞着64片黄金圆盘。大梵天命令婆罗门把圆盘从下面开始按大小顺序重新摆放在另一根柱子上。并且规定，在小圆盘上不能放大圆盘，在三根柱子之间一次只能移动一个圆盘。
柱子编号为a, b, c，将所有圆盘从a移到c可以描述为： 如果a只有一个圆盘，可以直接移动到c； 如果a有N个圆盘，可以看成a有1个圆盘（底盘） + (N-1)个圆盘，首先需要把 (N-1) 个圆盘移动到 b，然后，将 a的最后一个圆盘移动到c，再将b的(N-1)个圆盘移动到c。 请编写一个函数move(n, a, b, c) ，给定输入 n, a, b, c，打印出移动的步骤： 例如，输入 move(2, ‘A’, ‘B’, ‘C’)，打印出： A –> B A –> C B –> C
输入格式
有两行：
第一行一个正整数
第二行有三个符号，如A、B、C或a,b,c等，输入时用空格分隔开。
输出格式
移动过程的记录
示例
输入：
2
A B C
输出：
A --> B
A --> C
B --> C
标准答案
def hanoi_move(n, a, b, c):
"""接收一个表示圆盘数量的整数n和三个表示柱子的字符，打印输出把n个圆盘从第一个柱子移动到第三个柱子的过程。"""
if n == 1: # 终止条件，当只有一个圆盘时，从A移动到C后结束程序
print(a, '-->', c)
return None
else: # 递归调用，每调用一次圆盘次减少一个
hanoi_move(n - 1, a, c, b) # 首先需要把 (N-1) 个圆盘移动到 b
hanoi_move(1, a, b, c) # 将a的最后一个圆盘移动到c
hanoi_move(n - 1, b, a, c) # 再将b的(N-1)个圆盘移动到c
if __name__ == '__main__': # 使前面定义的函数可以被其他模块调用
num = int(input()) # 输入最初圆盘数量
s1, s2, s3 = input().split() # 输入表示柱子的字符，例如输入A B C
hanoi_move(num, s1, s2, s3) # 调用递归函数移动圆盘
类型：函数
描述
1179 能用 3 种方法表示为 3 个不同素数平方和的整数。
如：
1179 = 1717 + 1919 + 23*23
1179 = 77 + 1313 + 31*31
1179 = 77 + 1717 + 29*29
请输出能用 6 种方式表示为 3 个不同素数平方和的最小整数。
（本题涉及的最大素数不超过100）
输入格式
该题目没有输入
输出格式
输出能用 6 种方式表示为 3 个不同素数平方和的最小整数
输入输出示例
能用 3 种方法表示为 3 个不同素数平方和的最小的整数的输出形式如下，按相同规律输出本题结果：
示例
输出：1179
标准答案
# 先获取所有100以内的素数列表
# 再利用itertools中的 combinations可以快速获得所有不重复的3个素数的组合
# 再获得每组素数的平方和的列表,统计这个列表中每个数的出现次数,如果出现6次,便是题目答案
from itertools import combinations
def is_prime(n):
"""判断素数的函数,接收一个正整数为参数，参数是素数时返回True，否则返回False
减小判定区间，减少循环次数，提升效率"""
if n < 2:
return False # 0、1、负数以及偶数都不是素数
for i in range(2, int(n ** 0.5) + 1):
if n % i == 0: # 能被2到其n-1之间的数整除的数不是素数
return False
else:
return True # for循环正常结束，未遇到return的数是素数
def combine(ls_of_prime, n):
"""根据n获得列表中的所有可能组合（3个元素为一组）"""
comb_of_prime = []
for c in combinations(ls_of_prime, n):
comb_of_prime.append(c)
return comb_of_prime
def six_ways(comb_of_prime):
"""传入所有三个素数的组合列表，计算每个组合中的元素的平方和，产生新的列表，
遍历10000以下的整数，如果这个整数在列表中出现的次数为6次，那么便是最小的、
可以有6 种表示方法表示为3个素数平方和的那个数"""
result = [sum((c[0] ** 2, c[1] ** 2, c[2] ** 2)) for c in comb_of_prime]
for i in range(10000):
if result.count(i) == 6: # 统计当前数字在列表中出现的次数
return i
if __name__ == '__main__':
lsOfPrime = [i for i in range(100) if is_prime(i)]
combOfPrime = combine(lsOfPrime, 3)
print(six_ways(combOfPrime))
# 也可以直接求解,但效率较低
def is_prime(n):
# """判断素数的函数,接收一个正整数为参数，参数是素数时返回True，否则返回False
# 减小判定区间，减少循环次数，提升效率"""
# if n < 2:
# return False # 0、1、负数以及偶数都不是素数
# for i in range(2, int(n ** 0.5) + 1):
# if n % i == 0: # 能被2到其n-1之间的数整除的数不是素数
# return False
# else:
# return True # for循环正常结束，未遇到return的数是素数
#
# def six_ways():
# i = 2
# while True:
# lsnew = [tuple(sorted(list((i, j, k, l)))) for j in ls for k in ls for l in ls if
# i == j * j + k * k + l * l and j != k and k != l and j != l]
# if len(set(lsnew)) == 6: # 若列表中不重复的元素有6个，则找到答案
# return i
# else:
# i = i + 1
#
#
# ls = [i for i in range(100) if is_prime(i)] # 为提升效率，先生成100以内素数列表
# print(six_ways())
类型：函数
描述
调用附件中的函数进行四则运算
输入格式
两个整数
输出格式
和
示例
输入：3 4
输出：7
标准答案
import cal
a,b = map(int,input().split())
print(cal.add(a,b))
类型：函数
描述
猴子第1天摘了一堆桃子吃了一半又多一个，第2天吃了剩下的一半又多一个，...，第10天早上时发现只有1个桃子了。问第1天摘了多少？
示例
输出：xxxx
标准答案
num = 1
for i in range(9):
num = (num + 1) * 2
print(num)
# def g(n):
# if n==10:
# return 1
# else:
# return 2*(g(n+1)+1)
# print(g(1))
类型：函数
描述
输入一个正整数n，把数字n分解成不能再分解因子的乘法，比如：8=222， 10 = 2*5，而不是 8 = 2 * 4 这种可以再分解的。
输入格式
输入一个正整数n
输出格式
输出包含所有因子的列表
示例
输入：12
输出：[2, 2, 3]
标准答案
def defactor(N): # 定义一个函数名称为defactor，意义是返回N的所有因子
for i in range(2,N): #从2开始试试
if N % i ==0: # 如果试到 i 是 N 的因子的话，就返回i的所有因子和N/i的所有因子 的列表
return defactor(i)+defactor(int(N/i)) # 拼接 列表 + 列表
else: # 如果没有试到就说明这个N是一个质数，就直接包含它的 列表
return [N] # 返回列表
if __name__ == '__main__':
n = int(input())
print(defactor(n))
类型：函数
描述
输入一个正整数n，统计从[0,n]之间的最大的10个素数之和。本题保证测试用例至少有10个满足条件的素数。
例如：输入31 ，应求得3，5，7，11，13，17，19，23，29，31之和。
本题要求使用自定义函数完成，代码框架参考如下：
def isprime(n): #判断素数函数
......
def f(n): #找小于n的素数并求和
......
......
p=int(input())
print(f(p))
示例
输入：31
输出：158
标准答案
def isprime(n):
for i in range(2,int(n**0.5)+1):
if n%i==0:
return False
else:
return True
def f(n):
sumPrime,count=0,0
for i in range(n,1,-1):
if isprime(i):
sumPrime = sumPrime + i
count = count + 1
if count == 10:
return sumPrime
num = int(input())
print(f(num))
类型：函数
描述
输入一个完全由数字字符组成的字符串s，分别统计其中出现的奇数和偶数字符数值之和
如输入‘123456789’
输出 oddsum=25,evensum=20
本题需要使用自定义函数完成，建议代码框架如下：
def f(n):
......
def p(t):
......
def .......
s=input()
print('oddsum={},evensum={}'.format(......))
示例
输入：123456789
输出：oddsum=25,evensum=20
标准答案
def f(n): #奇偶函数
if n%2==0:
return 0
return 1
def p(t): #奇数求和
j=0
for i in t:
if f(int(i))==1:
j+=int(i)
return j
def q(t): #偶数求和
j=0
for i in t:
if f(int(i))==0:
j+=int(i)
return j
s=input()
print('oddsum={},evensum={}'.format(p(s),q(s)))
类型：函数
描述
在两行中分别输入一个字符串s和整数n，定义一个函数将字符串s循环向右移动n位，n为负数时左移。
若s为空字符串''，则不论n为多少，均输出空字符串''。
如 s='123456' n=3
输出结果：456123
代码框架如下：
def f(s,n):
......
s=input()
n=int(input())
print(f(s,n))
示例
输入：
123456
2
输出：
561234
标准答案
def f(s,n):
p=''
if s=='':
return p
t=(len(s)-n)%len(s)
p=s[t:]
p+=s[:t]
return p
s=input()
n=int(input())
print(f(s,n))
'''def f(s,n):
p=''
if s=='':
return p
if n>=0:
t=len(s)-n%len(s)
else:
t=abs(n)%len(s)
p=s[t:]
p+=s[:t]
return p
s=input()
n=int(input())
print(f(s,n))
'''
类型：函数
描述
小明是一个汽车迷，看到什么汽车马上就可以说出汽车的生产年份、型号和品牌。定义一个函数，可以输出汽车的介绍。
例如输入：
2020 AMG_S65 奔驰
可以输出：
这是一辆2020年生产，型号是AMG_S65的奔驰牌汽车
要求函数具有以下功能：当用户只输入生产年份、型号时，品牌按“宝马”输出。
输入格式
输入用空格分隔的年、型号和品牌（品牌可能没有）
输出格式
这是一辆年生产，型号是的牌汽车（根据用户输入进行替换）
示例
输入：2020 AMG_S65 奔驰
输出：这是一辆2020年生产，型号是AMG_S65的奔驰牌汽车。
标准答案
# 2020 AMG_S65 奔驰
# 2019 745li
# 2018 760 宝马
def car(year,model,brand = '宝马'):
return f'这是一辆{year}年生产，型号是{model}的{brand}牌汽车。'
ls = input().split()
print(car(*ls))
类型：函数
描述
一个不含0的数，如果它能被它的每一位除尽，则它是一个自除数。例如128是一个自除数，因为128能被1、2、8整除。编写函数selfDivisor(num)判断num是否为自除数，使用该函数输出不大于N的所有自除数。
（注意，含有数字0的数不是自除数）
输入格式
输入为一行，一个正整数N（N>=1）。
输出格式
输出为一行，是不大于N的所有自除数，每个数后面有一个空格。
示例 1
输入：1
输出：1
示例 2
输入：22
输出：1 2 3 4 5 6 7 8 9 11 12 15 22
标准答案
def selfDivisor(num):
if '0' in str(num):
return False # 包含数字0的不是自除数
for c in str(num): # 对数字num中的每位数字进行遍历
if num % int(c) != 0: # 测试num的每一位是否是num的因子
return False # 如果存在不能整除的数，则不是自除数
else: # 如果for遍历顺利结束，未遇到return，则执行else子句，返回True
return True
n=int(input())
for num in range(1,n+1): # 注意不大于包括等于n
if selfDivisor(num): # 调用函数，当返回值为True时，该数为自除数，输出这个数
print(num,end=' ') # 输出以空格结尾
类型：函数
描述
已知华氏温度转换摄氏温度的计算公式：C=5×(F−32)/9，其中：C表示摄氏温度，F表示华氏温度。
编写函数F2C(f)将华氏温度转换为摄氏温度，读入两个华氏温度值f1和f2，打印范围在f1~f2内，每次增加两个华氏温度刻度的速查表。
注意：如果f1>f2，则直接打印error。
输入格式
输入为一行，为两个不小于32的正整数f1和f2，表示两个华氏温度。两个数之间用逗号隔开，形如f1,f2。
输出格式
如果f1>f2，输出error。
如果f1<=f2，则输出华氏转摄氏的温度转换速查表，速查表可能有多行，每行一个温度转换对，形如f1 : c1，其中c1保留小数点两位。速查表以2华氏度为刻度。
示例1
输入：86,44
输出：error
示例 2
输入：32,32
输出：32 : 0.00
示例 3
输入：44,45
输出：44 : 6.67
示例 4
输入：44,46
输出：
44 : 6.67
46 : 7.78
示例 5
输入：60,73
输出：
60 : 15.56
62 : 16.67
64 : 17.78
66 : 18.89
68 : 20.00
70 : 21.11
72 : 22.22
标准答案
def F2C(f):
c=5*(f-32)/9
return c
left,right=map(int,input().split(','))
if left>right:
print('error')
else:
for f in range(left,right+1,2):
print("{} : {:.2f}".format(f,F2C(f)))
类型：函数
描述
输入一个包含多个单词的英文句子，单词间以空格分隔，标点符号后跟一个空格。定义一个函数，功能是用指定的符号把单词连接起来。
输入格式
第一行输入一个英文句子
第二行输入一个符号
输出格式
用符号连接起来的单词
示例
输入：
a string can be split on a delimiter.
-
输出：
a-string-can-be-split-on-a-delimiter.
标准答案
def split_and_join(line,sign):
return sign.join(line.split())
# 以下代码请勿改动
if __name__ == '__main__':
line = input()
sign = input()
result = split_and_join(line,sign)
print(result)
类型：函数
描述
定义一个函数来判断单词m是否可以由字符串n中出现的字母来组成。
本题保证字符串中出现的字母均为小写字母，且不考虑n中的字母使用次数
在两行中分别输入两个字符串m,n
如果m,n 满足条件，则输出’FOUND‘ ，否则输出'NOT FOUND'
如果输入的m包含有除字母外的其他字符，输出’ERROR‘结束
示例 1
输入：
word
world
输出：
FOUND
示例 2
输入：
1a3e
输出：
ERROR
示例 3
输入：
at
bcda
输出：
NOT FOUND
标准答案
def f(m,n):
for i in m:
if i not in n:
return 'NOT FOUND'
return 'FOUND'
m=input()
if m.isalpha():
n=input()
print(f(m,n))
else:
print('ERROR')
类型：函数
描述
商品价格每天都在变化，作为一个商人，需要低买高卖赚取利润，通常会根据历史数据，检验策略的收益。
已知有一个商品历史价格变化列表。其中第 i 个元素是第 i 天该商品的价格。
现在使用的贪心策略是在该过程中要求必须尽可能多的进行获利的交易，并且每次买入时都要先清仓（全部卖出上一次买入的商品），不能同时进行多笔交易。
定义一个函数，计算你在这种策略下能获取的最大利润。
比如价格列表为 [1,3,5,1,8]，利润最大为11元，
第1天买入，第2天卖出 获利3-1=2元
第2天买入，第3天卖出 获利5-3=2元
第4天价格跌落，所以第三天无交易
第4天买入，第5天卖出 获利8-1=7元
总利润为 2+2+7=11元
本题的编程模板会帮助你建立一个随机的价格列表（价格在1-100元的闭区间中），你需要在两行中各输入一个整数，第一行输入一个可交易的总天数（即列表中的价格个数），第二行输入一个整数做为随机种子。
输出时模板会在两行中分别输出生成的价格列表以及能获取的最大利润。
提示：列表的索引使用方式与字符串相同。
输入格式
在两行输入中各输入一个整数
输出格式
生成的价格列表
获取的最大利润
示例
输入：
10
6
输出：
[74, 11, 63, 98, 34, 5, 1, 19, 85, 76]
171
标准答案
import random
def f(prices):
s=0
for i in range(len(prices)-1): #此处注意不要越界
if prices[i]<prices[i+1]:
s+=prices[i+1]-prices[i]
return s
n=int(input())
random.seed(int(input()))
ls=[]
for i in range(0,n):
ls.append(random.randint(1,100))
print(ls)
print(f(ls))
类型：函数
描述
定义一个函数来判断单词m是否可以由字符串n中出现的字母来组成。
本题保证字符串中出现的字母均为小写字母，n中的字母只能使用一次。
在两行中分别输入两个字符串m,n
如果m,n 满足条件，则输出’FOUND‘ ，否则输出'NOT FOUND'
如果输入的m包含有除字母外的其他字符，输出’ERROR‘结束
示例 1
输入：
word
world
输出：
FOUND
示例 2
输入：
1a3e
输出：
ERROR
示例 3
输入：
at
bcda
输出：
NOT FOUND
示例 4
输入：
hello
heol
输出：
NOT FOUND
标准答案
def f(m,n):
for i in m:
if n.count(i)>0:
n=n.replace(i,'',1)
else:
return 'NOT FOUND'
return 'FOUND'
m=input()
if m.isalpha():
n=input()
print(f(m,n))
else:
print('ERROR')
类型：函数
描述
素数或称质数，是指一个大于1的整数，除1和它本身外，不能被其他的正整数所整除。 素数判定方法是： 先用一定的方法枚举正整数n所有可能的真因子，并验证每个枚举的数是否为真因子。若是，则停止枚举，确定n为合数；若枚举完也没发现真因子，可确定n为素数。完成以下函数的定义并按要求完成问题：
- 定义素数函数is_ prime(n) 将素数的判定代码定义为一个函数，接受用户输入的正整数n，返回n是否是素数，n为素数时返回True，不是素数时返回False。 一个整数若可以进行因数分解，那么分解时得到的两个数一定是一个小于等于sqrt(n)，一个大于等于sqrt(n)，所以对于每个数n，并不需要从2判断到n-1，只需要遍历到sqrt(n)即可。因为若sqrt(n)左侧找不到因数，那么右侧也一定找不到因数,这样可以显著提升算法的效率。
- 定义一个函数output_prime(n)，接受一个正整数number为参数，在函数中调用问题1中定义的判定素数函数，对不大于number的整数一一判定，在同一行中输出不大于n的全部素数。此函数无返回值，直接输出找到的素数。 调用all_prime(n)函数前，先接收用户输入的一个正整数，作为函数调用时的参数。
- 定义寻找回文素数函数 回文是指数或者字符串具有首尾回环性质，从后向前按位颠倒后与原文一样。首尾回环的数字就是回文数，如：12321；首尾回环的字符串就是回文串，如：'上海自来水来自海上'。 如果一个整数是素数，同时，其对应的字符串是回文字符串时，便称其为回文素数。 编写一个函数，调用前面定义好的素数判定函数和题目给定的回文判定函数完成回文素数的判定，函数无返回值，直接输出找到的回文素数。 输入一个正整数，输出小于这个数的所有回文素数。
- 寻找反素数 反素数是指一个将其逆向拼写后也是一个素数的非回文数。例如：17和71都是素数且均不是回文数，所以17和71都是反素数。 输入一个正整数n，按从小到大顺序输出所有反素数。
- 哥德巴赫猜想 1742年，哥德巴赫给欧拉的信中提出了以下猜想“任意一个大于2的整数都可写成三个质数之和”。常见的猜想陈述为欧拉的版本，即任意一个大于2的偶数都可写成两个素数之和，亦称为“强哥德巴赫猜想”或“关于偶数的哥德巴赫猜想”。 编写函数，接收一个大于2的偶数，输出两个素数，并且两个素数之和等于原来的偶数，如果有多个不同组合，则全部输出。若输入的数不是大于2的偶数，输出'Data error!'
输入输出
问题1 如果输入'素数'，再输入一个正整数n，按从小到大顺序输出不大于n的所有素数。
问题2 如果输入'回文素数'，再输入一个正整数n，按从小到大顺序输出小于n的所有回文素数。
问题3 如果输入'反素数'，再输入一个正整数n，输入一个正整数n，按从小到大顺序输出小于n的所有反素数。
问题4 如果输入'哥德巴赫猜想'，接收一个大于2的偶数，输出两个素数，并且两个素数之和等于原来的偶数，如果有多个不同组合，则全部输出，格式参考下面的示例。若输入的数不是大于2的偶数，输出'Data error!'
如果输入不是以上字符串，输出'输入错误'。
示例 1
输入：
素数
100
输出：
2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97
示例2
输入：
回文素数
200
输出：
2 3 5 7 11 101 131 151 181 191
示例3
输入：
反素数
200
输出：
13 17 31 37 71 73 79 97 107 113 149 157 167 179 199
示例4
输入：
哥德巴赫猜想
30
输出：
30=7+23
30=11+19
30=13+17
标准答案
def question_judge(question):
"""接收一个字符串为参数，根据参数判断问题类型"""
if question == '素数': # 如果输入”素数“，再输入一个正整数n，输出不大于n的所有素数
n = int(input())
output_prime(n) # 输出素数
elif question == '回文素数':
n = int(input())
palindromic_prime(n) # 输出回文素数
elif question == '反素数':
n = int(input())
reverse_prime(n) # 输出反素数
elif question == '哥德巴赫猜想':
n = int(input())
goldbach_conjecture(n)
else:
print('输入错误')
def is_prime(n):
"""判断素数的函数,接收一个正整数为参数，参数是素数时返回True，否则返回False
减小判定区间，减少循环次数，提升效率"""
if n < 2:
return False # 0、1、负数以及偶数都不是素数
for i in range(2, int(n ** 0.5) + 1):
if n % i == 0: # 能被2到其根号n之间的整数整除的数不是素数
return False
else:
return True # for循环正常结束，未遇到return的数是素数
def output_prime(number):
"""接收一个正整数为参数，遍历从0到number之间的所有整数
在一行中输出不大于number的所有素数，函数无返回值"""
for i in range(number + 1): # 遍历小于n的整数
if is_prime(i): # i为素数时输出i
print(i, end=' ') # 输出后不换行，空格分隔输出
def palindromic(num):
"""接收一个数字为参数，判定其是否为回文数，返回布尔值。"""
if str(num) == str(num)[::-1]:
return True
else:
return False
def palindromic_prime(number):
"""接收一个正整数参数number，遍历从0到number之间的所有整数，
若某个数是素数，且转为字符串后是回文字符串，则称其中回文素数
找出并在同一行中从小到大输出小于number的所有回文素数，各数字间用一个空格分隔，
函数无返回值"""
for i in range(number): # 遍历小于n的整数
if palindromic(i) and is_prime(i):
print(i, end=' ') # i为回文素数时输出i，输出后不换行
def reverse_num(num):
"""接收一个整数，返回其逆序字符串对应的整数"""
return int(str(num)[::-1])
def reverse_prime(number):
"""接收一个正整数参数，找出并在同一行内输出所有小于number的反素数，数字间用一个空格分隔。
反素数指某数i及其逆序数都是素数，但数i对应的字符串不是回文字符串
函数无返回值"""
for i in range(number): # 遍历小于n的整数
if not palindromic(i) and is_prime(i) and is_prime(reverse_num(i)):
print(i, end=' ') # i为回文素数时输出i，输出后不换行
def goldbach_conjecture(num):
""" 哥德巴赫猜想, 接收一个不小于4的正整数为参数。
当参数为不小于4的偶数时，将其分解为两个素数的加和，按小数+数的格式输出。
有多种组合时全部输出，但不输出重复的组合，例如输出8=3+5，不输出8=5+3。
参数为奇数或小于4时，输出'Data error!'
"""
if num % 2 == 0 and num >= 4: # 只判定偶数
for i in range(num // 2+1): # 超过num // 2的组合为重复组合
if is_prime(i) and is_prime(num - i):
print(f"{num}={i}+{num-i}")
else:
print('Data error!')
if __name__ == '__main__':
problems = input()
question_judge(problems)
类型：函数
描述
输入一个8位数表示的年月日，读出月份数字并输出该月有多少天。
输入格式
输入一个8位的表示年月日的字符串
输出格式
该月的天数
示例
输入：20000219
输出：29
标准答案
# 输出**月有多少天
def is_leap(year):
if year % 400 == 0 or (year % 4 == 0 and year % 100 != 0):
return True
else:
return False
def days_of_month(date_str):
year = int(date_str[:4])
month = int(date_str[4:6])
if month in [1, 3, 5, 7, 8, 10, 12]:
return 31
elif month in [4, 6, 9, 11]:
return 30
elif month == 2 and is_leap(year):
return 29
else:
return 28
if __name__ == '__main__':
date_in = input() # 输入一个年月日
print(days_of_month(date_in))