目录
Demo27 打印数字I
Demo28 打印数字II
Demo29 打印数字III
Demo30 打印菱形I
Demo31 打印菱形II
Demo32 打印菱形III
Demo33 猜数字
Demo34 最大公约数I
Demo35 判断素数
Demo36 最小公倍数
Demo37 整数的素因子
Demo38 完全数
Demo39 前50个素数
Demo40 计算π
Demo41 计算e
Demo42 剪刀石头布II
Demo43 组合问题I
Demo44 组合问题II
Demo45 水仙花数
Demo46 青蛙跳台阶
Demo47 堆叠相加
Demo48 十进制转二进制
Demo49 二进制转十进制
Demo50 十进制转十六进制
Demo51 十六进制转十进制
Demo52 最长公共前缀
Demo53 子串出现的次数
Demo54 最长公共子串
Demo55 检测密码
Demo56 回文素数
Demo57 反素数
Demo58 双素数
Demo59 梅森素数
Demo60 平方根的近似求法
Demo27 打印数字I
题目描述
利用循环，寻找规律，打印如下数字模式：
模式A
1
1 2
1 2 3
1 2 3 4
1 2 3 4 5
1 2 3 4 5 6
模式B
1 2 3 4 5 6
1 2 3 4 5
1 2 3 4
1 2 3
1 2
1
模式C
1
2 1
3 2 1
4 3 2 1
5 4 3 2 1
6 5 4 3 2 1
模式D
1 2 3 4 5 6
1 2 3 4 5
1 2 3 4
1 2 3
1 2
1
代码如下：
#模式Alayer = int(input("请输入你要输入的行数："))
for index in range(1, layer + 1 ):for j in range(1, index + 1):print(j, end = " ")print()#模式Blayer = int(input("请输入你要输入的行数："))
for index in range(layer + 1 ):for j in range(1, layer - index + 1):print(j, end = " ")print()#模式C
layer = int(input("请输入你要输入的行数："))for index in range(1, layer + 1):for j in range(layer, 0, -1):if j <= index:print(j, end=" ")else:print(" ", end=" ")print()# 模式Dlayer = int(input("请输入你要输入的行数："))for index in range(1, layer):for j in range(1, index):print(" ", end=" ")for k in range(1, layer - index + 2):print(k, end = " ")print()
Demo28 打印数字II
题目描述
利用循环，寻找规律，打印如下数字模式：
1
2 1 2
3 2 1 2 3
4 3 2 1 2 3 4
5 4 3 2 1 2 3 4 5
6 5 4 3 2 1 2 3 4 5 6
7 6 5 4 3 2 1 2 3 4 5 6 7
代码如下：
# 输入行数
rows = int(input("请输入行数："))# 外层循环控制行数
for i in range(1, rows+1):# 内层循环打印空格，根据行数和数字最大值来确定空格数量for j in range(rows-i):print(" ", end="")# 内层循环打印数字升序部分for k in range(i, 0, -1):print(k, end=" ")# 内层循环打印数字降序部分for l in range(2, i+1):print(l, end=" ")print() # 换行
Demo29 打印数字III
题目描述
利用循环，寻找规律，打印如下数字模式：
1
1 2 1
1 2 4 2 1
1 2 4 8 4 2 1
1 2 4 8 16 8 4 2 1
1 2 4 8 16 32 16 8 4 2 1
1 2 4 8 16 32 64 32 16 8 4 2 1
代码如下：
# 输入行数
rows = int(input("请输入行数："))# 外层循环控制行数
for i in range(rows):# 内层循环打印空格，根据行数和数字最大值来确定空格数量for j in range(rows - i - 1):print(" ", end="")# 内层循环打印左半部分数字for k in range(i + 1):num = 2 ** kprint("{:5d}".format(num), end="")# 内层循环打印右半部分数字for l in range(i, 0, -1):num = 2 ** (l - 1)print("{:5d}".format(num), end="")print() # 换行
Demo30 打印菱形I
题目描述
如下所示，是一个高度为9的菱形
*
* *
* * *
* * * *
* * * * *
* * * *
* * *
* *
*
用户输入菱形高度n，并打印出该高度下的菱形
输入输出描述
输入高度n，n为奇数
输出该高度的菱形
示例
输入：
5
输出：
*
* *
* * *
* *
*
代码如下:
# #打印实心菱形# 输入行数
rows = int(input("请输入行数："))# 上半部分阶梯
for i in range(1, rows+1):# 打印空格，根据行数和当前行来确定空格数量for j in range(rows-i):print(" ", end="")# 打印星号，每一行的星号数量等于当前行数for j in range(i):print("*", end=" ")print() # 换行# 下半部分阶梯
for i in range(rows-1, 0, -1):# 打印空格，根据行数和当前行来确定空格数量for j in range(rows-i):print(" ", end="")# 打印星号，每一行的星号数量等于当前行数for j in range(i):print("*", end=" ")print() # 换行
Demo31 打印菱形II
题目描述
如下所示，是一个高度为9的菱形
*
* *
* *
* *
* *
* *
* *
* *
*
用户输入菱形高度n，并打印出该高度下的菱形
输入输出描述
输入高度n，n为奇数
输出该高度的菱形
示例
输入：
5
输出：
*
* *
* *
* *
*
代码如下：
#打印空心菱形#控制台输入行数
layer = int(input("请输入你要输入的行数："))#判断是不是奇函数
while layer % 2 == 0:layer = int(input("请输入奇数行："))#打印上半部分
for i in range(1 , (layer // 2 + 2)):#打印空格for j in range(layer - i):print(" ", end = "")#打印星号（判断当前位置是否为首尾位置，如果是则打印星号，否则打印空格，）for j in range(2 * i - 1):if j == 0 or j == 2 * i - 2:print("*", end = "")else:print(" ", end = "")print()
#打印下半部分
for i in range(layer // 2, 0, -1):#打印空格for j in range(layer - i):print(" ", end = "")#打印星号（判断当前位置是否为首尾位置，如果是则打印星号，否则打印空格，）for j in range(2 * i - 1):if j == 0 or j == 2 * i - 2:print("*", end = "")else:print(" ", end = "")print()#换行Demo32 打印菱形III
题目描述
如下所示，是一个高度为9的菱形
*
***
*****
*******
*********
*******
*****
***
*
用户输入菱形高度n，并打印出该高度下的菱形
输入输出描述
输入高度n，n为奇数
输出该高度的菱形
示例
输入：
5
输出：
*
***
*****
***
*
代码如下：
#打印实心菱形
#输入行数layer = int(input("请输入你要输入的行数："))
#如果输入的行数是偶数，我们则要求重新输入
while layer % 2 == 0:layer = int(input("请输入奇数行："))
#打印上半部分的金字塔
for i in range(1 , (layer // 2 + 2)):
#打印空格，根据行数和当前的行数来确定空格的数量for j in range(layer - i):print(" ", end = "")#打印星号根据当前行数来确定星号数for j in range(2 * i - 1):print("*", end = "")print()# 打印下半部分的金字塔
for i in range(layer // 2, 0, -1):print(" ", end = "")#打印空格，根据行数和当前的行数来确定空格的数量for j in range(layer - i -1):print(" ", end = "")#打印星号根据当前行数来确定星号数for j in range(2 * i - 1):print("*", end = "")print() #换行Demo33 猜数字
题目描述
计算机随机生成一个[0,100]之间的整数，程序提示用户连续地输入数字直到它与那个随机生成的数字相同
对于用户输入的数字，程序会提示它是过高还是过低
输入输出描述
每次输入一个整数
每次输出该数字是过高还是过低，如果猜中则输出猜中的数字并结束
示例
输入：50
输出：高了
输入：25
输出：低了
输入：42
输出：高了
输入：39
输出：猜中了！答案就是39
代码如下：
import randomnum1 = random.randint(1, 100)while True:num2 = int(input("请输入你猜测的数字(1-100)："))if num2 > num1:print("高了")elif num2 < num1:print("低了")else:print(f"恭喜你，猜对了，答案就是{num2}")Demo34 最大公约数I
题目描述
输入两个正整数，计算其最大公约数，例如4和2的最大公约数是2，16和24的最大公约数是8
输入输出描述
输入两个数字
输出最大公约数
示例1
输入：
16 24
输出：
8
示例2
输入：
7 3
输出：
1
代码如下：
#短除法
num1, num2 = map(int, input("请依次输入两个正整数：").split(" "))
#初始的共约数为1
t = 1
for i in range(2, min(num1, num2)):#每次for循环迭代时，使用while循环判断两个数能不能被迭代变量整除while num1 % i ==0 and num2 % i ==0:t = t * inum1 = num1 / inum2 = num2 / iprint(f"最小公约数为{t}")#欧几里得算法num1, num2 = map(int, input("请依次输入两个正整数：").split(" "))
a = max(num1 , num2)
b = min(num1 , num2)
t = a % b
while t != 0:a = bb = tprint(f"最大的公约数:{b}")breakDemo35 判断素数
题目描述
一个大于1的整数如果只能被正整数1和它本身整除，则它就是素数，例如2、3、5和7都是素数，而4、6、8、9则不是
输入输出描述
输入一个大于1的正整数
输出Yes表示该数字是素数，否则输出No
示例1
输入：
9
输出：
No
示例2
输入：
11
输出：
Yes
代码如下：
def is_prime(n):if n <=1:return Falsefor i in range(2, int(n**1/2) + 1):if n % i == 0:return Falsereturn Truenum = int(input("请输入一个大于1的正整数："))if is_prime(num):print("YES")
else:print("NO")
Demo36 最小公倍数
题目描述
输入两个正整数，计算其最小公倍数，例如4和2的最小公倍数是4，3和5的最小公倍数是15
输入输出描述
输入两个正整数
输出最小公倍数
示例1
输入：
3 9
输出：
9
示例2
输入：
4 6
输出：
12
代码如下：
def find_lcm(x , y):if x > y:greater = xelse:greater = ywhile True:if greater % x==0 and greater % y ==0:lcm = greaterbreakgreater += 1return lcmnum1 , num2 = map(int, input("请依次输入两个整数：").split(" "))
lcm = find_lcm(num1 ,num2)
print(f"最小公倍数为：{lcm}")Demo37 整数的素因子
题目描述
输入一个正整数，然后找出它所有的最小因子，也称之为素因子
输入输出描述
输入一个正整数
输出多行，每行输出一个素因子
示例1
输入：
120
输出：
2 2 2 3 5
解释：
2 * 2 * 2 *3 * 5 = 120
示例2
输入：
100
输出：
2 2 5 5
代码如下：
def find_prime_factors(num):factors = []i = 2while i*i <= num:if num % i != 0:i += 1else:num = num // ifactors.append(i)if num > 1:factors.append(i)return factors
num = int(input("请输入一个正整数："))
prime_factors = find_prime_factors(num)
# for factors in prime_factors:
# print(f"输出素因子为:{factors}")
print(f"输出素因子为:{prime_factors}")
Demo38 完全数
题目描述
如果一个正整数等于除了它本身之外所有正因子的和，那么这个数称为完全数
例如 6 = 3 + 2 + 1，28 = 14 + 7 + 4 + 2 + 1
输入输出描述
输入一个正整数
输出该数是否为完全数
示例1
输入：
6
输出：
Yes
示例2
输入：
9
输出：
No
代码如下：
def is_perfect_number(num):factors = []for i in range(1, num):if num % i == 0:factors.append(i)sum_of_factors = sum(factors)if sum_of_factors == num:return "YES"else:return "NO"num = int(input("请输入一个正整数："))
print(is_perfect_number(num))
Demo39 前50个素数
题目描述
打印前50个素数，每打印10个素数换行
代码如下：
def is_prime(num):if num <= 1:return Falsefor i in range(2, int(num ** 1/2) + 1):if num % i == 0:return Falsereturn Truecount = 0
for num in range(1, 500):if is_prime(num):print(num, end = " ")count += 1if count % 10 ==0:print()if count >= 50:breakDemo40 计算π
题目描述
你可以使用下面的数列近似计算π
当i越大时，计算结果越近似于π
代码如下：
def approximate_pi(n):pi_approx = 0.0sign = 1for i in range(1, n + 1):term = sign / (2*i -1)pi_approx += termsign *= -1return 4 * pi_approxn = int(input("请输入你要迭代的次数："))
approximate = approximate_pi(n)
print(f"π的近似值为{approximate}")
Demo41 计算e
题目描述
你可以使用下面的数列近似计算e
当i越大时，计算结果越近似于e
代码如下：
import mathdef approximate_e(n):e_approx = 0.0factorial = 1for i in range(1, n):term = 1 / factoriale_approx += termfactorial *= (i + 1)return e_approx + 1
n = int(input("请输入你要迭代的次数："))
approximate = approximate_e(n)
print(f"e的近似值为：{approximate}")
print(f"e的真实值为：{math.e}")
Demo42 剪刀石头布II
题目描述
延伸【Demo21剪刀石头布I】的问题，利用循环将程序改为，计算机和电脑谁先赢三次，谁就是终极胜利者
代码如下：
import randomchoices = ["石头", "剪刀", "布"]
#choices = {"石头":0, "剪刀":1, "步":2}
player_score = 0
computer_score = 0while True:# 玩家进行选择player_choice = input("请出拳（石头、剪刀、布）：")# 随机生成计算机的选择computer_choice = random.choice(choices)# 判断胜负并更新分数if player_choice == computer_choice:print("平局！")elif (player_choice == "石头" and computer_choice == "剪刀") or \(player_choice == "剪刀" and computer_choice == "布") or \(player_choice == "布" and computer_choice == "石头"):print("你赢了！")player_score += 1else:print("你输了！")computer_score += 1# 显示当前分数print(f"当前分数：玩家 {player_score} - {computer_score} 计算机")if player_score == 3:print("玩家获胜！")breakif computer_score == 3:print("计算机获胜！")break# 询问是否继续游戏play_again = input("是否继续游戏？（输入 y 继续，其他任意键退出）：")if play_again.lower() != "y":breakprint("游戏结束！")
Demo43 组合问题I
题目描述
在数字范围[1,7]之间，任意选择两个不相同的数作为一个组合，输出每一组组合，并统计所有组合的个数
注：组合（a，b）与组合（b，a）算同一种组合，只记录一次
代码如下：
count = 0
for i in range(1, 8):for j in range(i + 1, 8):print(f"({i}, {j})")count += 1
print(f"有{count}种组合")Demo44 组合问题II
题目描述
有1、2、3、4这个四个数字，能组成多少个互不相同且无重复数字的三位数？分别又是多少？
代码如下：
count = 0
for i in range(1,5):for j in range(1, 5):for k in range(1, 5):if i != j and i != k and j != k:print(f"{i}{j}{k}")count += 1
print(f"有{count}种组合")Demo45 水仙花数
题目描述
水仙花数，是一个三位数，且这个数的个位、十位和百位的立方和等于该数字本身，例如$153=1^3+5^3+3^3$
编写程序，输出所有的水仙花数
代码如下：
for i in range(100,1000):a = i // 100b = i % 100 // 10c = i % 10if a ** 3 + b ** 3 + c ** 3 == i:print(f"水仙花数有：{i}")Demo46 青蛙跳台阶
题目描述
一只青蛙，一次可以跳一个台阶或者两个台阶，现有n个台阶，问该青蛙有多少种不同的跳法？
例如：两个台阶，有两种跳法（1+1，2）；四个台阶，有五种跳法（1+1+1+1，2+1+1，1+2+1，1+1+2，2+2）
代码如下：
def jum_ways(n):if n == 1:return 1elif n == 2:return 2else :return jum_ways(n - 1) + jum_ways(n - 2)n = int(input("请输入台阶数："))
print("不同的跳法数量为：")
print(jum_ways(n))Demo47 堆叠相加
题目描述
现有堆叠相加模式$a+aa+aaa+aaaa+aaaaa+......$
例如：$2+22+222+2222+22222$，其中a为2，且有5组数字
输入输出描述
输入两个数据分别为数字a和组数n
输出按照堆叠相加模式算出的和
示例
输入：
3 4
输出：
3702
解释：
3 + 33 + 333 + 3333 = 3702
代码如下：
def add_up(a, n):sum = 0num = afor i in range(n):sum += numnum = num * 10 + areturn sum a, n = map(int, input("请依次输入叠加的数字以及叠加的组数：").split(" "))
print("最终的总和为：")
print(add_up(a, n))
Demo48 十进制转二进制
题目描述
输入一个十进制正整数，输出其二进制形式
输入输出描述
输入一个十进制正整数
输出二进制字符串
示例
输入：
9
输出：
1001
代码如下：
def base_system_conversion(decimalism):binary =" "while decimalism > 0:remainder = decimalism % 2binary = str(remainder) + binarydecimalism = decimalism // 2return binary
decimalism = int(input("请输入你想转换的十进制："))
print(f"转换后的二进制为:{base_system_conversion(decimalism)}")Demo49 二进制转十进制
题目描述
输入一个二进制字符串，输出其对应的十进制数字
输入输出描述
输入一个二进制字符串
输出十进制数字
示例
输入：
1001
输出：
9
代码如下：
def base_system_conversion(binary):decimalism = 0binary_str = str(binary)binary_str = binary_str[::-1] for i in range(len(binary_str)):if binary_str[i] == '1':decimalism += 2 ** ireturn decimalismbinary_input = input("请输入你想转换的二进制：")
print(f"转换后的十进制为: {base_system_conversion(binary_input)}")
Demo50 十进制转十六进制
题目描述
输入一个十进制正整数，输出其十六进制形式
输入输出描述
输入一个十进制正整数
输出十六进制字符串
示例
输入：
1233321
输出：
1e1b9
代码如下：
def base_system_conversion(decimal):hexadecimal = ""while decimal > 0:remainder = decimal % 16if remainder < 10:hexadecimal = str(remainder) + hexadecimalelse:hexadecimal = chr(65 + remainder - 10) + hexadecimaldecimal = decimal // 16return hexadecimaldecimal = int(input("请输入你想转换的十进制："))
print(f"转换后的十六进制为: {base_system_conversion(decimal)}")Demo51 十六进制转十进制
题目描述
输入一个十六进制字符串，输出其对应的十进制数字
输入输出描述
输入一个十六进制字符串
输出十进制数字
示例
输入：
1e1b9
输出：
123321
代码如下：
def base_system_conversion(hexadecimal):decimal = 0power = len(hexadecimal) - 1for digit in hexadecimal:if digit.isdigit():decimal += int(digit) * (16 ** power)else:decimal += (ord(digit.upper()) - 55) * (16 ** power)power -= 1return decimalhexadecimal = input("请输入你想转换的十六进制：")
print(f"转换后的十进制为: {base_system_conversion(hexadecimal)}")
Demo52 最长公共前缀
题目描述
给定两个字符串 s1 和 s2 ，求两个字符串最长的公共前缀串，字符区分大小写
输入输出描述
输入两行，分别表示s1和s2
输出前缀串
示例
输入：
abcdefg
abcdhko
输出：
abcd
代码如下：
def common_prefixes(s1, s2):common_prefixes = " "if len(s1) < len(s2):n = len(s1)else:n = len(s2)L1 = list(s1)L2 = list(s2)for i in range(n):if L1[i] == L2[i]:common_prefixes = common_prefixes + L1[i]return common_prefixes
s1 = input("请输入s1的字符串：")
s2 = input("请输入s2的字符串：")
common_prefixes = common_prefixes(s1, s2)
print(f"公共的字符前缀为：{common_prefixes}")
Demo53 子串出现的次数
题目描述
给定两个字符串 s1 和 s2 ，求 s2 在 s1 中出现的次数，字符区分大小写，已匹配的字符不计入下一次匹配
输入输出描述
输入两行字符串，分别为s1和s2，s2的长度小于等于s1
输出s2在s1中出现的次数
示例1
输入：
ABCsdABsadABCasdhjabcsaABCasd
ABC
输出：
3
示例2
输入：
AAAAAAAA
AAA
输出：
2
代码如下：
def occurrence_number(s1, s2):total_degree = 0 # 初始化计数器为0i = 0 # 设置字符串s1的索引i为0while i < len(s1) - len(s2) + 1: # 当i小于等于s1长度减去s2长度加1时执行循环if s1[i:i+len(s2)] == s2: # 如果s1中从索引i开始长度为s2的子串等于s2total_degree += 1 # 计数器加1i += len(s2) # 将索引i移动s2的长度else:i += 1 # 否则将索引i移动1return total_degree # 返回计数器的值s1 = input("请输入s1的字符串：") # 接收用户输入的s1字符串
s2 = input("请输入s2的字符串：") # 接收用户输入的s2字符串total = occurrence_number(s1, s2) # 调用occurrence_number函数计算s2在s1中出现的次数
print(f"{s2}在{s1}中出现的次数为：{total}") # 输出结果
Demo54 最长公共子串
题目描述
给定两个字符串 s1 和 s2 ，求 s1 与 s2 之间的最长公共子串，字符区分大小写
输入输出描述
输入两行字符串，分别为s1和s2
输出最长公共子串
示例
输入：
123ABCDEFG83hsad
iughABCDEFG23uy
输出：
ABCDEFG
代码如下：
def longest_common_substring(s1, s2):m = len(s1)n = len(s2)dp = [[0] * (n + 1) for _ in range(m + 1)]# 创建了一个名为dp的二维数组，其中每个内部列表都包含n+1个元素，并且初始值都为0。max_length = 0end_index = 0for i in range(1, m + 1):for j in range(1, n + 1):if s1[i - 1] == s2[j - 1]:dp[i][j] = dp[i - 1][j - 1] + 1 if dp[i][j] > max_length:max_length = dp[i][j]end_index = ielse:dp[i][j] = 0return s1[end_index - max_length:end_index]s1 = input("请输入s1的字符串：")
s2 = input("请输入s2的字符串：")result = longest_common_substring(s1, s2)
print(f"最长公共子串为：{result}")
Demo55 检测密码
题目描述
一些网站会给密码强加一些规则：
（1）密码必须至少有8个字符
（2）密码只能包含英文字母和数字
（3）密码应该至少包含两个数字
（4）密码应该至少包含两个大写字母
如果密码符合规则，输出Yes；否则输出No
输入输出描述
输入一串密码
输出该密码是否符合规则
示例1
输入：
123456ab
输出：
No
示例2
输入：
123abcABC
输出：
Yes
代码如下：
import redef check_password_rules(password):# 判断密码是否至少有8个字符if len(password) < 8:return "No" # 判断密码是否只包含英文字母和数字# if not any(char.isdigit() for char in password):# if not any(char.isalpha() for char in password):# return "No" if not re.match("^[A-Za-z0-9]+$", password):return "No"return "Yes"# 判断密码是否至少包含两个数字if "0" not in password and len(password) < 2:return "No" # 判断密码是否至少包含两个大写字母if "A" not in password and len(password) < 2:return "No" # 如果密码符合所有规则，返回"Yes"return "Yes"
password = input("请输入你的密码：") # 您要检查的密码
print(check_password_rules(password))
Demo56 回文素数
题目描述
回文素数是指一个数既是素数又是回文数，例如131既是素数也是回文数
输出显示前100个回文素数，每行显示10个
代码如下：
#判断素数：
def is_prime(n):if n <=1:return Falsefor i in range(2, int(n**1/2) + 1):if n % i == 0:return Falsereturn True#判断回文数：
def reverseNumber(n):num = str(n)m = num[::-1]if num == m:return n
count = 0
num = int(input("请输入一个大于1的正整数（给定一个范围）："))
for n in range(1, num + 1):if is_prime(n) and reverseNumber(n) == n:print(n, end = " ")count += 1if count % 10 ==0:print()if count >= 50:breakDemo57 反素数
题目描述
反素数是指一个将其逆向拼写后也是一个素数的非回文数，例如17和71都是素数但不是回文数，且反转后依旧是素数
输出显示前100个反素数，每行显示10个
代码如下：
# 输出前100个反素数def is_prime(n):if n < 2:return Falsefor i in range(2, int(n**0.5) + 1):if n % i == 0:return Falsereturn Truedef find_inverse_primes(start, end):primes = []for i in range(start, end):if is_prime(i) and is_prime(int(str(i)[::-1])):primes.append(i)return primesstart = 1
end = 100
inverse_primes = find_inverse_primes(start, end)for i in range(len(inverse_primes) // 10 + 1):print(" ".join(map(str, inverse_primes[i * 10:i * 10 + 10])))
Demo58 双素数
题目描述
双素数是指一对差值为2的素数，例如3和5就是一对双素数，5和7也是一对双素数
输出显示小于1000的双素数
代码如下：
def is_prime(n):if n <= 1: return Truefor i in range(2, int(n ** (1 / 2) + 1)): if n % i == 0:return Falsereturn True
def palindromic(num):return str(num) == str(num)[::-1]
def reverse_num(num):return int(str(num)[::-1])
def reverse_prime(number):i = 2count = 0while True:if not palindromic(i) and is_prime(i) and is_prime(reverse_num(i)):print(i, end=' ') count = count + 1if count == number:breaki = i + 1
if __name__ == "__main__":n = int(input())reverse_prime(n)
Demo59 梅森素数
如果一个素数可以写成$2^p-1$的形式，其中p是某个正整数，那么这个素数就称作梅森素数
输出p≤31的所有梅森素数
代码如下：
def is_prime(n): if n <= 1: return False for i in range(2, int(n**0.5) + 1): if n % i == 0: return False return True def find_mersenne_primes(): for p in range(2, 32): n = 2**p - 1 if is_prime(n): print(f"梅森素数在p = {p}: {n}") find_mersenne_primes()Demo60 平方根的近似求法
有几种实现开平方$\sqrt{n}$的技术，其中一个称为巴比伦法
它通过使用下面公式的反复计算近似地得到：
当nextGuess和lastGuess几乎相同时，nextGuess就是平方根的近似值
lastGuess初始值为1，如果nextGuess和lastGuess的差值小于一个很小的数，比如0.0001，就可以认为nextGuess是n的平方根的近似值；否则，nextGuess成为下一次计算的lastGuess，近似过程继续执行
编写代码，求解n的平方根的近似值
代码如下：
# def sqrt_babylon(n):
# lastGuess = 1.0
# while True:
# nextGuess = (lastGuess + n / lastGuess) / 2.0
# if abs(nextGuess - lastGuess) < 0.0001:
# return nextGuess
# lastGuess = nextGuess
def sqrt_babylon(n): # 验证输入是否为正数 if n < 0: raise ValueError("输入必须为正数") # 初始化初始猜测值为1.0 last_guess = 1.0 # 循环迭代直到满足精度要求 while True: # 计算下一个猜测值 next_guess = (last_guess + n / last_guess) / 2.0 # 检查是否满足精度要求 if abs(next_guess - last_guess) < 0.0001: # 返回最终猜测值 return next_guess # 更新上一个猜测值 last_guess = next_guess
num = int(input("请输入你需要求解的数："))
n = sqrt_babylon(num)
print(f"计算后的近似值为：{n}")
v10.18.10官方版)
通关思路)
