Python123题库—07函数

1. 判断素数函数

类型: 函数

描述‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

写一个函数isPrime(n)用于判断一个数字n是不是素数,用户输入一个正整数,在一行内输出不大于该数的所有素数,各数后面用一个空格分隔。‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

输入格式‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

输入正整数‪‬‮‬‪‬‫‬‪‬‮‬‪‬‮‬‪‬‫‬‪‬‮‬‪‬‮‬‭‬‪‬‪‬‮‬‫‬‪‬

[En]

Enter a positive integer ‪‬‮‬‪‬‫‬‪‬‮‬‪‬‮‬‪‬‫‬‪‬‮‬‪‬‮‬‭‬‪‬‪‬‮‬‫‬‪‬

输出格式‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

所有不大于该数字的素数都用空格隔开。‪‬‮‬‪‬‫‬‪‬‮‬‪‬‮‬‪‬‫‬‪‬‮‬‪‬‮‬‭‬‪‬‪‬‮‬‫‬‪‬

[En]

All primes that are not greater than that number are separated by a space. ‪‬‮‬‪‬‫‬‪‬‮‬‪‬‮‬‪‬‫‬‪‬‮‬‪‬‮‬‭‬‪‬‪‬‮‬‫‬‪‬

输入: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=' ')  #在同一行内输出结果,不换行,中间用空格分隔

2. 二分法求平方根

类型: 函数

描述‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

设计一个用二分法计算一个大于或等于 1 的实数 n 的平方根的函数sqrt_binary(n),计算精度控制在计算结果的平方与输入的误差不大于1e-6。‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

注:初始区间取[0,n]‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

输入格式‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

输入一个实数 n(大于或等于1)‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

输出格式‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

第一行输出由自行设计的函数‪‬‮‬‪‬‫‬‪‬‮‬‪‬‮‬‪‬‫‬‪‬‮‬‪‬‮‬‭‬‪计算出的平方根‬‪‬‮‬‫‬‪‬

[En]

The first line outputs the square root ‪‬‮‬‪‬‫‬‪‬‮‬‪‬‮‬‪‬‫‬‪‬‮‬‪‬‮‬‭‬‪ calculated by the self-designed function ‬‪‬‮‬‫‬‪‬

第二行输出用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)=0:
    print(sqrt_binary(num))
    print(math.sqrt(num))
else:
    print('请输入一个非负数!')

3. 二分法求平方根B

类型: 函数

描述‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

设计一个用二分法计算一个大于或等于 0 的实数 n 的平方根的函数sqrt_binary(n),实数 n和计算精度控制由用户在同一行内输入,用逗号进行分隔,输出结果保留8位小数。当(abs(x * x – n) )小于或等于设定的精度时,近似认为 x * x == n。‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

注:初始区间取[0,n+0.25]‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

输入格式‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

在同 行内输入一个实数 n(大于或等于0)和一个代表精度的数字(可用1e-m格式输入),逗号间隔‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

输出格式‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

第一行输出由自行设计的函数‪‬‮‬‪‬‫‬‪‬‮‬‪‬‮‬‪‬‫‬‪‬‮‬‪‬‮‬‭‬‪计算出的平方根‬‪‬‮‬‫‬‪‬

[En]

The first line outputs the square root ‪‬‮‬‪‬‫‬‪‬‮‬‪‬‮‬‪‬‫‬‪‬‮‬‪‬‮‬‭‬‪ calculated by the self-designed function ‬‪‬‮‬‫‬‪‬

第二行输出用math库开平方函数计算得到的平方根‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

输入:5.0,1e-7
输出:
2.23606796
2.23606798

标准答案

import math

