07函数
1. 判断素数函数
类型：函数
描述
写一个函数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('请输入一个非负数！')
类型：函数
描述
回文素数是指一个数既是素数又是回文数。例如，131，既是素数又是回文数。 用户输入一个正整数 n , 请你在一行内输出从小到大排列的的前n个回文素数，数字后面用一个空格进行分隔。
输入格式
输入一个正整数
输出格式
符合要求的回文素数
示例- 输入：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()计算平方根
类型：函数
描述
反素数(逆向拼写的素数)是指一个将其逆向拼写后也是一个素数的非回文数。
例如：
13和31都是素数，且13和31都不是回文数，所以，13和31是反素数。
输入一个正整数 n , 请在同一行输出从小到大排列的的前n个反素数，每个数字后面加一个空格。
输入格式
输入一个正整数
输出格式
符合条件的反素数
示例- 输入：
- 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)
- 输入：10
- 输出：2 3 5 7 11 101 131 151 181 191
类型：函数
描述
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 个不同素数平方和的最小的整数的输出形式如下，按相同规律输出本题结果：
示例- 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)
- 输入：
- 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)
类型：函数
描述
猴子第1天摘了一堆桃子吃了一半又多一个，第2天吃了剩下的一半又多一个，...，第10天早上时发现只有1个桃子了。问第1天摘了多少？
示例- 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分解成不能再分解因子的乘法，比如：8=222， 10 = 2*5，而不是 8 = 2 * 4 这种可以再分解的。
输入格式
输入一个正整数n
输出格式
输出包含所有因子的列表
示例标准答案- 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))
类型：函数
描述
输入一个正整数n，统计从[0,n]之间的最大的10个素数之和。本题保证测试用例至少有10个满足条件的素数。
例如：输入31 ，应求得3，5，7，11，13，17，19，23，29，31之和。
本题要求使用自定义函数完成，代码框架参考如下：示例- 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))
类型：函数
描述
输入一个完全由数字字符组成的字符串s，分别统计其中出现的奇数和偶数字符数值之和
如输入‘123456789’
输出 oddsum=25,evensum=20
本题需要使用自定义函数完成，建议代码框架如下：- def summ(n):
- sum = 0
- for i in range(1,n+1):
- sum = sum + i
- return sum
- print(summ(int(input())))
- 输入：
- 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) # 调用递归函数移动圆盘
类型：函数
描述
在两行中分别输入一个字符串s和整数n，定义一个函数将字符串s循环向右移动n位，n为负数时左移。
若s为空字符串''，则不论n为多少，均输出空字符串''。
如 s='123456' n=3
输出结果：456123
代码框架如下：示例- # 先获取所有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())
类型：函数
描述
小明是一个汽车迷，看到什么汽车马上就可以说出汽车的生产年份、型号和品牌。定义一个函数，可以输出汽车的介绍。
例如输入：
2020 AMG_S65 奔驰
可以输出：
这是一辆2020年生产，型号是AMG_S65的奔驰牌汽车
要求函数具有以下功能：当用户只输入生产年份、型号时，品牌按“宝马”输出。
输入格式
输入用空格分隔的年、型号和品牌（品牌可能没有）
输出格式
这是一辆年生产，型号是的牌汽车（根据用户输入进行替换）
示例- import cal
- a,b = map(int,input().split())
- print(cal.add(a,b))
类型：函数
描述
一个不含0的数，如果它能被它的每一位除尽，则它是一个自除数。例如128是一个自除数，因为128能被1、2、8整除。编写函数selfDivisor(num)判断num是否为自除数，使用该函数输出不大于N的所有自除数。
（注意，含有数字0的数不是自除数）
输入格式
输入为一行，一个正整数N（N>=1）。
输出格式
输出为一行，是不大于N的所有自除数，每个数后面有一个空格。
示例 1- 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))
- 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))
类型：函数
描述
已知华氏温度转换摄氏温度的计算公式：C=5×(F−32)/9，其中：C表示摄氏温度，F表示华氏温度。
编写函数F2C(f)将华氏温度转换为摄氏温度，读入两个华氏温度值f1和f2，打印范围在f1~f2内，每次增加两个华氏温度刻度的速查表。
注意：如果f1>f2，则直接打印error。
输入格式
输入为一行，为两个不小于32的正整数f1和f2，表示两个华氏温度。两个数之间用逗号隔开，形如f1,f2。
输出格式
如果f1>f2，输出error。
如果f1right: print('error')else: for f in range(left,right+1,2): print("{} : {:.2f}".format(f,F2C(f)))[/code]22. 字符串切分连接
类型：函数
描述
输入一个包含多个单词的英文句子，单词间以空格分隔，标点符号后跟一个空格。定义一个函数，功能是用指定的符号把单词连接起来。
输入格式
第一行输入一个英文句子
第二行输入一个符号
输出格式
用符号连接起来的单词
示例- def isprime(n): #判断素数函数
- ......
- def f(n): #找小于n的素数并求和
- ......
- ......
- p=int(input())
- print(f(p))
类型：函数
描述
定义一个函数来判断单词m是否可以由字符串n中出现的字母来组成。
本题保证字符串中出现的字母均为小写字母，且不考虑n中的字母使用次数
在两行中分别输入两个字符串m,n
如果m,n 满足条件，则输出’FOUND‘ ，否则输出'NOT FOUND'
如果输入的m包含有除字母外的其他字符，输出’ERROR‘结束
示例 1- 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))
- 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)))
类型：函数
描述
商品价格每天都在变化，作为一个商人，需要低买高卖赚取利润，通常会根据历史数据，检验策略的收益。
已知有一个商品历史价格变化列表。其中第 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元的闭区间中），你需要在两行中各输入一个整数，第一行输入一个可交易的总天数（即列表中的价格个数），第二行输入一个整数做为随机种子。
输出时模板会在两行中分别输出生成的价格列表以及能获取的最大利润。
提示：列表的索引使用方式与字符串相同。
输入格式
在两行输入中各输入一个整数
输出格式
生成的价格列表
获取的最大利润
示例- def f(s,n):
- ......
- s=input()
- n=int(input())
- print(f(s,n))
类型：函数
描述
素数或称质数，是指一个大于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- 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 奔驰
- # 2019 745li
- # 2018 760 宝马
- def car(year,model,brand = '宝马'):
- return f'这是一辆{year}年生产，型号是{model}的{brand}牌汽车。'
- ls = input().split()
- print(car(*ls))
- 输入：22
- 输出：1 2 3 4 5 6 7 8 9 11 12 15 22
类型：函数
描述
输入一个8位数表示的年月日，读出月份数字并输出该月有多少天。
输入格式
输入一个8位的表示年月日的字符串
输出格式
该月的天数
示例- 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=' ') # 输出以空格结尾
|
