目录
[Demo27 打印数字I](#Demo27 打印数字I)
[Demo28 打印数字II](#Demo28 打印数字II)
[Demo29 打印数字III](#Demo29 打印数字III)
[Demo30 打印菱形I](#Demo30 打印菱形I)
[Demo31 打印菱形II](#Demo31 打印菱形II)
[Demo32 打印菱形III](#Demo32 打印菱形III)
[Demo33 猜数字](#Demo33 猜数字)
[Demo34 最大公约数I](#Demo34 最大公约数I)
[Demo35 判断素数](#Demo35 判断素数)
[Demo36 最小公倍数](#Demo36 最小公倍数)
[Demo37 整数的素因子](#Demo37 整数的素因子)
[Demo38 完全数](#Demo38 完全数)
[Demo39 前50个素数](#Demo39 前50个素数)
[Demo40 计算π](#Demo40 计算π)
[Demo41 计算e](#Demo41 计算e)
[Demo42 剪刀石头布II](#Demo42 剪刀石头布II)
[Demo43 组合问题I](#Demo43 组合问题I)
[Demo44 组合问题II](#Demo44 组合问题II)
[Demo45 水仙花数](#Demo45 水仙花数)
[Demo46 青蛙跳台阶](#Demo46 青蛙跳台阶)
[Demo47 堆叠相加](#Demo47 堆叠相加)
[Demo48 十进制转二进制](#Demo48 十进制转二进制)
[Demo49 二进制转十进制](#Demo49 二进制转十进制)
[Demo50 十进制转十六进制](#Demo50 十进制转十六进制)
[Demo51 十六进制转十进制](#Demo51 十六进制转十进制)
[Demo52 最长公共前缀](#Demo52 最长公共前缀)
[Demo53 子串出现的次数](#Demo53 子串出现的次数)
[Demo54 最长公共子串](#Demo54 最长公共子串)
[Demo55 检测密码](#Demo55 检测密码)
[Demo56 回文素数](#Demo56 回文素数)
[Demo57 反素数](#Demo57 反素数)
[Demo58 双素数](#Demo58 双素数)
[Demo59 梅森素数](#Demo59 梅森素数)
[Demo60 平方根的近似求法](#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
代码如下：
python
#模式A
layer = int(input("请输入你要输入的行数："))
for index in range(1, layer + 1 ):
for j in range(1, index + 1):
print(j, end = " ")
print()
#模式B
layer = 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()
# 模式D
layer = 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
代码如下：
python
# 输入行数
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
代码如下：
python
# 输入行数
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 ** k
print("{: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
输出：
*
* *
* * *
* *
*
代码如下:
python
# #打印实心菱形
# 输入行数
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
输出：
*
* *
* *
* *
*
代码如下：
python
#打印空心菱形
#控制台输入行数
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
输出：
*
***
*****
***
*
代码如下：
python
#打印实心菱形
#输入行数
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
代码如下：
python
import random
num1 = 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
代码如下：
python
#短除法
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 * i
num1 = num1 / i
num2 = num2 / i
print(f"最小公约数为{t}")
#欧几里得算法
num1, num2 = map(int, input("请依次输入两个正整数：").split(" "))
a = max(num1 , num2)
b = min(num1 , num2)
t = a % b
while t != 0:
a = b
b = t
print(f"最大的公约数:{b}")
breakDemo35 判断素数
题目描述
一个大于1的整数如果只能被正整数1和它本身整除，则它就是素数，例如2、3、5和7都是素数，而4、6、8、9则不是
输入输出描述
输入一个大于1的正整数
输出Yes表示该数字是素数，否则输出No
示例1
输入：
9
输出：
No
示例2
输入：
11
输出：
Yes
代码如下：
python
def is_prime(n):
if n <=1:
return False
for i in range(2, int(n**1/2) + 1):
if n % i == 0:
return False
return True
num = 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
代码如下：
python
def find_lcm(x , y):
if x > y:
greater = x
else:
greater = y
while True:
if greater % x==0 and greater % y ==0:
lcm = greater
break
greater += 1
return lcm
num1 , 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
代码如下：
python
def find_prime_factors(num):
factors = []
i = 2
while i*i <= num:
if num % i != 0:
i += 1
else:
num = num // i
factors.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
代码如下：
python
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个素数换行
代码如下：
python
def is_prime(num):
if num <= 1:
return False
for i in range(2, int(num ** 1/2) + 1):
if num % i == 0:
return False
return True
count = 0
for num in range(1, 500):
if is_prime(num):
print(num, end = " ")
count += 1
if count % 10 ==0:
print()
if count >= 50:
breakDemo40 计算π
题目描述
你可以使用下面的数列近似计算π
当i越大时，计算结果越近似于π
代码如下：
python
def approximate_pi(n):
pi_approx = 0.0
sign = 1
for i in range(1, n + 1):
term = sign / (2*i -1)
pi_approx += term
sign *= -1
return 4 * pi_approx
n = int(input("请输入你要迭代的次数："))
approximate = approximate_pi(n)
print(f"π的近似值为{approximate}")Demo41 计算e
题目描述
你可以使用下面的数列近似计算e
当i越大时，计算结果越近似于e
代码如下：
python
import math
def approximate_e(n):
e_approx = 0.0
factorial = 1
for i in range(1, n):
term = 1 / factorial
e_approx += term
factorial *= (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】的问题，利用循环将程序改为，计算机和电脑谁先赢三次，谁就是终极胜利者
代码如下：
python
import random
choices = ["石头", "剪刀", "布"]
#choices = {"石头":0, "剪刀":1, "步":2}
player_score = 0
computer_score = 0
while 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 += 1
else:
print("你输了！")
computer_score += 1
# 显示当前分数
print(f"当前分数：玩家 {player_score} - {computer_score} 计算机")
if player_score == 3:
print("玩家获胜！")
break
if computer_score == 3:
print("计算机获胜！")
break
# 询问是否继续游戏
play_again = input("是否继续游戏？（输入 y 继续，其他任意键退出）：")
if play_again.lower() != "y":
break
print("游戏结束！")Demo43 组合问题I
题目描述
在数字范围[1,7]之间，任意选择两个不相同的数作为一个组合，输出每一组组合，并统计所有组合的个数
注：组合（a，b）与组合（b，a）算同一种组合，只记录一次
代码如下：
python
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这个四个数字，能组成多少个互不相同且无重复数字的三位数？分别又是多少？
代码如下：
python
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
编写程序，输出所有的水仙花数
代码如下：
python
for i in range(100,1000):
a = i // 100
b = i % 100 // 10
c = i % 10
if 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）
代码如下：
python
def jum_ways(n):
if n == 1:
return 1
elif n == 2:
return 2
else :
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
代码如下：
python
def add_up(a, n):
sum = 0
num = a
for i in range(n):
sum += num
num = num * 10 + a
return sum
a, n = map(int, input("请依次输入叠加的数字以及叠加的组数：").split(" "))
print("最终的总和为：")
print(add_up(a, n))Demo48 十进制转二进制
题目描述
输入一个十进制正整数，输出其二进制形式
输入输出描述
输入一个十进制正整数
输出二进制字符串
示例
输入：
9
输出：
1001
代码如下：
python
def base_system_conversion(decimalism):
binary =" "
while decimalism > 0:
remainder = decimalism % 2
binary = str(remainder) + binary
decimalism = decimalism // 2
return binary
decimalism = int(input("请输入你想转换的十进制："))
print(f"转换后的二进制为:{base_system_conversion(decimalism)}")Demo49 二进制转十进制
题目描述
输入一个二进制字符串，输出其对应的十进制数字
输入输出描述
输入一个二进制字符串
输出十进制数字
示例
输入：
1001
输出：
9
代码如下：
python
def base_system_conversion(binary):
decimalism = 0
binary_str = str(binary)
binary_str = binary_str[::-1]
for i in range(len(binary_str)):
if binary_str[i] == '1':
decimalism += 2 ** i
return decimalism
binary_input = input("请输入你想转换的二进制：")
print(f"转换后的十进制为: {base_system_conversion(binary_input)}")Demo50 十进制转十六进制
题目描述
输入一个十进制正整数，输出其十六进制形式
输入输出描述
输入一个十进制正整数
输出十六进制字符串
示例
输入：
1233321
输出：
1e1b9
代码如下：
python
def base_system_conversion(decimal):
hexadecimal = ""
while decimal > 0:
remainder = decimal % 16
if remainder < 10:
hexadecimal = str(remainder) + hexadecimal
else:
hexadecimal = chr(65 + remainder - 10) + hexadecimal
decimal = decimal // 16
return hexadecimal
decimal = int(input("请输入你想转换的十进制："))
print(f"转换后的十六进制为: {base_system_conversion(decimal)}")Demo51 十六进制转十进制
题目描述
输入一个十六进制字符串，输出其对应的十进制数字
输入输出描述
输入一个十六进制字符串
输出十进制数字
示例
输入：
1e1b9
输出：
123321
代码如下：
python
def base_system_conversion(hexadecimal):
decimal = 0
power = len(hexadecimal) - 1
for digit in hexadecimal:
if digit.isdigit():
decimal += int(digit) * (16 ** power)
else:
decimal += (ord(digit.upper()) - 55) * (16 ** power)
power -= 1
return decimal
hexadecimal = input("请输入你想转换的十六进制：")
print(f"转换后的十进制为: {base_system_conversion(hexadecimal)}")Demo52 最长公共前缀
题目描述
给定两个字符串 s1 和 s2 ，求两个字符串最长的公共前缀串，字符区分大小写
输入输出描述
输入两行，分别表示s1和s2
输出前缀串
示例
输入：
abcdefg
abcdhko
输出：
abcd
代码如下：
python
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
代码如下：
python
def occurrence_number(s1, s2):
total_degree = 0 # 初始化计数器为0
i = 0 # 设置字符串s1的索引i为0
while i < len(s1) - len(s2) + 1: # 当i小于等于s1长度减去s2长度加1时执行循环
if s1[i:i+len(s2)] == s2: # 如果s1中从索引i开始长度为s2的子串等于s2
total_degree += 1 # 计数器加1
i += len(s2) # 将索引i移动s2的长度
else:
i += 1 # 否则将索引i移动1
return 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
代码如下：
python
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 = 0
end_index = 0
for 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 = i
else:
dp[i][j] = 0
return 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
代码如下：
python
import re
def 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个
代码如下：
python
#判断素数：
def is_prime(n):
if n <=1:
return False
for i in range(2, int(n**1/2) + 1):
if n % i == 0:
return False
return 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 += 1
if count % 10 ==0:
print()
if count >= 50:
breakDemo57 反素数
题目描述
反素数是指一个将其逆向拼写后也是一个素数的非回文数，例如17和71都是素数但不是回文数，且反转后依旧是素数
输出显示前100个反素数，每行显示10个
代码如下：
python
# 输出前100个反素数
def is_prime(n):
if n < 2:
return False
for i in range(2, int(n**0.5) + 1):
if n % i == 0:
return False
return True
def 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 primes
start = 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的双素数
代码如下：
python
def is_prime(n):
if n <= 1:
return True
for i in range(2, int(n ** (1 / 2) + 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=' ')
count = count + 1
if count == number:
break
i = i + 1
if __name__ == "__main__":
n = int(input())
reverse_prime(n)Demo59 梅森素数
如果一个素数可以写成2\^p-1的形式，其中p是某个正整数，那么这个素数就称作梅森素数
输出p≤31的所有梅森素数
代码如下：
python
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的平方根的近似值
代码如下：
python
# 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}")