def sqrt_binary(num, accuracy):
    """接收一个浮点数num和一个表示计算精度的浮点数accuracy为参数,用二分法计算浮点数的平方根x,
    当 abs(x * x - num)

4. 计算ID号

类型: 函数

描述‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

我的微信ID是大写字母WHUT后面的数字是两个素数连在一起,大的在前,小的在后,如果我告诉你两数的乘积是多少,你能计算出我的ID号吗?‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

如果输入一个[0-9]之间的数字,你能统计出从1开始到我ID中的数字的序列里,一共出现多少次这个数字吗?‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

输入格式‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

第一行输入ID中两个素数的乘积‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

第二行输入一个[0-9]之间的数字‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

输出格式‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

第一行输出ID号‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

第二行输出数字‪‬‮‬‪‬‫‬‪‬‮‬‪‬‮‬‪‬‫‬‪‬‮‬‪‬‮‬‭‬‪‬‪‬‮‬‫‬‪‬的次数

[En]

The number of times the second line outputs digits ‪‬‮‬‪‬‫‬‪‬‮‬‪‬‮‬‪‬‫‬‪‬‮‬‪‬‮‬‭‬‪‬‪‬‮‬‫‬‪‬

输入和输出示例‪‬‮‬‪‬‫‬‪‬‮‬‪‬‮‬‪‬‫‬‪‬‮‬‪‬‮‬‭‬‪‬‪‬‮‬‫‬‪‬

[En]

Input and output sample ‪‬‮‬‪‬‫‬‪‬‮‬‪‬‮‬‪‬‫‬‪‬‮‬‪‬‮‬‭‬‪‬‪‬‮‬‫‬‪‬

输入:
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)

5. 回文素数

类型: 函数

描述‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

回文素数是指一个数既是素数又是回文数。例如,131,既是素数又是回文数。 用户输入一个正整数 n , 请你在一行内输出从小到大排列的的前n个回文素数,数字后面用一个空格进行分隔。‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

输入格式‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

输入正整数‪‬‮‬‪‬‫‬‪‬‮‬‪‬‮‬‪‬‫‬‪‬‮‬‪‬‮‬‭‬‪‬‪‬‮‬‫‬‪‬

[En]

Enter a positive integer ‪‬‮‬‪‬‫‬‪‬‮‬‪‬‮‬‪‬‫‬‪‬‮‬‪‬‮‬‭‬‪‬‪‬‮‬‫‬‪‬

输出格式‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

符合‪‬‮‬‪‬‫‬‪‬‮‬‪‬‮‬‪‬‫‬‪‬‮‬‪‬‮‬‭‬‪‬‪‬‮‬‫‬‪‬要求的回文

[En]

Palindromes that meet the requirements ‪‬‮‬‪‬‫‬‪‬‮‬‪‬‮‬‪‬‫‬‪‬‮‬‪‬‮‬‭‬‪‬‪‬‮‬‫‬‪‬

输入: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)

6. 反素数

类型: 函数

描述‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

反素数(逆向拼写的素数)是指一个将其逆向拼写后也是一个素数的非回文数。
例如:
13和31都是素数,且13和31都不是回文数,所以,13和31是反素数。
输入一个正整数 n , 请在同一行输出从小到大排列的的前n个反素数,每个数字后面加一个空格。‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

输入格式‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

输入正整数‪‬‮‬‪‬‫‬‪‬‮‬‪‬‮‬‪‬‫‬‪‬‮‬‪‬‮‬‭‬‪‬‪‬‮‬‫‬‪‬

[En]

Enter a positive integer ‪‬‮‬‪‬‫‬‪‬‮‬‪‬‮‬‪‬‫‬‪‬‮‬‪‬‮‬‭‬‪‬‪‬‮‬‫‬‪‬

输出格式‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

满足条件的逆素数的‪‬‮‬‪‬‫‬‪‬‮‬‪‬‮‬‪‬‫‬‪‬‮‬‪‬‮‬‭‬‪‬‪‬‮‬‫‬‪‬

[En]

‪‬‮‬‪‬‫‬‪‬‮‬‪‬‮‬‪‬‫‬‪‬‮‬‪‬‮‬‭‬‪‬‪‬‮‬‫‬‪‬ of inverse primes that meet the conditions

输入:
10
输出:
13 17 31 37 71 73 79 97 107 113

标准答案

def is_prime(n):
    if n

7. 哥德巴赫猜想

类型: 函数

描述‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

数学领域著名的”哥德巴赫猜想”的大致意思是:任何一个大于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!')
'''

8. 侯先生爬楼梯

类型: 函数

描述‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

侯先生每天爬楼梯锻炼身体。他爬楼梯只有两种台阶,要么一次走一步,要么一次走两步。‪‬‮‬‪‬‫‬‪‬‮‬‪‬‮‬‪‬‫‬‪‬‮‬‪‬‮‬‭‬‪‬‪‬‮‬‫‬‪‬

[En]

Mr. Hou climbs stairs for exercise every day. There are only two kinds of steps for him to climb stairs, either one step at a time, or two steps at a time. ‪‬‮‬‪‬‫‬‪‬‮‬‪‬‮‬‪‬‫‬‪‬‮‬‪‬‮‬‭‬‪‬‪‬‮‬‫‬‪‬

有一天侯先生想弄明白一个很难的问题:从最下面的平台开始到顶端的第n级一共有多少种走法呢?‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

例如n是2时,有两种走法:直接从平台上跨两步到第2级,或者从平台跨一步到1级再跨一步到第2级。‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

请你帮帮侯先生,给你n(1

Original: https://www.cnblogs.com/leezStudy/p/16410244.html
Author: CV攻城狮~
Title: Python123题库—07函数

原创文章受到原创版权保护。转载请注明出处:https://www.johngo689.com/499221/

转载文章受原作者版权保护。转载请注明原作者出处!

(0)

大家都在看

亲爱的 Coder【最近整理,可免费获取】👉 最新必读书单  | 👏 面试题下载  | 🌎 免费的AI知识星球