• Demo 题记

    Demo 1

    输入一个摄氏温度的值，将它转变为华氏温度，并将结果输出

    1. #输入一个摄氏温度的值，将它转变为华氏温度，并将结果输出
    2. c = float(input("请输入摄氏温度："))
    3.  
    4. print("对应的华氏温度为%.2f"%(9*c/5+32))

    输入圆柱的半径和高，并利用如下公式计算圆柱体的底面积和体积。

    1. # 输入圆柱的半径和高，并利用如下公式计算圆柱体的底面积和体积。
    2. r = float(input("请输入圆柱体的半径:"))
    3. h = float(input("请输入圆柱体的高:"))
    4.  
    5. s = 3.14 * r *r
    6. print("圆柱体的底面积为:%.2f,圆柱体的体积为:%.2f"%(s,s*h))

    输入英尺数然后将它转换为米数，并输出结果，一英尺等于0.305米

    1. #输入英尺数然后将它转换为米数，并输出结果，一英尺等于0.305米
    2. y = float(input("请输入英尺数:"))
    3.  
    4. print("%.2F英尺 = %.2f米"%(y,0.305*y))

    读取小计和酬金率，然后计算小费以及合计金额。例如客户的小计为10元，酬金率为15%，那么小费是1.5元，合计金额为11.5元

    1. #读取小计和酬金率，然后计算小费以及合计金额。例如客户的小计为10元，酬金率为15%，那么小费是1.5元，合计金额为11.5元
    2. j = float(input("请输入小计总额:"))
    3. l = float(input("请输入酬金率:"))
    4.  
    5. x = j * l
    6. print("小费为:%.2f"%x)
    7. print("合计金额:%.2f"%(x + j))

    取一个0到1000之间的整数，并计算它各位数字之和

    1. #读取一个0到1000之间的整数，并计算它各位数字之和
    2. num = int(input("请输入一个0~1000之间的整数:"))
    3.  
    4. if 0 < num < 1000:
    5.     a = num % 10
    6.     b = (num - a) // 10 % 10
    7.     c = (num - a - b * 10) // 100
    8.  
    9. sum = a + b + c 
    10. print(sum)

    输入分钟数，然后将该分钟数转换为年数和天数，假定一年有365天

    1. #输入分钟数，然后将该分钟数转换为年数和天数，假定一年有365天
    2. min = int(input("请输入分钟数:"))
    3.  
    4. day = int(min / 60 / 24)
    5. year = int(min / 60 / 24 // 365)
    6. print(year, (day - year * 365))

    水从初始温度加热到最终温度是需要能量的，请计算需要多少能量，公式如下：

    这里的M是按千克计的水量，初始温度和最终温度均为摄氏度，热量Q以焦耳计

    Q = M ×（最终温度 – 初始温度）× 4184

    1. m = float(input("请输入水量:"))
    2. s = float(input("请输入水初始温度:"))
    3. d = float(input("请输入水最终温度:"))
    4.  
    5. print("所需的能量值:%.2f"%(m*(d - s)*4184))

    输入一个四位整数，并以反向顺序显示

    1. #输入一个四位整数，并以反向顺序显示
    2. num = int(input("请输入一个四位整数:"))
    3.  
    4. while num > 0:
    5.     s = num % 10
    6.     num //= 10
    7.     print(s)

    输入三角形的三个顶点坐标，并计算其面积，计算公式如下

    当三个点A、B、C的坐标分别为A(x1，y1)、B(x2，y2)、C(x3、y3)时，三角形面积为，

    S=(x1y2-x1y3+x2y3-x2y1+x3y1-x2y2)

    1. #输入三角形的三个顶点坐标，并计算其面积，计算公式如下
    2. # 当三个点A、B、C的坐标分别为A(x1，y1)、B(x2，y2)、C(x3、y3)时，三角形面积为，
    3. # S=(x1y2-x1y3+x2y3-x2y1+x3y1-x2y2)
    4. Ax,Ay = map(float,(input("请输入A的横纵坐标:").split()))
    5. Bx,By = map(float,(input("请输入B的横纵坐标:").split()))
    6. Cx,Cy = map(float,(input("请输入C的横纵坐标:").split()))
    7.  
    8. S = (Ax*By - Ax*Cy + Bx*Cy - Bx*Ay + Cx*Ay - Bx*By )
    9. print("面积S = %.2f"%S)

    输入你所在的时区，并输出当前的时间

    1. # 输入你所在的时区，并输出当前的时间
    2.  
    3. # 从datetime模块导入datetime类和timedelta类(表示时间间隔)
    4. from datetime import datetime,timedelta
    5.  
    6.  
    7. place = int(input("请输入时区："))
    8. # 获取当前时间
    9. now = datetime.now()
    10. # 将时间格式化为字符串
    11. time_8= now.strftime("%H:%M:%S")
    12.  
    13. if place == 8:
    14.   print(time_8)
    15. elif place == -5:
    16.   # 修改时间（将小时加11）
    17.   modified_time = now +timedelta(hours=11) 
    18.   time_5= modified_time.strftime("%H:%M:%S")
    19.   print(time_5)
    20. else:
    21.   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))

    1. # 输入三角形的三个顶点坐标，并计算该三角形的三个角分别是多少
    2.  
    3.  
    4. import math
    5.  
    6.  
    7. x1,y1,x2,y2,x3,y3=map(float,input("请输入顶点坐标，用空格隔开：").split())
    8. # 计算三条边长
    9. side1 = math.sqrt( (x1-x2)**2+(y1-y2)**2)
    10. side2 = math.sqrt((x2-x3)**2+(y2-y3)**2)
    11. side3 = math.sqrt((x1-x3)**2+(y1-y3)**2)
    12. # 公式计算（弧度制）
    13. cont1=math.acos((side1**2-side2**2-side3**2)/(-2*side2*side3))
    14. cont2=math.acos((side2**2-side1**2-side3**2)/(-2*side1*side3))
    15. cont3=math.acos((side3**2-side2**2-side1**2)/(-2*side1*side2))
    16. # 将弧度制转化为角度制
    17. angle_1=math.degrees(cont1)
    18. angle_2=math.degrees(cont2)
    19. angle_3=math.degrees(cont3)
    20. print("%.2f\n%.2f\n%.2f\n"%(angle_1,angle_2,angle_3))
    21.

    假设硬币种类分为：一元硬币、两角五分硬币、一角硬币、五分硬币、一分硬币

    输入总金额，并将总金额兑换成若干个硬币，并保证所兑换的硬币个数最少

    1. '''
    2. 假设硬币种类分为：一元硬币、两角五分硬币、一角硬币、五分硬币、一分硬币
    4. 输入总金额，并将总金额兑换成若干个硬币，并保证所兑换的硬币个数最少
    5. '''
    6. money = float(input("请输入总金额:"))
    7.  
    8. a = money // 1
    9. b = (money - a) // 0.25
    10. c = (money - a - (b*0.25))// 0.1
    11. d = (money - a - (b*0.25) - (c*0.1))// 0.05
    12. e = (money - a - (b*0.25) - (c*0.1) - (d*0.05))//0.01
    13. print("%.0f个一元硬币" %a)
    14. print("%.0f个两角五分硬币" %b)
    15. print("%.0f个一角硬币" %c)
    16. print("%.0f个五分硬币" %d)
    17. print("%.0f个一分硬币" %e)

    正多边形是边长相等的多边形，而且所有的角相等，计算正多边形的公式为

    1. '''正多边形是边长相等的多边形，而且所有的角相等，计算正多边形的公式为：'''
    2.  
    3. import math
    4.  
    5.  
    6. n , s = map(float,input("输入：\n").split())
    7. area = (n * s * s) / (4 * math.tan(math.pi/n))
    8. print("%.2f"%area)

    '''BMI是根据体重测量健康的方式，通过以千克为单位的体重除以以米为单位的身高的平方计算而出'''

    1. '''BMI是根据体重测量健康的方式，通过以千克为单位的体重除以以米为单位的身高的平方计算而出'''
    2. sg = float(input("请输入身高(m)："))
    3. tz = float(input("请输入体重(kg)："))
    4. BMI = tz / (sg*sg)
    5. if BMI < 18.5:
    6.     print("过轻")
    7. elif 18.5 <= BMI < 24:
    8.     print("正常")
    9. elif 24 <= BMI < 27:
    10.     print("过重")
    11. elif 27 <= BMI < 30:
    12.     print("轻度肥胖")
    13. elif 30 <= BMI < 35:
    14.     print("中度肥胖")
    15. elif BMI >= 35:
    16.     print("重度肥胖")

    一个年份如果能被4整除但不能被100整除，或者能被400整除，那么这个年份就是闰年

    1. '''一个年份如果能被4整除但不能被100整除，或者能被400整除，那么这个年份就是闰年'''
    2. year = int(input("请输入年份:"))
    3.  
    4. if year % 4 == 0 & year % 100 != 0 or year % 400 == 0:
    5.     print(f"{year}年是闰年")
    6. else:
    7.     print(f"{year}年是平年")

    随机产生一个两位数数字，然后用户输入一个两位数数字，并根据以下规则判定用户赢得的奖金是多少

    （1）输入的数字和随机产生的数字完全相同（包括顺序），奖金为10000元

    （2）输入的数字和随机产生的数字相同（不包括顺序），奖金为3000元

    （3）输入的数字和随机产生的数字有一位数相同，奖金为1000美元

    （4）输入的数字和随机产生的数字都不相同，没有奖金，0元

    1. # 中彩票
    2.  
    3.  
    4. import random
    5.  
    6.  
    7. input_num = int (input("输入："))
    8. input_str =  str(input_num)
    9. random_num = random.randint(10,99)
    10. random_str = str(random_num)
    11. print(random_num)
    12. if input_num ==random_num:
    13.   print("10000")
    14. elif random_str[0] ==  input_str[1] and random_str[1] == input_str[0]:
    15.   print("3000")
    16. 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]) :
    17.   print("1000")
    18. else:
    19.   print("0")

    求一元二次方程

    1. # 解一元二次方程
    2. # ax^2+bx+c=0 
    3.  
    4.  
    5. import math
    6.  
    7.  
    8. a,b,c =  map(float,input("输入：").split())
    9. if a==0:
    10.   print("输入不合法")
    11. elif b**2-4*a*c>0:
    12. #  round(number[, ndigits])----四舍五入保留ndigits位小数
    13.  print( round((-b+math.sqrt(b**2-4*a*c))/(2*a),2))
    14.  print( round((-b-math.sqrt(b**2-4*a*c))/(2*a),2))
    15.   
    16.  
    17.  
    18. elif b**2-4*a*c==0:
    19.   print(round((-b)/(2*a),2))
    20.  
    21.   
    22. elif b**2-4*a*c<0:
    23.   print("无实数解")

    解2×2线程方程

    1. # 解2×2线程方程
    2.  
    3.  
    4. a,b,c,d,e,f = map(float,input("输入：").split())
    5. # 前提：(ad - bc)不等于0
    6. # x = (ed - bf) / (ad - bc)
    7. # y = (af - ec) / (ad - bc)
    8. if (a*d - b*c) ==0:
    9.   print("无解")
    10. else:
    11.   x = (e*d - b*f) / (a*d - b*c)
    12.   y = (a*f - e*c) / (a*d - b*c)
    13.   print(x,y)

    未来是周几

    1. # 未来是周几
    2.  
    3.  
    4. week ,future_day = map(int ,input("输入：").split())
    5. day = (week+future_day)%7
    6. if day == 0:
    7.   print("星期天") 
    8. if day == 1:
    9.   print("星期一") 
    10. if day == 2:
    11.   print("星期二") 
    12. if day == 3:
    13.   print("星期三") 
    14. if day == 4:
    15.   print("星期四") 
    16. if day == 5:
    17.   print("星期五") 
    18. if day == 6:
    19.   print("星期六")

    本年中的第几天

    1. year,month,day = map(int,input("输入").split())
    2. # 定义每月的天数表
    3. month_day =[0,31,28,31,30,31,30,31,31,30,31,30,31]
    4. # 判断闰年，并对二月进行加一操作
    5. if (year %4 ==0 and year%100 ==0) or year%400 == 0:
    6.   month_day[2] += 1 
    7.   
    8. for i in range(0 , month):
    9.   day += month_day[i]
    10.  
    11. print(day)

    剪刀石头布

    1. import random
    2.  
    3.  
    4. use_num =int( input("输入："))
    5. com_num = random.randint(0,2)
    6. # 定义一个方法：将数字和字符转换，
    7. def vo(num):
    8.   if num ==0:
    9.     return " 剪刀"
    10.   elif num == 1:
    11.     return " 石头"
    12.   elif num ==2:
    13.     return " 布"
    14.   else :
    15.     return 0
    16.     
    17. # 对用户输入数据进行判断
    18. if vo(use_num)==0:
    19.   print("输入不合法")
    20.   
    21. else:
    22.   print("计算机输出"+vo(com_num))
    23.   print("用户出的"+vo(use_num))
    24.  
    25.   if com_num==use_num:
    26.     print("平手")
    27.   elif (com_num==1 and use_num==0) or(com_num==0 and use_num==2) or (com_num == 2 and use_num == 1):
    28.     print("计算机赢")
    29.   else:
    30.     print("用户赢")

    计算三角形的周长

    1.  
    2. side1,side2,side3 = map(int,input("输入：").split())
    3. if side1+side2>side3 and side1+side3>side2 and side2+side3>side1:
    4.   print(side1+side2+side3)
    5. else:
    6.   print("非法")
    7.

    判断一年中某天是星期几

    1. # 判断一年中某天是星期几
    2.  
    3. # 输入年、月、日三个数据，数据之间用空格分隔
    4. # 输出该日是周几
    5.  
    6. year,month,day = map(int,input("输入：").split())
    7.  
    8. # 一月和二月都是按照前一年的13月和14月来计数的，所以还得把年份改为前一年
    9. if month ==1 or month  == 2:
    10.   year-=1
    11.   month+=12
    12. h =int((day+26*(month+1)//10+year%100+year%100//4+year/100//4+5*year/100)%7)
    13. if h == 0:
    14.   print("星期六")
    15. elif h == 1:
    16.   print("星期天")
    17. elif h == 2:
    18.   print("星期一")
    19. elif h == 3:
    20.   print("星期二")
    21. elif h == 4:
    22.   print("星期三")  
    23. elif h == 5:
    24.   print("星期四")
    25. elif h == 6:
    26.   print("星期五")

    回文数

    1. # 回文数
    2.  
    3. # 输入一个三位整数，然后判断其是否为一个回文数
    4. # 如果一个数从左向右和从右向左读取时是一样的，那么这个数就是回文数
    5.  
    6.  
    7. # 用户需要判断的数字
    8. num = int (input("输入："))
    9. # num会在后续的操作中改值，所以需要定义一个变量存储num的值
    10. tem =num
    11. # 定义一个变量用于存储反转后的数字
    12. change_num =0
    13. while num >0:
    14.  change_num *= 10
    15.  change_num += num%10
    16.  num //= 10 
    17.  
    18. if tem == change_num:
    19.   print("yes")
    20. else:
    21.   print("no")

    判断两个矩形之间的位置关系

    1. # 判断两个矩形之间的位置关系
    2.  
    3. # 输入两行，每行四个数据，分别是矩形的中心坐标x、y和矩形的宽、高
    4. # 输出两者的关系
    5.  
    6.  
    7. x1,y1,winth1,high1 = map(float ,input("输入").split())
    8. x2,y2,winth2,high2 = map(float ,input("输入").split())
    9. level =abs(x1-x2) 
    10. vertical = abs(y1-y2)
    11. if level < (winth1+winth2)/2 and vertical<(high1+high2)/2:
    12.   print("包含")
    13. elif level<abs(winth1-winth2) and vertical<abs(high1-high2):
    14.   print("重叠")
    15. else:
    16.   print("相离")

    Demo 2

    打印数字I

    利用循环，寻找规律，打印如下数字模式：

    1. print("模式A")
    2. layer = 6
    3. for i in range(1,layer+1):
    4.     for j in range(1,i+1):
    5.         print(j,end="")
    6.     print()
    7. print("模式B")
    8. for i in range(layer,0,-1):
    9.     for j in range(1,i+1):
    10.         print(j,end="")
    11.     print()
    12. print("模式C")
    13. for i in range(layer+1):
    14.     print(" "*(layer - i),end=" ")
    15.     for j in range(i,0,-1):
    16.         print(j,end="")
    17.     print()
    18. print("模式D")
    19. for i in range(layer,0,-1):
    20.     print(" "*(layer - i),end=" ")
    21.     for j in range(1,i+1):
    22.         print(j,end="")
    23.     print()

    打印数字Ⅱ

    1. layer = 7
    2. for i in range(1,layer+1):
    3.     print(" "*(layer - i),end=" ")
    4.     for j in range(i , 0 ,-1):
    5.         print(j ,end="")
    6.     for j in range(2 , i+1):
    7.         print(j ,end="")
    8.     print()

    打印数字Ⅲ

    1. layer = 7
    2. for i in range(1,layer+1):
    3.     print(" "*2*(layer - i),end=" ")
    4.     for j in range(1 , i+1 ):
    5.         print(2**(j-1) ,end=" ")
    6.     for j in range(i-1 , 0,-1):
    7.         print(2**(j-1),end=" ")
    8.     print()

    打印菱形Ⅰ

    1. layer = int(input("输入：\n"))
    2. for i in range(layer // 2 + 2):
    3.     print(" "*(layer - i), end="")
    4.     for j in range(i ):
    5.         print("*",end=" ")
    6.     print()
    7. for i in range(layer // 2 , 0 , -1):
    8.     print(" " * (layer - i),end="")
    9.     for j in range(i):
    10.         print("*",end=" ")
    11.     print()

    打印菱形Ⅱ

    1. layer = int(input("输入：\n"))
    2. for i in range(layer // 2 + 2):
    3.     print(" "*(layer - i), end="")
    4.     for j in range(2 * i - 1):
    5.         if j == 0 or j == 2 * i - 2:
    6.             print("*",end="")
    7.         else:
    8.             print(" ",end="")
    9.     print()
    10. for i in range(layer // 2 , 0 , -1):
    11.     print(" " * (layer - i),end="")
    12.     for j in range(2 * i - 1):
    13.         if j == 0 or j == 2 * i - 2:
    14.             print("*",end="")
    15.         else:
    16.             print(" ",end="")
    17.     print()

    打印菱形Ⅲ

    1. layer = int(input("输入：\n"))
    2. for i in range(layer // 2 + 2):
    3.     print(" "*(layer - i), end="")
    4.     for j in range(2 * i - 1):
    5.         print("*",end="")
    6.     print()
    7. for i in range(layer // 2 , 0 , -1):
    8.     print(" " * (layer - i),end="")
    9.     for j in range(2 * i - 1):
    10.         print("*",end="")
    11.     print()

    猜数字

    计算机随机生成一个[0,100]之间的整数，程序提示用户连续地输入数字直到它与那个随机生成的数字相同

    对于用户输入的数字，程序会提示它是过高还是过低

    1. """猜数字"""
    2. import random
    3.  
    4.  
    5. computer = random.randint(0,101)
    6. person = int(input("请猜一个数："))
    7.  
    8. while computer != person:
    9.     if computer > person:
    10.         print("猜低了")
    11.     elif computer < person:
    12.         print("猜高了")
    13.     else:
    14.         print("恭喜你猜对了！！！")
    15.         break
    16.     person = int(input("请重新猜测："))
    17.  
    18. print(f"猜中的答案就是{person}")

    最大公约数I

    输入两个正整数，计算其最大公约数，例如4和2的最大公约数是2，16和24的最大公约数是8

    1. """最大公约数I"""
    2. num1 = int(input("输入a = "))
    3. num2 = int(input("输入b = "))
    4.  
    5. def gcd(num1, num2):
    6.     if num2 == 0:
    7.         return num1
    8.     else:
    9.         return gcd(num2, num1 % num2)
    10.  
    11. print(gcd(num1,num2))

    判断素数

    一个大于1的整数如果只能被正整数1和它本身整除，则它就是素数，例如2、3、5和7都是素数，而4、6、8、9则不是

    1. """判断素数"""
    2. a = int(input("输入：\n"))
    3. def sushu(n:int) -> int:
    4.     flog = 0
    5.     for i in range(2,a):
    6.         if a % i == 0:
    7.             flog = 1
    8.     if flog:
    9.         return 0
    10.     else:
    11.         return 1
    12.  
    13. if sushu(a):
    14.     print("yes")
    15. else:
    16.     print("no")

    最小公倍数

    输入两个正整数，计算其最小公倍数，例如4和2的最小公倍数是4，3和5的最小公倍数是15

    1. def gcd(num1, num2):
    2.     if num2 == 0:
    3.         return num1
    4.     else:
    5.         return gcd(num2, num1 % num2)
    6.  
    7. a = int(input("请输入a = "))
    8. b = int(input("请输入b = "))
    9.  
    10. c = gcd(a, b)
    11. print(f"a, b最小公倍数为：{a*b/c}")

    整数的素因子

    输入一个正整数，然后找出它所有的最小因子，也称之为素因子

    1. """整数的素因子"""
    2. num = int(input("请输入一个数："))
    3. num1 = 2
    4. while num >= num1:
    5.     if num % num1 == 0:
    6.         print(num1)
    7.         num = num / num1
    8.     else:
    9.         num1 += 1

    完全数

    如果一个正整数等于除了它本身之外所有正因子的和，那么这个数称为完全数

    1. """完全数"""
    2. a = int(input("输入：\n"))
    3. c = 0
    4. for i in range(1,a):
    5.     if a%i == 0:
    6.          c+=i
    7. if c==a:
    8.     print("Yes")
    9. else:
    10.     print("No")

    前50个素数

    打印前50个素数，每打印10个素数换行

    1. """打印前50个素数"""
    2. def sushu(n:int) -> int:
    3.     flog = 0
    4.     if n == 0:
    5.         return 1
    6.     for i in range(2,n):
    7.         if n % i == 0:
    8.             flog = 1
    9.     if flog:
    10.         return 0
    11.     else:
    12.         return 1
    13.  
    14. for i in range(1,51):
    15.     if sushu(i):
    16.         print(i)

    计算π

    你可以使用下面的数列近似计算π

    当i越大时，计算结果越近似于π

    1. sum = 0
    2. for i in range(1,100000):
    3.     if i % 2 ==0:
    4.         sum = sum - 1/(2*i-1)
    5.     elif i % 2 != 0:
    6.         sum = sum + 1/(2*i-1)
    7. pi = sum * 4
    8. print(pi)

    计算e

    你可以使用下面的数列近似计算e

    当i越大时，计算结果越近似于e

    1. e = 0
    2. for i in range(1,100):
    3.     for j in range(1,i+1):
    4.         i *= j
    5.         e = e + 1/i
    6. print(e)

     剪刀石头布II

    延伸【Demo21剪刀石头布I】的问题，利用循环将程序改为，计算机和电脑谁先赢三次，谁就是终极胜利者

    1. import random
    2.  
    3.  
    4. dn = 0
    5. you = 0
    6. while True:
    7.     b = random.randint(1,4)
    8.     a = int(input("请输入1-3（1代表剪刀，2代表石头，3代表布）之间整数："))
    9.     
    10.     if (a == 1 and b == 2) or (a == 2 and b == 3) or (a == 3 and b == 1):
    11.         print("兄弟再练练吧")
    12.         dn += 1
    13.         if dn == 3:
    14.             print("你输了")
    15.             break
    16.     elif a == b:
    17.         print("点到为止，平手")
    18.     else:
    19.         print("有两把刷子哟")
    20.         you += 1
    21.         if you == 3:
    22.             print("你赢了")
    23.             break

    组合问题I

    在数字范围[1,7]之间，任意选择两个不相同的数作为一个组合，输出每一组组合，并统计所有组合的个数

    注：组合（a，b）与组合（b，a）算同一种组合，只记录一次

    1. s = []
    2. for i in range(1,8):
    3.     for j in range(i+1,8):
    4.         s.append(f"{i},{j}")
    5. print(s)

    组合问题II

    有1、2、3、4这个四个数字，能组成多少个互不相同且无重复数字的三位数？分别又是多少？

    1. s = []
    2. num = 0
    3. for i in range(1,5):
    4.     for j in range(i+1,5):
    5.         for l in range(j+1,5):
    6.             num = str(i) + str(j) + str(l)
    7.             s.append(num)
    8. print(s)

    水仙花数

    水仙花数，是一个三位数，且这个数的个位、十位和百位的立方和等于该数字本身，例如$153=1^3+5^3+3^3$

    1. for i in range(100 , 1000):
    2.     a = i // 100
    3.     b = i % 100 // 10
    4.     c = i % 10
    5.     if i == a ** 3 + b ** 3 + c ** 3:
    6.         print(i,end=" ")

    青蛙跳台阶

    一只青蛙，一次可以跳一个台阶或者两个台阶，现有n个台阶，问该青蛙有多少种不同的跳法？

    例如：两个台阶，有两种跳法（1+1，2）；四个台阶，有五种跳法（1+1+1+1，2+1+1，1+2+1，1+1+2，2+2）

    1. # 青蛙跳楼梯：1 1 2 3 5 8 13······
    2. def qingwa(n : int) -> int:
    3.     if n == 1 or n ==2:
    4.         return n
    5.     return qingwa(n-1) + qingwa(n-2)
    6. print(qingwa(10))

    堆叠相加

    现有堆叠相加模式$a+aa+aaa+aaaa+aaaaa+......$

    例如：$2+22+222+2222+22222$，其中a为2，且有5组数字

    1. a = int(input("请输入一个数："))
    2. n = int(input("请输入循环次数："))
    3. sum = 0
    4. for i in range(1,n):
    5.     sum = sum + a*i
    6. print(sum)

    十进制转二进制

    输入一个十进制正整数，输出其二进制形式

    1. """十进制转二进制"""
    2. num = int(input("请输入一个十进制整数："))
    3.  
    4. e = ""
    5. while num > 0:
    6.     e = str(num % 2) + e
    7.     num = num // 2
    8. print(e)

    二进制转十进制

    输入一个二进制字符串，输出其对应的十进制数字

    1. # 二进制转十进制
    2.  
    3.  
    4. num = int(input("输入"))
    5.  
    6.  
    7. def change_num (num):
    8.   all = 0
    9.   str_num = str(num)
    10.   for i in range(0,len(str_num)):
    11.     all += int(str_num[i])
    12.     if i == len(str_num)-1: 
    13.       return all
    14.     all *= 2 
    15.  
    16.  
    17.  
    18. print(change_num(num))

    十进制转十六进制

    输入一个十进制正整数，输出其十六进制形式

    1. # 十进制转十六进制
    2.  
    3.  
    4. num = int(input("输入："))
    5.  
    6.  
    7. def change_num(num):
    8.   ox_num = "0123456789ABCDEF"
    9.   fin_num = ""
    10.   while num > 0:
    11.     get_num = num % 16
    12.     num //= 16
    13.     fin_num = ox_num[get_num] + fin_num  
    14.   return fin_num
    15.  
    16.  
    17. print(change_num(num))

    十六进制转十进制

    输入一个十六进制字符串，输出其对应的十进制数字

    1. # 十六进制转十进制
    2.  
    3.  
    4. num = str(input("输入："))
    5.  
    6.  
    7. def change_num(num):
    8.   ox_num = "0123456789abcdef"
    9.   all = 0
    10.   len_num = len(num)
    11.   for j in num:
    12.     for i in ox_num:
    13.       if i == j:
    14.         all += ox_num.index(i)* 16 ** (len_num-1)
    15.         len_num -= 1
    16.   return all
    17.   
    18.  
    19. print(change_num(num))

    最长公共前缀

    给定两个字符串 s1 和 s2 ，求两个字符串最长的公共前缀串，字符区分大小写

    1. # 给定两个字符串 s1 和 s2 ，求两个字符串最长的公共前缀串，字符区分大小写
    2.  
    3.  
    4. str1 = str(input("输入"))
    5. str2 = str(input())
    6.  
    7.  
    8.  
    9. def judge_str (str1,str2):
    10.   new_str = ""
    11.   
    12.   for i,j in zip(str1,str2):
    13. # zip() 函数来同时遍历两个字符串。
    14. # 如果两个字符串的长度不相等，zip() 函数将会以较短的字符串为准，忽略超过其长度的部分。
    15.     if i == j :
    16.       new_str += i
    17.     else:
    18.       break
    19.   return new_str
    20.  
    21.  
    22. print(judge_str(str1,str2))

    子串出现的次数

    给定两个字符串 s1 和 s2 ，求 s2 在 s1 中出现的次数，字符区分大小写，已匹配的字符不计入下一次匹配

    1. # 给定两个字符串 s1 和 s2 ，求 s2 在 s1 中出现的次数，
    2. #字符区分大小写，已匹配的字符不计入下一次匹配
    3.  
    4.  
    5. str1 = str(input("输入"))
    6. str2 = str(input("输入"))
    7.  
    8.  
    9. def judge_str(str1,str2):
    10.   count = 0
    11.   index_str1 = 0
    12.   while index_str1 <= len(str1)-len(str2) :
    13.       flog = True
    14.       tem = index_str1
    15.       for i in str2:
    16.         if str1[tem] == i:
    17.           tem += 1
    18.         else:
    19.             index_str1 += 1
    20.             flog = False
    21.             break
    22.       if flog:
    23.         count += 1
    24.         index_str1 += len(str2)
    25.       
    26.   return count
    27.  
    28.       
    29. print(judge_str(str1,str2))

    检测密码

    一些网站会给密码强加一些规则：

    （1）密码必须至少有8个字符

    （2）密码只能包含英文字母和数字

    （3）密码应该至少包含两个数字

    （4）密码应该至少包含两个大写字母

    如果密码符合规则，输出Yes；否则输出No

    1. # 一些网站会给密码强加一些规则：
    2. # （1）密码必须至少有8个字符
    3. # （2）密码只能包含英文字母和数字
    4. # （3）密码应该至少包含两个数字
    5. # （4）密码应该至少包含两个大写字母
    6. # 如果密码符合规则，输出Yes；否则输出No
    7.  
    8.  
    9. s1 = str(input("输入"))
    10.  
    11.  
    12. def string_pass(s1):
    13.   get_num = 0
    14.   get_capital = 0
    15.   if len(s1)<8:
    16.     return "no"
    17.   for i in s1:
    18.     if ord(i)<48 or 57<ord(i)<65 or 90<ord(i)< 96 or ord(i)>122:
    19.       return "no"
    20.     if 47<ord(i)<58:
    21.       get_num += 1
    22.     if 64<ord(i)<91:
    23.       get_capital += 1
    24.   if get_num < 2:
    25.     return "no"
    26.   if get_capital< 2:
    27.     return "no"
    28.   return "yes"
    29.  
    30.  
    31. print(string_pass(s1))

    回文素数

    回文素数是指一个数既是素数又是回文数，例如131既是素数也是回文数

    输出显示前100个回文素数，每行显示10个

    1. # 回文素数是指一个数既是素数又是回文数，例如131既是素数也是回文数
    2. # 输出显示前100个回文素数，每行显示10个
    3.  
    4.  
    5. import math
    6.  
    7.  
    8. # 找素数的函数
    9. def find_prime(num):
    10.   if num < 2 :
    11.     return False
    12.   if num == 2 or num == 3:
    13.     return True
    14.   elif num % 2 == 0:
    15.     return False
    16.   elif num % 3 == 0:
    17.     return False
    18.   
    19.   sqrt = int(math.sqrt(num))
    20.   i = 1
    21.   while (6*i-1) < sqrt :
    22.     if num % (6*i-1) == 0 or num % (6*i+1) == 0:
    23.       return False
    24.     i += 1
    25.   else:
    26.       return True
    27.   
    28.  
    29. # 找回文数
    30. def find_palindromic(num):
    31.   str_num = str(num)
    32.   i = 0
    33.   j = len(str_num)-1
    34.   while i < j:
    35.     if str_num[i] != str_num[j]:
    36.       return False
    37.     i += 1
    38.     j -= 1
    39.   return True  
    40.  
    41. i = 100
    42. count = 0
    43. while count < 100:
    44.   if find_prime(i) and find_palindromic(i):
    45.     print(str(i) +" ",end="")
    46.     count += 1
    47.     if count % 10 == 0:
    48.       print()
    49.   i += 1

    反素数

    反素数是指一个将其逆向拼写后也是一个素数的非回文数，例如17和71都是素数但不是回文数，且反转后依旧是素数

    输出显示前100个反素数，每行显示10个

    1. # 反素数是指一个将其逆向拼写后也是一个素数的非回文数，例如17和71都是素数但不是回文数，且反转后依旧是素数
    2. # 输出显示前100个反素数，每行显示10个
    3.  
    4.  
    5. import math
    6.  
    7.  
    8. # 质数
    9. def is_prime(num):
    10.   if num<2:
    11.     return False
    12.   if num == 2 or num ==3:
    13.     return True
    14.   if num % 2 == 0 or num % 3 == 0:
    15.     return False
    16.   
    17.   sqrt_num =int(math.sqrt(num))
    18.   k = 1
    19.   while (6*k-1)
    20.     if num % (6*k-1) == 0 or num % (6*k+1) == 0:
    21.       return False
    22.     k += 1
    23.   return True
    24.  
    25.  
    26. # 回文数
    27. def is_palindromic (num):
    28.   str_num =  str(num)
    29.   i = 0
    30.   j = len(str_num)-1
    31.   while i < j:
    32.     if str_num[i] != str_num[j]:
    33.       return False
    34.     i += 1
    35.     j -= 1
    36.   return True
    37.  
    38.  
    39.  
    40. # 反转
    41. def get_sort_num(num):
    42.   str_num = str(num)
    43.   reversed_str =  str_num[::-1]
    44.   return int(reversed_str)
    45.  
    46. count = 0
    47. i = 17
    48. while count < 100:
    49.   if is_prime(i) and is_prime(get_sort_num(i))  and not is_palindromic(i):
    50.     print (str(i)+" ",end="")
    51.     count += 1
    52.     if count % 10 == 0:
    53.       print()
    54.   i += 1
    55.

    双素数

    双素数是指一对差值为2的素数，例如3和5就是一对双素数，5和7也是一对双素数

    输出显示小于1000的双素数

    1. # 双素数是指一对差值为2的素数，例如3和5就是一对双素数，5和7也是一对双素数
    2. # 输出显示小于1000的双素数
    3.  
    4.  
    5. import math
    6.  
    7.  
    8. # 质数
    9. def is_prime(num):
    10.   if num<2:
    11.     return False
    12.   if num == 2 or num ==3:
    13.     return True
    14.   if num % 2 == 0 or num % 3 == 0:
    15.     return False
    16.   
    17.   sqrt_num =int(math.sqrt(num))
    18.   k = 1
    19.   while (6*k-1)
    20.     if num % (6*k-1) == 0 or num % (6*k+1) == 0:
    21.       return False
    22.     k += 1
    23.   return True
    24.  
    25.  
    26. i = 1
    27. while i+2 < 1000:
    28.   if is_prime(i):
    29.     if is_prime(i+2):
    30.       print(f"[{i},{i+2}] ",end="")
    31.   i += 2

    梅森素数

    如果一个素数可以写成$2^p-1$的形式，其中p是某个正整数，那么这个素数就称作梅森素数

    输出p≤31的所有梅森素数

    1. # 如果一个素数可以写成2**p-1的形式，其中p是某个正整数，那么这个素数就称作梅森素数
    2. # 输出p≤31的所有梅森素数
    3.  
    4.  
    5. import math
    6.  
    7.  
    8. # 质数
    9. def is_prime(num):
    10.   if num<2:
    11.     return False
    12.   if num == 2 or num ==3:
    13.     return True
    14.   if num % 2 == 0 or num % 3 == 0:
    15.     return False
    16.   
    17.   sqrt_num =int(math.sqrt(num))
    18.   k = 1
    19.   while (6*k-1)
    20.     if num % (6*k-1) == 0 or num % (6*k+1) == 0:
    21.       return False
    22.     k += 1
    23.   return True
    24.  
    25.  
    26. p = 1
    27. while p < 32:
    28.   if is_prime(2**p-1):
    29.     print(2**p-1)
    30.   p +=1

    平方根的近似求法

    有几种实现开平方$\sqrt{n}$的技术，其中一个称为巴比伦法

    它通过使用下面公式的反复计算近似地得到：

    当nextGuess和lastGuess几乎相同时，nextGuess就是平方根的近似值

    lastGuess初始值为1，如果nextGuess和lastGuess的差值小于一个很小的数，比如0.0001，就可以认为nextGuess是n的平方根的近似值；否则，nextGuess成为下一次计算的lastGuess，近似过程继续执行

    编写代码，求解n的平方根的近似值

    1. # 平方根的近似求法
    2. #方法：nextGuess=(lastGuess+n/lasetGuess)/2
    3. #当nextGuess和lastGuess几乎相同时，nextGuess就是平方根的近似值
    4. #lastGuess初始值为1，如果nextGuess和lastGuess的差值小于一个很小的数，比如0.0001，就可以认为#nextGuess是n的平方根的近似值；否则，nextGuess成为下一次计算的lastGuess，近似过程继续执行
    5.  
    6.  
    7. n = eval(input("输入"))
    8.  
    9.  
    10. def get_num(n,last_guess):
    11.  
    12.   nextguess = (last_guess+n/last_guess)/2
    13.   if abs(nextguess - last_guess) <0.0001:
    14.     return (nextguess)
    15.   else: 
    16.     return get_num (n,nextguess)
    17.   
    18.  
    19. print(get_num(n,1))

  • 相关阅读:
    Mybatis快速上手
    BGP配置和应用案例
    MySQL数据库——视图的更新、视图作用以及案例
    React 组件基础
    【故障分类】基于注意力机制的卷积神经网络结合双向长短记忆神经网络CNN-BiLSTM-attention实现数据分类附matlab代码
    【毕业设计】基于stm32的便携式U盘设计与实现 - stm32制作U盘
    在iframe标签中操作外层dom
    17 多远线性回归
    [JAVA]通过HashMap实现的增删改查小例子
    【无公网IP】在公网环境下Windows远程桌面Ubuntu 18.04
  • 原文地址：https://blog.csdn.net/m0_74747565/article/details/133904230