Demo 1
输入一个摄氏温度的值，将它转变为华氏温度，并将结果输出
#输入一个摄氏温度的值，将它转变为华氏温度，并将结果输出
c = float(input("请输入摄氏温度："))
print("对应的华氏温度为%.2f"%(9*c/5+32))输入圆柱的半径和高，并利用如下公式计算圆柱体的底面积和体积。
# 输入圆柱的半径和高，并利用如下公式计算圆柱体的底面积和体积。
r = float(input("请输入圆柱体的半径:"))
h = float(input("请输入圆柱体的高:"))
s = 3.14 * r *r
print("圆柱体的底面积为:%.2f,圆柱体的体积为:%.2f"%(s,s*h))输入英尺数然后将它转换为米数，并输出结果，一英尺等于0.305米
#输入英尺数然后将它转换为米数，并输出结果，一英尺等于0.305米
y = float(input("请输入英尺数:"))
print("%.2F英尺 = %.2f米"%(y,0.305*y))读取小计和酬金率，然后计算小费以及合计金额。例如客户的小计为10元，酬金率为15%，那么小费是1.5元，合计金额为11.5元
#读取小计和酬金率，然后计算小费以及合计金额。例如客户的小计为10元，酬金率为15%，那么小费是1.5元，合计金额为11.5元
j = float(input("请输入小计总额:"))
l = float(input("请输入酬金率:"))
x = j * l
print("小费为:%.2f"%x)
print("合计金额:%.2f"%(x + j))取一个0到1000之间的整数，并计算它各位数字之和
#读取一个0到1000之间的整数，并计算它各位数字之和
num = int(input("请输入一个0~1000之间的整数:"))
if 0 < num < 1000:
a = num % 10
b = (num - a) // 10 % 10
c = (num - a - b * 10) // 100
sum = a + b + c
print(sum)输入分钟数，然后将该分钟数转换为年数和天数，假定一年有365天
#输入分钟数，然后将该分钟数转换为年数和天数，假定一年有365天
min = int(input("请输入分钟数:"))
day = int(min / 60 / 24)
year = int(min / 60 / 24 // 365)
print(year, (day - year * 365))水从初始温度加热到最终温度是需要能量的，请计算需要多少能量，公式如下：
这里的M是按千克计的水量，初始温度和最终温度均为摄氏度，热量Q以焦耳计
Q = M ×（最终温度 – 初始温度）× 4184
m = float(input("请输入水量:"))
s = float(input("请输入水初始温度:"))
d = float(input("请输入水最终温度:"))
print("所需的能量值:%.2f"%(m*(d - s)*4184))输入一个四位整数，并以反向顺序显示
#输入一个四位整数，并以反向顺序显示
num = int(input("请输入一个四位整数:"))
while num > 0:
s = num % 10
num //= 10
print(s)输入三角形的三个顶点坐标，并计算其面积，计算公式如下
当三个点A、B、C的坐标分别为A(x1，y1)、B(x2，y2)、C(x3、y3)时，三角形面积为，
S=(x1y2-x1y3+x2y3-x2y1+x3y1-x2y2)
#输入三角形的三个顶点坐标，并计算其面积，计算公式如下
# 当三个点A、B、C的坐标分别为A(x1，y1)、B(x2，y2)、C(x3、y3)时，三角形面积为，
# S=(x1y2-x1y3+x2y3-x2y1+x3y1-x2y2)
Ax,Ay = map(float,(input("请输入A的横纵坐标:").split()))
Bx,By = map(float,(input("请输入B的横纵坐标:").split()))
Cx,Cy = map(float,(input("请输入C的横纵坐标:").split()))
S = (Ax*By - Ax*Cy + Bx*Cy - Bx*Ay + Cx*Ay - Bx*By )
print("面积S = %.2f"%S)输入你所在的时区，并输出当前的时间
# 输入你所在的时区，并输出当前的时间
# 从datetime模块导入datetime类和timedelta类(表示时间间隔)
from datetime import datetime,timedelta
place = int(input("请输入时区："))
# 获取当前时间
now = datetime.now()
# 将时间格式化为字符串
time_8= now.strftime("%H:%M:%S")
if place == 8:
print(time_8)
elif place == -5:
# 修改时间（将小时加11）
modified_time = now +timedelta(hours=11)
time_5= modified_time.strftime("%H:%M:%S")
print(time_5)
else:
print("输入有误重新输入")输入三角形的三个顶点坐标，并计算该三角形的三个角分别是多少（角度制）
A=acos((a*a-b*b-c*c)/(-2*b*c))
B=acos((b*b-a*a-c*c)/(-2*a*c))
C=acos((c*c-b*b-a*a)/(-2*a*b))
# 输入三角形的三个顶点坐标，并计算该三角形的三个角分别是多少
import math
x1,y1,x2,y2,x3,y3=map(float,input("请输入顶点坐标，用空格隔开：").split())
# 计算三条边长
side1 = math.sqrt( (x1-x2)**2+(y1-y2)**2)
side2 = math.sqrt((x2-x3)**2+(y2-y3)**2)
side3 = math.sqrt((x1-x3)**2+(y1-y3)**2)
# 公式计算（弧度制）
cont1=math.acos((side1**2-side2**2-side3**2)/(-2*side2*side3))
cont2=math.acos((side2**2-side1**2-side3**2)/(-2*side1*side3))
cont3=math.acos((side3**2-side2**2-side1**2)/(-2*side1*side2))
# 将弧度制转化为角度制
angle_1=math.degrees(cont1)
angle_2=math.degrees(cont2)
angle_3=math.degrees(cont3)
print("%.2f\n%.2f\n%.2f\n"%(angle_1,angle_2,angle_3))
假设硬币种类分为：一元硬币、两角五分硬币、一角硬币、五分硬币、一分硬币
输入总金额，并将总金额兑换成若干个硬币，并保证所兑换的硬币个数最少
'''
假设硬币种类分为：一元硬币、两角五分硬币、一角硬币、五分硬币、一分硬币
输入总金额，并将总金额兑换成若干个硬币，并保证所兑换的硬币个数最少
'''
money = float(input("请输入总金额:"))
a = money // 1
b = (money - a) // 0.25
c = (money - a - (b*0.25))// 0.1
d = (money - a - (b*0.25) - (c*0.1))// 0.05
e = (money - a - (b*0.25) - (c*0.1) - (d*0.05))//0.01
print("%.0f个一元硬币" %a)
print("%.0f个两角五分硬币" %b)
print("%.0f个一角硬币" %c)
print("%.0f个五分硬币" %d)
print("%.0f个一分硬币" %e)正多边形是边长相等的多边形，而且所有的角相等，计算正多边形的公式为
'''正多边形是边长相等的多边形，而且所有的角相等，计算正多边形的公式为：'''
import math
n , s = map(float,input("输入：\n").split())
area = (n * s * s) / (4 * math.tan(math.pi/n))
print("%.2f"%area)
'''BMI是根据体重测量健康的方式，通过以千克为单位的体重除以以米为单位的身高的平方计算而出'''
'''BMI是根据体重测量健康的方式，通过以千克为单位的体重除以以米为单位的身高的平方计算而出'''
sg = float(input("请输入身高(m)："))
tz = float(input("请输入体重(kg)："))
BMI = tz / (sg*sg)
if BMI < 18.5:
print("过轻")
elif 18.5 <= BMI < 24:
print("正常")
elif 24 <= BMI < 27:
print("过重")
elif 27 <= BMI < 30:
print("轻度肥胖")
elif 30 <= BMI < 35:
print("中度肥胖")
elif BMI >= 35:
print("重度肥胖")一个年份如果能被4整除但不能被100整除，或者能被400整除，那么这个年份就是闰年
'''一个年份如果能被4整除但不能被100整除，或者能被400整除，那么这个年份就是闰年'''
year = int(input("请输入年份:"))
if year % 4 == 0 & year % 100 != 0 or year % 400 == 0:
print(f"{year}年是闰年")
else:
print(f"{year}年是平年")随机产生一个两位数数字，然后用户输入一个两位数数字，并根据以下规则判定用户赢得的奖金是多少
（1）输入的数字和随机产生的数字完全相同（包括顺序），奖金为10000元
（2）输入的数字和随机产生的数字相同（不包括顺序），奖金为3000元
（3）输入的数字和随机产生的数字有一位数相同，奖金为1000美元
（4）输入的数字和随机产生的数字都不相同，没有奖金，0元
# 中彩票
import random
input_num = int (input("输入："))
input_str = str(input_num)
random_num = random.randint(10,99)
random_str = str(random_num)
print(random_num)
if input_num ==random_num:
print("10000")
elif random_str[0] == input_str[1] and random_str[1] == input_str[0]:
print("3000")
elif (random_str[0] == input_str[0] or random_str[0] == input_str[1])or(random_str[1] == input_str[0] or random_str[1] == input_str[1]) :
print("1000")
else:
print("0")求一元二次方程
# 解一元二次方程
# ax^2+bx+c=0
import math
a,b,c = map(float,input("输入：").split())
if a==0:
print("输入不合法")
elif b**2-4*a*c>0:
# round(number[, ndigits])----四舍五入保留ndigits位小数
print( round((-b+math.sqrt(b**2-4*a*c))/(2*a),2))
print( round((-b-math.sqrt(b**2-4*a*c))/(2*a),2))
elif b**2-4*a*c==0:
print(round((-b)/(2*a),2))
elif b**2-4*a*c<0:
print("无实数解")解2×2线程方程
# 解2×2线程方程
a,b,c,d,e,f = map(float,input("输入：").split())
# 前提：(ad - bc)不等于0
# x = (ed - bf) / (ad - bc)
# y = (af - ec) / (ad - bc)
if (a*d - b*c) ==0:
print("无解")
else:
x = (e*d - b*f) / (a*d - b*c)
y = (a*f - e*c) / (a*d - b*c)
print(x,y)未来是周几
# 未来是周几
week ,future_day = map(int ,input("输入：").split())
day = (week+future_day)%7
if day == 0:
print("星期天")
if day == 1:
print("星期一")
if day == 2:
print("星期二")
if day == 3:
print("星期三")
if day == 4:
print("星期四")
if day == 5:
print("星期五")
if day == 6:
print("星期六")
本年中的第几天
year,month,day = map(int,input("输入").split())
# 定义每月的天数表
month_day =[0,31,28,31,30,31,30,31,31,30,31,30,31]
# 判断闰年，并对二月进行加一操作
if (year %4 ==0 and year%100 ==0) or year%400 == 0:
month_day[2] += 1
for i in range(0 , month):
day += month_day[i]
print(day)剪刀石头布
import random
use_num =int( input("输入："))
com_num = random.randint(0,2)
# 定义一个方法：将数字和字符转换，
def vo(num):
if num ==0:
return " 剪刀"
elif num == 1:
return " 石头"
elif num ==2:
return " 布"
else :
return 0
# 对用户输入数据进行判断
if vo(use_num)==0:
print("输入不合法")
else:
print("计算机输出"+vo(com_num))
print("用户出的"+vo(use_num))
if com_num==use_num:
print("平手")
elif (com_num==1 and use_num==0) or(com_num==0 and use_num==2) or (com_num == 2 and use_num == 1):
print("计算机赢")
else:
print("用户赢")计算三角形的周长
side1,side2,side3 = map(int,input("输入：").split())
if side1+side2>side3 and side1+side3>side2 and side2+side3>side1:
print(side1+side2+side3)
else:
print("非法")
判断一年中某天是星期几
# 判断一年中某天是星期几
# 输入年、月、日三个数据，数据之间用空格分隔
# 输出该日是周几
year,month,day = map(int,input("输入：").split())
# 一月和二月都是按照前一年的13月和14月来计数的，所以还得把年份改为前一年
if month ==1 or month == 2:
year-=1
month+=12
h =int((day+26*(month+1)//10+year%100+year%100//4+year/100//4+5*year/100)%7)
if h == 0:
print("星期六")
elif h == 1:
print("星期天")
elif h == 2:
print("星期一")
elif h == 3:
print("星期二")
elif h == 4:
print("星期三")
elif h == 5:
print("星期四")
elif h == 6:
print("星期五")回文数
# 回文数
# 输入一个三位整数，然后判断其是否为一个回文数
# 如果一个数从左向右和从右向左读取时是一样的，那么这个数就是回文数
# 用户需要判断的数字
num = int (input("输入："))
# num会在后续的操作中改值，所以需要定义一个变量存储num的值
tem =num
# 定义一个变量用于存储反转后的数字
change_num =0
while num >0:
change_num *= 10
change_num += num%10
num //= 10
if tem == change_num:
print("yes")
else:
print("no")判断两个矩形之间的位置关系
# 判断两个矩形之间的位置关系
# 输入两行，每行四个数据，分别是矩形的中心坐标x、y和矩形的宽、高
# 输出两者的关系
x1,y1,winth1,high1 = map(float ,input("输入").split())
x2,y2,winth2,high2 = map(float ,input("输入").split())
level =abs(x1-x2)
vertical = abs(y1-y2)
if level < (winth1+winth2)/2 and vertical<(high1+high2)/2:
print("包含")
elif level<abs(winth1-winth2) and vertical<abs(high1-high2):
print("重叠")
else:
print("相离")Demo 2
打印数字I
利用循环，寻找规律，打印如下数字模式：
print("模式A")
layer = 6
for i in range(1,layer+1):
for j in range(1,i+1):
print(j,end="")
print()
print("模式B")
for i in range(layer,0,-1):
for j in range(1,i+1):
print(j,end="")
print()
print("模式C")
for i in range(layer+1):
print(" "*(layer - i),end=" ")
for j in range(i,0,-1):
print(j,end="")
print()
print("模式D")
for i in range(layer,0,-1):
print(" "*(layer - i),end=" ")
for j in range(1,i+1):
print(j,end="")
print()打印数字Ⅱ
layer = 7
for i in range(1,layer+1):
print(" "*(layer - i),end=" ")
for j in range(i , 0 ,-1):
print(j ,end="")
for j in range(2 , i+1):
print(j ,end="")
print()打印数字Ⅲ
layer = 7
for i in range(1,layer+1):
print(" "*2*(layer - i),end=" ")
for j in range(1 , i+1 ):
print(2**(j-1) ,end=" ")
for j in range(i-1 , 0,-1):
print(2**(j-1),end=" ")
print()打印菱形Ⅰ
layer = int(input("输入：\n"))
for i in range(layer // 2 + 2):
print(" "*(layer - i), end="")
for j in range(i ):
print("*",end=" ")
print()
for i in range(layer // 2 , 0 , -1):
print(" " * (layer - i),end="")
for j in range(i):
print("*",end=" ")
print()打印菱形Ⅱ
layer = int(input("输入：\n"))
for i in range(layer // 2 + 2):
print(" "*(layer - i), 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):
print(" " * (layer - i),end="")
for j in range(2 * i - 1):
if j == 0 or j == 2 * i - 2:
print("*",end="")
else:
print(" ",end="")
print()打印菱形Ⅲ
layer = int(input("输入：\n"))
for i in range(layer // 2 + 2):
print(" "*(layer - i), end="")
for j in range(2 * i - 1):
print("*",end="")
print()
for i in range(layer // 2 , 0 , -1):
print(" " * (layer - i),end="")
for j in range(2 * i - 1):
print("*",end="")
print()猜数字
计算机随机生成一个[0,100]之间的整数，程序提示用户连续地输入数字直到它与那个随机生成的数字相同
对于用户输入的数字，程序会提示它是过高还是过低
"""猜数字"""
import random
computer = random.randint(0,101)
person = int(input("请猜一个数："))
while computer != person:
if computer > person:
print("猜低了")
elif computer < person:
print("猜高了")
else:
print("恭喜你猜对了！！！")
break
person = int(input("请重新猜测："))
print(f"猜中的答案就是{person}")最大公约数I
输入两个正整数，计算其最大公约数，例如4和2的最大公约数是2，16和24的最大公约数是8
"""最大公约数I"""
num1 = int(input("输入a = "))
num2 = int(input("输入b = "))
def gcd(num1, num2):
if num2 == 0:
return num1
else:
return gcd(num2, num1 % num2)
print(gcd(num1,num2))判断素数
一个大于1的整数如果只能被正整数1和它本身整除，则它就是素数，例如2、3、5和7都是素数，而4、6、8、9则不是
"""判断素数"""
a = int(input("输入：\n"))
def sushu(n:int) -> int:
flog = 0
for i in range(2,a):
if a % i == 0:
flog = 1
if flog:
return 0
else:
return 1
if sushu(a):
print("yes")
else:
print("no")最小公倍数
输入两个正整数，计算其最小公倍数，例如4和2的最小公倍数是4，3和5的最小公倍数是15
def gcd(num1, num2):
if num2 == 0:
return num1
else:
return gcd(num2, num1 % num2)
a = int(input("请输入a = "))
b = int(input("请输入b = "))
c = gcd(a, b)
print(f"a, b最小公倍数为：{a*b/c}")整数的素因子
输入一个正整数，然后找出它所有的最小因子，也称之为素因子
"""整数的素因子"""
num = int(input("请输入一个数："))
num1 = 2
while num >= num1:
if num % num1 == 0:
print(num1)
num = num / num1
else:
num1 += 1完全数
如果一个正整数等于除了它本身之外所有正因子的和，那么这个数称为完全数
"""完全数"""
a = int(input("输入：\n"))
c = 0
for i in range(1,a):
if a%i == 0:
c+=i
if c==a:
print("Yes")
else:
print("No")前50个素数
打印前50个素数，每打印10个素数换行
"""打印前50个素数"""
def sushu(n:int) -> int:
flog = 0
if n == 0:
return 1
for i in range(2,n):
if n % i == 0:
flog = 1
if flog:
return 0
else:
return 1
for i in range(1,51):
if sushu(i):
print(i)计算π
你可以使用下面的数列近似计算π
当i越大时，计算结果越近似于π
sum = 0
for i in range(1,100000):
if i % 2 ==0:
sum = sum - 1/(2*i-1)
elif i % 2 != 0:
sum = sum + 1/(2*i-1)
pi = sum * 4
print(pi)计算e
你可以使用下面的数列近似计算e
当i越大时，计算结果越近似于e
e = 0
for i in range(1,100):
for j in range(1,i+1):
i *= j
e = e + 1/i
print(e)剪刀石头布II
延伸【Demo21剪刀石头布I】的问题，利用循环将程序改为，计算机和电脑谁先赢三次，谁就是终极胜利者
import random
dn = 0
you = 0
while True:
b = random.randint(1,4)
a = int(input("请输入1-3（1代表剪刀，2代表石头，3代表布）之间整数："))
if (a == 1 and b == 2) or (a == 2 and b == 3) or (a == 3 and b == 1):
print("兄弟再练练吧")
dn += 1
if dn == 3:
print("你输了")
break
elif a == b:
print("点到为止，平手")
else:
print("有两把刷子哟")
you += 1
if you == 3:
print("你赢了")
break组合问题I
在数字范围[1,7]之间，任意选择两个不相同的数作为一个组合，输出每一组组合，并统计所有组合的个数
注：组合（a，b）与组合（b，a）算同一种组合，只记录一次
s = []
for i in range(1,8):
for j in range(i+1,8):
s.append(f"{i},{j}")
print(s)组合问题II
有1、2、3、4这个四个数字，能组成多少个互不相同且无重复数字的三位数？分别又是多少？
s = []
num = 0
for i in range(1,5):
for j in range(i+1,5):
for l in range(j+1,5):
num = str(i) + str(j) + str(l)
s.append(num)
print(s)水仙花数
水仙花数，是一个三位数，且这个数的个位、十位和百位的立方和等于该数字本身，例如$153=1^3+5^3+3^3$
for i in range(100 , 1000):
a = i // 100
b = i % 100 // 10
c = i % 10
if i == a ** 3 + b ** 3 + c ** 3:
print(i,end=" ")青蛙跳台阶
一只青蛙，一次可以跳一个台阶或者两个台阶，现有n个台阶，问该青蛙有多少种不同的跳法？
例如：两个台阶，有两种跳法（1+1，2）；四个台阶，有五种跳法（1+1+1+1，2+1+1，1+2+1，1+1+2，2+2）
# 青蛙跳楼梯：1 1 2 3 5 8 13······
def qingwa(n : int) -> int:
if n == 1 or n ==2:
return n
return qingwa(n-1) + qingwa(n-2)
print(qingwa(10))堆叠相加
现有堆叠相加模式$a+aa+aaa+aaaa+aaaaa+......$
例如：$2+22+222+2222+22222$，其中a为2，且有5组数字
a = int(input("请输入一个数："))
n = int(input("请输入循环次数："))
sum = 0
for i in range(1,n):
sum = sum + a*i
print(sum)十进制转二进制
输入一个十进制正整数，输出其二进制形式
"""十进制转二进制"""
num = int(input("请输入一个十进制整数："))
e = ""
while num > 0:
e = str(num % 2) + e
num = num // 2
print(e)二进制转十进制
输入一个二进制字符串，输出其对应的十进制数字
# 二进制转十进制
num = int(input("输入"))
def change_num (num):
all = 0
str_num = str(num)
for i in range(0,len(str_num)):
all += int(str_num[i])
if i == len(str_num)-1:
return all
all *= 2
print(change_num(num))十进制转十六进制
输入一个十进制正整数，输出其十六进制形式
# 十进制转十六进制
num = int(input("输入："))
def change_num(num):
ox_num = "0123456789ABCDEF"
fin_num = ""
while num > 0:
get_num = num % 16
num //= 16
fin_num = ox_num[get_num] + fin_num
return fin_num
print(change_num(num))
十六进制转十进制
输入一个十六进制字符串，输出其对应的十进制数字
# 十六进制转十进制
num = str(input("输入："))
def change_num(num):
ox_num = "0123456789abcdef"
all = 0
len_num = len(num)
for j in num:
for i in ox_num:
if i == j:
all += ox_num.index(i)* 16 ** (len_num-1)
len_num -= 1
return all
print(change_num(num))
最长公共前缀
给定两个字符串 s1 和 s2 ，求两个字符串最长的公共前缀串，字符区分大小写
# 给定两个字符串 s1 和 s2 ，求两个字符串最长的公共前缀串，字符区分大小写
str1 = str(input("输入"))
str2 = str(input())
def judge_str (str1,str2):
new_str = ""
for i,j in zip(str1,str2):
# zip() 函数来同时遍历两个字符串。
# 如果两个字符串的长度不相等，zip() 函数将会以较短的字符串为准，忽略超过其长度的部分。
if i == j :
new_str += i
else:
break
return new_str
print(judge_str(str1,str2))子串出现的次数
给定两个字符串 s1 和 s2 ，求 s2 在 s1 中出现的次数，字符区分大小写，已匹配的字符不计入下一次匹配
# 给定两个字符串 s1 和 s2 ，求 s2 在 s1 中出现的次数，
#字符区分大小写，已匹配的字符不计入下一次匹配
str1 = str(input("输入"))
str2 = str(input("输入"))
def judge_str(str1,str2):
count = 0
index_str1 = 0
while index_str1 <= len(str1)-len(str2) :
flog = True
tem = index_str1
for i in str2:
if str1[tem] == i:
tem += 1
else:
index_str1 += 1
flog = False
break
if flog:
count += 1
index_str1 += len(str2)
return count
print(judge_str(str1,str2))检测密码
一些网站会给密码强加一些规则：
（1）密码必须至少有8个字符
（2）密码只能包含英文字母和数字
（3）密码应该至少包含两个数字
（4）密码应该至少包含两个大写字母
如果密码符合规则，输出Yes；否则输出No
# 一些网站会给密码强加一些规则：
# （1）密码必须至少有8个字符
# （2）密码只能包含英文字母和数字
# （3）密码应该至少包含两个数字
# （4）密码应该至少包含两个大写字母
# 如果密码符合规则，输出Yes；否则输出No
s1 = str(input("输入"))
def string_pass(s1):
get_num = 0
get_capital = 0
if len(s1)<8:
return "no"
for i in s1:
if ord(i)<48 or 57<ord(i)<65 or 90<ord(i)< 96 or ord(i)>122:
return "no"
if 47<ord(i)<58:
get_num += 1
if 64<ord(i)<91:
get_capital += 1
if get_num < 2:
return "no"
if get_capital< 2:
return "no"
return "yes"
print(string_pass(s1))回文素数
回文素数是指一个数既是素数又是回文数，例如131既是素数也是回文数
输出显示前100个回文素数，每行显示10个
# 回文素数是指一个数既是素数又是回文数，例如131既是素数也是回文数
# 输出显示前100个回文素数，每行显示10个
import math
# 找素数的函数
def find_prime(num):
if num < 2 :
return False
if num == 2 or num == 3:
return True
elif num % 2 == 0:
return False
elif num % 3 == 0:
return False
sqrt = int(math.sqrt(num))
i = 1
while (6*i-1) < sqrt :
if num % (6*i-1) == 0 or num % (6*i+1) == 0:
return False
i += 1
else:
return True
# 找回文数
def find_palindromic(num):
str_num = str(num)
i = 0
j = len(str_num)-1
while i < j:
if str_num[i] != str_num[j]:
return False
i += 1
j -= 1
return True
i = 100
count = 0
while count < 100:
if find_prime(i) and find_palindromic(i):
print(str(i) +" ",end="")
count += 1
if count % 10 == 0:
print()
i += 1反素数
反素数是指一个将其逆向拼写后也是一个素数的非回文数，例如17和71都是素数但不是回文数，且反转后依旧是素数
输出显示前100个反素数，每行显示10个
# 反素数是指一个将其逆向拼写后也是一个素数的非回文数，例如17和71都是素数但不是回文数，且反转后依旧是素数
# 输出显示前100个反素数，每行显示10个
import math
# 质数
def is_prime(num):
if num<2:
return False
if num == 2 or num ==3:
return True
if num % 2 == 0 or num % 3 == 0:
return False
sqrt_num =int(math.sqrt(num))
k = 1
while (6*k-1)<sqrt_num:
if num % (6*k-1) == 0 or num % (6*k+1) == 0:
return False
k += 1
return True
# 回文数
def is_palindromic (num):
str_num = str(num)
i = 0
j = len(str_num)-1
while i < j:
if str_num[i] != str_num[j]:
return False
i += 1
j -= 1
return True
# 反转
def get_sort_num(num):
str_num = str(num)
reversed_str = str_num[::-1]
return int(reversed_str)
count = 0
i = 17
while count < 100:
if is_prime(i) and is_prime(get_sort_num(i)) and not is_palindromic(i):
print (str(i)+" ",end="")
count += 1
if count % 10 == 0:
print()
i += 1
双素数
双素数是指一对差值为2的素数，例如3和5就是一对双素数，5和7也是一对双素数
输出显示小于1000的双素数
# 双素数是指一对差值为2的素数，例如3和5就是一对双素数，5和7也是一对双素数
# 输出显示小于1000的双素数
import math
# 质数
def is_prime(num):
if num<2:
return False
if num == 2 or num ==3:
return True
if num % 2 == 0 or num % 3 == 0:
return False
sqrt_num =int(math.sqrt(num))
k = 1
while (6*k-1)<sqrt_num:
if num % (6*k-1) == 0 or num % (6*k+1) == 0:
return False
k += 1
return True
i = 1
while i+2 < 1000:
if is_prime(i):
if is_prime(i+2):
print(f"[{i},{i+2}] ",end="")
i += 2梅森素数
如果一个素数可以写成$2^p-1$的形式，其中p是某个正整数，那么这个素数就称作梅森素数
输出p≤31的所有梅森素数
# 如果一个素数可以写成2**p-1的形式，其中p是某个正整数，那么这个素数就称作梅森素数
# 输出p≤31的所有梅森素数
import math
# 质数
def is_prime(num):
if num<2:
return False
if num == 2 or num ==3:
return True
if num % 2 == 0 or num % 3 == 0:
return False
sqrt_num =int(math.sqrt(num))
k = 1
while (6*k-1)<sqrt_num:
if num % (6*k-1) == 0 or num % (6*k+1) == 0:
return False
k += 1
return True
p = 1
while p < 32:
if is_prime(2**p-1):
print(2**p-1)
p +=1
平方根的近似求法
有几种实现开平方$\sqrt{n}$的技术，其中一个称为巴比伦法
它通过使用下面公式的反复计算近似地得到：
当nextGuess和lastGuess几乎相同时，nextGuess就是平方根的近似值
lastGuess初始值为1，如果nextGuess和lastGuess的差值小于一个很小的数，比如0.0001，就可以认为nextGuess是n的平方根的近似值；否则，nextGuess成为下一次计算的lastGuess，近似过程继续执行
编写代码，求解n的平方根的近似值
# 平方根的近似求法
#方法：nextGuess=(lastGuess+n/lasetGuess)/2
#当nextGuess和lastGuess几乎相同时，nextGuess就是平方根的近似值
#lastGuess初始值为1，如果nextGuess和lastGuess的差值小于一个很小的数，比如0.0001，就可以认为#nextGuess是n的平方根的近似值；否则，nextGuess成为下一次计算的lastGuess，近似过程继续执行
n = eval(input("输入"))
def get_num(n,last_guess):
nextguess = (last_guess+n/last_guess)/2
if abs(nextguess - last_guess) <0.0001:
return (nextguess)
else:
return get_num (n,nextguess)
print(get_num(n,1))
