Demo01
#摄氏温度转化为华氏温度
print("输入一个值表示摄氏温度celsius")
celsius = float(input())
print("输出华氏温度fahrenheit,结果保留一位小数")
fahrenheit = (9/5)*celsius+32
print(f"转换后的华氏温度：{fahrenheit:.2f}")
Demo02
"""
计算圆柱体的体积
area = radius*radius*pi
volume = area*height
"""
import math
print("输入圆柱体的的半径和高，并利用公式计算圆柱体的底面积和体积")
# 获取用户输入的半径和高度
radius,height = map(float,input().split())
# 计算底面积和体积
area = radius * radius * math.pi
volume = area * height
# 输出底面积和体积
print(f"底面积：{area:.2f}")
print(f"体积： {volume:.2f}")
Demo03
"""
将英尺数转换成米数
1feet = 0.305meters
"""
print("输入一个数据表示英尺数：")
feet = float(input())
meters = feet * 0.305
print(f"转换结果：{meters:.4f}")
Demo04
"""
题目描述
读取小计和酬金率，然后计算小费以及合计金额。例如客户的小计为10元，酬金率为15%，那么小费是
1.5元，合计金额为11.5元
输入输出描述
分别输入小计和酬金率，两个数据用之间用空格分隔----subtotal,fee rate
输出两行，第一行为小费，第二行为合计金额，结果保留两位小数----tip,amount
"""
print("请输入消费小计和酬金率：")
# 输入小计和酬金率
subtotal,feeRate = map(float,input().split())
# 计算小费和合计金额
tip = subtotal*feeRate/100
amount = subtotal * (1+feeRate/100)
# 输出小费和合计金额
print(f"小费：{tip:.2f}")
print(f"合计金额：{amount:.2f}")
Demo05
"""
对一个整数中的各位数字求和
题目描述
读取一个0到1000之间的整数，并计算它各位数字之和
输入输出描述
输入一个[0,1000]之间的整数
输出该数字的各位数字之和----one ten hundred
"""
print("请输入一个整数：")
number = int(input())
hundred = number // 100
ten = number % 100 // 10
one = number % 100 % 10
sum = hundred + ten + one
print("各位数之和为：",sum)
Demo06
"""
计算年数和天数
题目描述
输入分钟数，然后将该分钟数转换为年数和天数，假定一年有365天
输入输出描述
输入一个分钟数----minute
输出两行，第一行为年数，第二行为天数----year、day
"""
print("请输入一个分钟数：")
minute = int(input())
# 计算天数和年数
hours = minute // 60
days = hours // 24
years = days //365
days = days % 365
print("年数：", years, "天数：",days)
Demo07
"""
计算能量
题目描述
水从初始温度加热到最终温度是需要能量的，请计算需要多少能量，公式如下：
Q = M * (finalT - initialT) * 4184
这里的M是按千克计的水量，初始温度和最终温度均为摄氏度，热量Q以焦耳计
输入输出描述
输入三行数据，第一行输入水量，第二行输入初始温度，第三行输入最终温度
输出所需的能量值，结果保留一位小数
"""
print("输入水量")
M = float(input())
print("输入初始温度")
initialT = float(input())
print("输入最终温度")
finalT = float(input())
Q = M * (finalT - initialT )* 4184
print("所需要的能量是：",Q,"J")
Demo08
"""
分割数字
题目描述
输入一个四位整数，并以反向顺序显示
输入输出描述
输入一个四位整数
输出四行，第一行为个位，第二行为十位，第三行为百位，第四行为千位 one、ten、hundred、thousand
"""
print("请输入一个数字：")
numbers = int(input())
thousand = numbers // 1000
hundred = numbers %1000 // 100
ten = numbers % 1000 % 100 // 10
one = numbers % 10
print(one)
print(ten)
print(hundred)
print(thousand)
Demo09
"""
计算三角形的面积（海伦公式）
输入六个数据，分别表示三角形三个顶点的坐标x1、y1、x2、y2、x3和y3，数据之间用空格分隔
向量叉积的几何意义在二维空间中正是平行四边形或三角形的有向面积。
输出三角形的面积，结果保留一位小数
"""
print("输入六个数据，分别表示三角形三个顶点的坐标x1、y1、x2、y2、x3和y3，数据之间用空格分隔:")
x1, y1, x2, y2, x3, y3 = map(float, input().split())
# 不妨用向量的叉积计算三角形面积
area = 0.5 * ((x2 - x1 ) * (y3 - y1) - (x3 - x1) * (y2 - y1))
if area < 0 :
area = -area
print("三角形的面积为：", area)
Demo10
# 显示当前时间
"""
题目描述
输入你所在的时区，并输出当前的时间
输入输出描述
输入时区，如东八区为8，西五区为-5
输出二十四小时制的时间，格式为 时:分:秒
"""
import time
# 输入时区
timezone = eval(input("东区输入正数，西区输入负数"))
#得到从1970年1月1日至今渡过多少秒
sum_sec = time.time()
# 计算从今天零时起到此刻渡过多少秒
today_sum_sec = sum_sec % (60 * 60 * 24)
# 计算格林尼治时间的时：分：秒
today_hours = today_sum_sec // (60 * 60)
today_mintes = today_sum_sec // 60 % 60
today_sec = today_sum_sec % 60
if today_hours + timezone < 0 :
print("%d时:%d分:%d秒" %(today_hours - timezone +24 , today_mintes, today_sec))
elif today_hours + timezone > 24 :
print("%d时:%d分:%d秒" %(today_hours + timezone -24 , today_mintes, today_sec))
else :
print("%d时:%d分:%d秒" %(today_hours + timezone , today_mintes, today_sec))
Demo11
# 计算三角形的三个角
"""
输入三角形的三个顶点坐标，并计算该三角形的三个角分别是多少（角度制）
其中a、b、c分别表示三条边，A、B、C分别表示三边对应的角
输入输出描述
输入六个数据，分别表示三角形三个顶点的坐标x1、y1、x2、y2、x3和y3，数据之间用空格分隔
输出三行，分别为A、B、C三个角的度数，结果保留两位小数
"""
import math
x1,y1,x2,y2,x3,y3 = map(float,input("请输入三个顶点的坐标x1、y1、x2、y2、x3和y3，数据之间用空格分隔").split())
# 计算三个边
a = ((x1 - x2)**2 + (y1 - y2)**2)**0.5
b = ((x1 - x3)**2 + (y1 - y3)**2)**0.5
c = ((x3 - x2)**2 + (y3 - y2)**2)**0.5
# 计算三个角的弧度值
A_rad = math.acos((b**2 + c**2 - a**2) / (2 * b * c))
B_rad = math.acos((a**2 + c**2 - b**2) / (2 * a * c))
C_rad = math.acos((a**2 + b**2 - c**2) / (2 * b * a))
# 计算角度
A_dge = math.degrees(A_rad)
B_dge = math.degrees(B_rad)
C_dge = math.degrees(C_rad)
print(f"{A_dge:.2f}\n{B_dge:.2f}\n{C_dge:.2f}" )
Demo12
"""
最小硬币数
题目描述
假设硬币种类分为：一元硬币、两角五分硬币、一角硬币、五分硬币、一分硬币
输入总金额，并将总金额兑换成若干个硬币，并保证所兑换的硬币个数最少
输入输出描述
输入总金额
输出每种硬币的个数---_100fen _25fen _10fen _5fen _1fen
"""
# 总金额的输入
sumMoney = eval(input("请输入总金额"))
# 对总金额百倍处理
sumMoney = int(100 * sumMoney)
# 计算各硬币数
_100fen = sumMoney // 100
_25fen = sumMoney % 100 // 25
_10fen = sumMoney % 25 // 10
_5fen = sumMoney % 10 // 5
_1fen = sumMoney % 5
print("最少硬币数为：", _100fen + _25fen + _10fen + _5fen + _1fen ,"个")
print("一元硬币枚数为：%d 两角五分硬币的枚数为: %d 一角硬币的枚数为：%d 五分硬币的枚数为： %d 一分硬币的枚数为：%d"
%( _100fen, _25fen, _10fen, _5fen, _1fen))
# print(f"一元硬币枚数为：{_100fen} 五角硬币的枚数为：{_25fen} 一角硬币的枚数为：{_10fen} 五分硬币的枚数为：{_5fen} 一分硬币的枚数为：{_1fen}")
Demo13
"""
计算正多边形面积---边数n、边长s
"""
import math
n, s = map(float , input("请输入边数和边长:").split())
# 计算多边形面积
area = n * s ** 2 / (4 * math.tan(math.pi / n))
print(f"多边形面积为：{area:.2f}")
Demo14
# 计算BMI评定数值
weight, height = map(float,input("请输入你的身高和体重：").split())
BMI = weight / height ** 2
if BMI < 18.5 :
print("超轻")
elif BMI < 25.0 :
print("标准")
elif BMI <30.0 :
print("超重")
else :
print("肥胖")
Demo15
# 判断闰年、输出Yes or No
Ipyears = eval(input("请输入需要判断的年号："))
if Ipyears % 4 == 0 and Ipyears % 100 != 0 or Ipyears % 400 == 0 :
print("Yes")
else :
print("No")
Demo16
import random
# 生成随机数
ranNum = random.randint(10,99)
print(ranNum)
# 取随机数的个、十位
r1 = ranNum % 10
r2 = ranNum // 10
# 获取用户输入的中将号，并解析出个、十位
userNum = eval(input("请输入一个两位数："))
u1 = userNum % 10
u2 = userNum // 10
if r1 == u1 and r2 == u2:
print(10000)
elif r1 == u2 and r2 == u1 :
print(5000)
elif r1 == u1 or r1 == u2 or r2 == u1 or r2 == u2 :
print(3000)
else :
print(0)
Demo17
# 计算一元二次方程
a, b, c = map(float, input("请输入二元一次方程组的实数部分：").split())
# 计算判别式
delt = b**2 - 4 * a * c
# 有两解
if delt > 0 :
x1 = (-b + delt ** 0.5) / (2 * a)
x2 = (-b - delt ** 0.5) / (2 * a)
print(x1)
print(x2)
#有一解
elif delt == 0 :
x = -b / (2 * a)
print(x)
# 无实数解
elif delt < 0 :
print("无实数解")
Demo18
# 解线性方程
# 输入a\b\c\d\e\f
a, b, c, d, e, f = map(float , input("请输入线性方程的参数：").split())
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 , sep = "\n")
Demo19
# 未来是周几
"""
题目描述
输入表示今天是一周内哪一天的数字（星期天是0，星期一是1，...，星期六是6）
并输入今天之后到未来某天的天数，然后输出该天是星期几
输入输出描述
输入两个数据，分别表示今日星期几的数字和未来某天的天数，数据之间用空格分隔
输出未来某天是星期几
"""
def today_is_weekday(today ,days ):
weekdays = ["天" ,"一" ,"二" ,"三" ,"四" ,"五" ,"六" ]
return weekdays[(today + days) % 7]
today , days = map(int , input("输入两个数据，分别表示今日星期几的数字和未来某天的天数，数据之间用空格分隔:").split())
print("未来是星期",today_is_weekday(today ,days), sep = "")
Demo20
# 本年中的第几天
"""
题目描述
给定某年、某月、某日的一个日期，计算该日是今年中的第几天
输入输出描述
输入三个数据分别表示年、月、日，数据之间用空格分隔
输出该日是今年中的第几天
"""
# 将天数解析代码封装成函数
def calculate_total_days(year , month , day):
days_in_month_leap = [31 ,29 ,31 ,30 ,31 ,30 ,31 ,31 ,30 ,31 ,30 ,31]
days_in_month_common = [31 ,28 ,31 ,30 ,31 ,30 ,31 ,31 ,30 ,31 ,30 ,31]
# 判断是否是闰年
if year % 400 == 0 and (year % 4 == 0 or year % 100 == 0) :
total_days = sum(days_in_month_leap[:month - 1]) + day
else :
total_days = sum(days_in_month_common[:month - 1]) + day
return total_days
year , month , day = map(int , input("输入三个数据分别表示年、月、日，数据之间用空格分隔").split())
print(calculate_total_days(year , month , day))
Demo21
# 剪刀 石头 布---分别对应 0 1 2
import random
# 计算机生成随机数
cuNum = random.randint(0,2)
myNum = eval(input("请输入随机数[0,2]得随机数："))
ArrList = ["剪刀", "石头", "布"]
if cuNum == myNum :
print("计算机出的是：",ArrList[cuNum])
print("我们出的是：",ArrList[myNum])
print("平局")
elif ArrList[cuNum] == "剪刀" and ArrList[myNum] == "布" or ArrList[cuNum] == "石头" and ArrList[myNum] == "剪刀"or ArrList[cuNum] == "布" and ArrList[myNum] == "石头":
print("计算机出的是：",ArrList[cuNum])
print("我们出的是：",ArrList[myNum])
print("计算机胜出")
else:
print("计算机出的是：",ArrList[cuNum])
print("我们出的是：",ArrList[myNum])
print("我们胜出")
Demo22
#输入三条边，判断是否能构成三角形，并输出三角形的周长
a , b , c = map(float , input("输入三边长度:").split())
# 先判断合法性，再计算周长
if a + b - c <= 0 :
print("非法")
else :
print(a + b + c)
Demo23
# 一周的星期几
"""
题目描述
泽勒的一致性是一个由泽勒开发的算法，用于计算一周的星期几，公式如下：
（1） 是指一周的星期几（0表示星期六、1表示星期天、...、6表示星期五）
（2） 是一个月的哪一天
（3） 是月份（3表示三月、4表示四月、...、12表示十二月），其中一月和二月都是按照前一年的13
月和14月来计数的，所以还得把年份改为前一年
（4） 是世纪数，即
（5） 是一个世纪的某一年，即
（6） 为向下取整符号
"""
# 创建可以调用的函数
def the_day_of_week(years , months , days):
weekdays = ["星期六","星期天","星期一","星期二","星期三","星期四","星期五" ]
q = days
if months == 1 :
m = 13
years = years - 1
elif months == 2:
m = 14
year = years - 1
else:
m = months
j = years // 100
k = years % 100
h = (int)(q + (26 * (int)(m + 1) / 10) + k + (int)(k / 4) + (int)(j / 4) + 5 * j ) % 7
return weekdays[h]
year , month , day = map(int , input("请输入年月日").split())
print(the_day_of_week(year , month , day))
Demo24
"""
输入八个数据，分别为x1 y1 x2 y2 x3 y3 x4 y4，数据之间用空格分隔
如有交点则输出交点的坐标x y，否则输出两条直线平行
"""
def find_intersection(x1 , y1 , x2 , y2 , x3 , y3 , x4 , y4):
# 计算第一条直线的斜率和截距
m1 = (y1 - y2) / (x1 - x2)
b1 = y1 - m1 * x1
# 计算第二条直线的斜率和截距
m2 = (y3 - y4) / (x3 - x4)
b2 = y3 - m2 * x3
# 检索两条直线是否平行
if m1 == m2:
return "平行"
# 如果不是平行的，那么我们可以使用斜率和截距来找到交点
x = (b2 - b1) / (m1 - m2)
y = m1 * x + b1
return round(x , 2) , round(y , 2)
# 输入坐标
x1 , y1 , x2 , y2 , x3 , y3 , x4 , y4 = map(float , input("请输入坐标：").split())
outPutData = find_intersection(x1 , y1 , x2 , y2 , x3 , y3 , x4 , y4)
print(outPutData)
Demo25
"""
回文数
题目描述
输入一个三位整数，然后判断其是否为一个回文数
如果一个数从左向右和从右向左读取时是一样的，那么这个数就是回文数
输入输出描述
输入一个数字
输出Yes表示是回文数，否则输出No
在 Python 中，str(num) 将整数 num 转换为字符串类型，方便我们对数字进行字符操作。
[::-1] 是 Python 切片操作符，它用于返回原字符串的一个子序列。在这里，冒号前后的
两个空位置分别代表原字符串的起始和结束索引，而 -1 表示步长为 -1，即从后向前取值
。因此，str(num)[::-1] 实际上就是获取 str(num) 的反向字符串，即原字符串的逆转。
所以，return str(num) == str(num)[::-1] 这一行代码的意思是：
判断将整数 num 转换成字符串后再逆转过来，看是否与原字符串相同。
如果相同，说明 num 是回文数，函数返回 True；否则返回 False。
"""
def is_palindrome(num):
return str(num) == str(num)[::-1]
num = eval(input("请输入一个整数："))
if is_palindrome(num):
print("Yes")
else:
print("No")
Demo26
"""
两个矩形
题目描述
判断两个矩形之间的关系：包含，重叠，相离
输入输出描述
输入两行，每行四个数据，分别是矩形的中心坐标x、y和矩形的宽、高
输出两者的关系
"""
print("输入两行，每行四个数据，分别是矩形的中心坐标x、y和矩形的宽、高")
x1 , y1 ,weight1 ,height1 = map(float,input().split())
x2 , y2 ,weight2 ,height2 = map(float,input().split())
# 计算矩形1的左下和右下角坐标
r1U = y1 + height1 / 2
r1D = y1 - height1 / 2
r1L = x1 - weight1 / 2
r1R = x1 + weight1 / 2
# 计算矩形2的左下和右上角坐标
r2U = y2 + height2 / 2
r2D = y2 - height2 / 2
r2L = x1 - weight2 / 2
r2R = x1 + weight2 / 2
# 矩形在坐标系中都是正放(故通过计算每个矩形的左下和右上的坐标进行判断)
if r1R < r2L or r1L > r2R :
# 如果矩形1的左右边界都不在矩形2的左右边界之间，则相离
print("相离")
elif r1U < r2D or r1D > r2U:
# 如果矩形1的上下边界都不在矩形2的上下边界之间，则相离
print("相离")
elif r1D > r2D and r1U < r2U and r1R < r2R and r1L > r2L or r2D > r1D and r2U < r1U and r2R < r1R and r2L > r1L:
# 各边界上限都小，则包含
print("包含")
else:
print("重叠")
Demo27
print("模式A")
for i in range(1 , 7):
for j in range(1 , i + 1):
print(j , end = " ")
print()
print("模式B")
for i in range(6 , 0 , -1):
for j in range(1 , i + 1):
print(j , end = " ")
print()
print("模式C")
for n in range(1 , 7):
for i in range(6 - n):
print(" " , end = " ")
for j in range(n , 0 ,-1):
print(j ,end = " ")
print()
print("模式D")
for n in range(6 ,0 ,-1 ):
for i in range(0 , 6- n ):
print(" " , end = " ")
for j in range(1 , n + 1):
print(j ,end = " ")
print()
Demo28
for n in range( 1,8 ):
for i in range(7-n):
print(" " ,end = " ")
for j in range(1-n , n ):
print(abs(j)+1 , end = " ")
print()
Demo29
for n in range(1, 8):
for i in range(7 - n):
print(" ", end = " ")
for j in range(1 - n, n):
num = 2 ** (n - 1 - abs(j))
print("%-2d" % (num), end = " ")
print()
Demo30
n = eval(input("请输入层高"))
for m in range (- n // 2 , n // 2 + 1):
for i in range(abs(m)):
print("" , end = " ")
for j in range(n // 2 + 1 - abs(m)):
print("*" , end = " ")
print()
Demo31
n = eval(input("输入层高："))
for m in range(1 , n + 1):
for i in range(abs(n // 2 + 1 - m)):
print("" , end = " ")
for j in range(1 , m + 1):
if j <= m and m + j <= n + 1:
if j == m or j == 1 or m + j == n + 1:
print("*" , end = " ")
else:
print(" " , end = " ")
print()
Demo32
# 打印*中无空格的菱形
n = eval(input("请输入层高："))
for m in range(- n // 2 , n // 2 + 1):
for i in range(abs(m)):
print(end = " ")
for j in range(n - abs(m) * 2):
print(end = "*")
print()
Demo33
import random
# 生成随机数
raNum = random(0 , 100)
# 放置哨兵
flog = True
while flog:
# 猜数
myNum = eval(input("请输入数字"))
if raNum < myNum:
print("高了")
elif raNum > myNum:
print("低了")
else:
# 相等
print("猜中了")
flog == Flase
Demo34
num1 , num2 = map(input("输入两个数求最小公因数:").split())
min_num = min(num1 , num2)
for n in range(min_num , 0 , -1):
if num1 % n == 0 and num2 % n == 0:
print("最小公因数是：", num)
break
Demo35
num = eval(input("请输入一个数："))
# 设置哨兵
flag = True
for n in range(2 , num // 2 + 1):
if num % n == 0 :
flag = False
break
if flag == True :
print("Yes")
else :
print("No")
Demo36
# 寻找最小公倍数
num1 , num2 = map(int , input("请输入两个整数数：").split())
max = num1
if max < num2:
max = num2
# 两个都为0时即为其最小公倍数
while max % num1 != 0 or max % num2 != 0:
max += 1
print(max)
Demo37
# 整是的素因子
num = eval(input("请输入一个整数："))
nums = 2
while num != 1 :
if num % nums == 0 :
print(nums , end = " ")
num /= nums
else:
nums += 1
Demo38
# 寻找完全数
"""
如果一个正整数等于除了它本身之外所有正因子的和，那么这个数称为完全数
例如 6 = 3 + 2 + 1，28 = 14 + 7 + 4 + 2 + 1
"""
num = eval(input("请输入一个正整数："))
# 采用for...slse:
sum = 1
for i in range(2 , num):
if num % i == 0:
sum += i
if sum == num:
print("Yes")
else:
print("No")
Demo39
# 打印前50个素数，每10个为一行
num = 2
count = 0
while count != 50:
flag = True
for n in range(2 , num // 2 + 1):
if num % n == 0:
flag = False
break
# 是素数怎么处理
if flag:
print(num , end = "\t")
count += 1
if count % 10 == 0:
print()
num += 1
Demo40
#计算Π
"""
pi = 4(1 - (1/3) + (1/5) -...+((-1) ** (i + 1) / 2 * i - 1))
当i的值越大时，计算结果越接近Π
"""
n = eval(input("请输入i的大小："))
sums = 0
for i in range(1 , n + 1):
sums += (-1) ** (i + 1) / (2 * i - 1)
print("%.7f" %(4 * sums))
Demo41
# 计算e
"""
e = 1 + 1 / 1! + 1 / 2! + 1 / 3! + ... + 1 / i!
当i越大时计算结果越接近e
"""
n = eval(input("请输入你的i:"))
sums = 1
count = 1
for i in range(1 , n + 1):
count *= i
sums += 1 / count
print("%.7f" %(sums))
Demo42
import random
ArrList = ["剪刀" , "石头" , "布"]
count1 = 0 #记录人的取胜场次
count2 = 0 #记录计算机取胜的场次
while count1 < 3 and count2 < 3:
# 计算机生成随机数
cuNum = random.randint(0,2)
myNum = eval(input("请输入随机数[0,2]得随机数且0是剪刀，1是石头，2是布："))
if cuNum == myNum :
print("计算机出的是：",ArrList[cuNum])
print("我们出的是：",ArrList[myNum])
print("平局")
elif ArrList[cuNum] == "剪刀" and ArrList[myNum] == "布" or ArrList[cuNum] == "石头" and ArrList[myNum] == "剪刀"or ArrList[cuNum] == "布" and ArrList[myNum] == "石头":
count2 += 1
else:
count1 += 1
print("人胜出" , count1 , "局")
print("电脑胜出" , count2 ,"局")
if count1 == 3:
print("人取得最终胜利")
else:
print("电脑取得最终胜利")
Demo43
"""
在数字范围[1,7]之间，任意选择两个不相同的数作为一个组合，输出每一组组合，并统计所有组合的个
数
注：组合（a，b）与组合（b，a）算同一种组合，只记录一次
"""
count = 0
for i in range(1 , 8):
for j in range( i + 1 , 8):
print("(%d,%d)" %(i , j) , end = " ")
count += 1
print()
print("组合数：",count)
Demo44
"""
题目描述
有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:
count += 1
print(i , j , k , sep = "")
print("这样的数的个数为：", count , sep = "")
Demo45
# 寻找水仙花数100~999
arr[num for num in (100 , 1000) if (num // 100) ** 3 + (num // 10 % 10 ) ** 3 + (num % 100) ** 3]
print(arr)
Demo46
n = eval(input("请输入台阶数："))
a = 1
b = 2
for i in range(n - 2):
c = a + b
a = b
b = c
print(c)
Demo47
num , n = map(int ,input().split())
sum = 0
nums = 0
for i in range(n):
nums = 10 * nums + num
sum += nums
print(sum)
Demo48
"""
十进制转二进制
"""
num = eval(input("请输入一个十进制的正整数："))
list = ""
while num != 0:
# num / 2 = nums...0 或 1 我们num除后一直取整直达为0为止，余数我们道取即可
# 注意序列相加的技巧
list = str(num % 2) + list
num = num // 2
print(list)
Demo49
# 二进制转十进制
numList = input("请输入一串二进制数：")
num = 0
count = 0
# 如arr = "ABCDEF" arr[0] = "A" arr[1] = "B"
for i in range(len(numList) - 1 , -1 , -1 ):
num += int(numList[i]) * 2 ** count
count += 1
print(num)
Demo50
num = eval(input())
s = ""
while num != 0:
y = num % 16
if y >= 10:
y = chr(ord('A') + y - 10)
s = str(y) + s
num = num // 16
print(s)
Demo51
# 十六进制转是进制
num = input("输入一个十六进制数:")
nums = 0
for n in range(len(num)):
if '0' <= num[n] and num[n] <= '9':
nums += int(num[n]) * 16 ** (len(num) -1 - n)
elif 'A' <= num[n] and num[n] <= 'F':
nums += int(num[n] , 16) * 16 ** (len(num) -1 - n)
else:
nums += int(num[n] , 16) * 16 ** (len(num) -1 - n)
print(nums)
Demo52
"""
题目描述
给定两个字符串 s1 和 s2 ，求两个字符串最长的公共前缀串，字符区分大小写
输入输出描述
输入两行，分别表示s1和s2
"""
# 收录两个字符串
str1 = input("请输入字符串s1:")
str2 = input("请输入字符串s2:")
prefix = ""
# 取到字符串长度较小的那个长度值
minStr = len(str1)
if minStr > len(str2):
minStr = len(str2)
for i in range(minStr):
if str1[i] == str2[i]:
prefix = prefix + str1[i] #注意我们是要从头输出，故此要注意字符串的拼接
else:
break
print(prefix)
Demo53
"""
题目描述
给定两个字符串 s1 和 s2 ，求 s2 在 s1 中出现的次数，字符区分大小写，已匹配的字符不计入下一次匹
配
输入输出描述
输入两行字符串，分别为s1和s2，s2的长度小于等于s1
输出s2在s1中出现的次数
"""
# 收录两个字符串
str1 = input("请输入字符串s1:")
str2 = input("请输入字符串s2:")
# 获取被匹配的字符串的长度
strLen = len(str2)
count = 0
index = 0
# 由于已匹配的字符串不计入下一次匹配，则要设定为不回头模式
while index <= len(str1) - strLen:
match = True
for i in range(strLen):
if str1[index + i] != str2[i]:
match = False
break
if match :
count += 1
index += strLen #匹配成功则移动到下一段字符串的起始位置
else:
index += 1 #匹配失败后往后移动一位进行匹配
print(count)
Demo54
#采用动态规划的方法解决问题
#(s1 : str , s2 : str)：表示输入的参数是字符串
#-> str：表示返回值的类型也是字符串
def longest_common_substring(s1 : str , s2 : str) -> str:
m = len(s1)
n = len(s2)
# 用列表解析式初始化二维数组
# dp 是一个 (m+1) x (n+1) 的二维列表
dp = [[0] * (n+1) for _ in range(m + 1)]
max_length = 0
# 用于定位最长子串末尾的下标
end_index = 0
# 两个子串的遍历比较要从1开始，因为我们已经将边界进行了赋值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 # （i，j）的值应该为左上角（i - 1， j - 1）的值+1
if dp[i][j] > max_length:
max_length = dp[i][j]
end_index = i - 1
# 最后根据dp数组还原最长公共子串
longest_substring = s1[end_index - max_length + 1 : end_index + 1]
return longest_substring
s1 = input("请输入字符串s1")
s2 = input("请输入字符串s2")
# 调用函数并输出结果
print(longest_common_substring(s1 , s2))
Demo55
# 检测密码是否合格
"""
一些网站会给密码强加一些规则：
（1）密码必须至少有8个字符
（2）密码只能包含英文字母和数字
（3）密码应该至少包含两个数字
（4）密码应该至少包含两个大写字母
如果密码符合规则，输出Yes；否则输出No
"""
# 导入正则表达式模块
import re
# 调用函数时给定的是字符串，其返回值也是字符串
def check_password_strength(password : str) -> str:
# 密码的长度应该至少为8位
if len(password) < 8:
return "No"
# 密码应该是由数字和字母组成用正则表达式检验
for i in password:
if not("A" <= i <= "Z" or "a"<= i <="z" or "0"<= i <="9"):
return "No"
# if not re.match("^[A-Za-z0-9]*$",password):
# return "No"
#密码至少包含两位数字
digit_count = sum(1 for char in password if char.isdigit())
if digit_count < 2:
return "No"
# 密码至少包含两位大写字母
uppercase_count = sum(1 for char in password if char.isupper())
if uppercase_count < 2:
return "No"
return "Yes"
# 测试
password = input("请输入密码：")
print(check_password_strength(password))
Demo56
# 回文素数
"""
题目描述
回文素数是指一个数既是素数又是回文数，例如131既是素数也是回文数
输出显示前100个回文素数，每行显示10个
"""
count = 0
#我们从10开始遍历，找到第100个回文素数为止
# 我们可以采用for...else:的分支结构以简化—————哨兵模式
num = 10
while count < 100:
for i in range(2 , num // 2 + 1):
if num % i == 0:
break
else:
if str(num) == str(num)[::-1]:
print(num , end = "\t")
count += 1
if count % 10 == 0: #每多10个就换行
print()
num += 1
Demo57
# 反素数
"""
题目描述
反素数是指一个将其逆向拼写后也是一个素数的非回文数，例如17和71都是素数但不是回文数，且反转
后依旧是素数
输出显示前100个反素数，每行显示10个
反向拼写可以用切片的方式进行
str(num) ---> str(num)[::-1]
reversion_num = int(str(num)[::-1])
"""
# 依旧从10开始
count = 0
num = 10
# 不用哨兵，依旧采用for...else
while count < 100:
# 先判断是不是素数
for i in range(2 , num // 2 + 1):
if num % i == 0:
break
else:
# 再筛选非回文数
if str(num) != str(num)[::-1]:
# 再对取反后的数进行素数判断
reversion_num = int(str(num)[::-1])
for j in range(2 , reversion_num // 2 + 1):
if reversion_num % j == 0:
break
else:
print(num , end = "\t")
count += 1
if count % 10 == 0:
print()
num += 1
Demo58
# 双素数
"""
双素数是指一对差值为2的素数，例如3和5就是一对双素数，5和7也是一对双素数
输出显示小于1000的双素数
"""
# 从2开始,到998打止，即如果998是素数我们再判断1000是不是
num = 2
count = 0
# 依旧用百试不爽的for...else
while num < 999:
for i in range(2 , num // 2 + 1):
if num % i == 0:
break
else:
double_num = num + 2
for j in range(2 , double_num // 2 + 1):
if double_num % j == 0:
break
else:
count += 1
print(num , "和" , double_num ,"是第" , count , "对双素数" , sep="")
num += 1
Demo59
# 梅森素数
"""
如果一个素数可以写成 2^p - 1 的形式，其中p是某个正整数，那么这个素数就称作梅森素数
输出p≤31的所有梅森素数
"""
# 即我们直接计算 2^p-1 p[0,31]是不是一个素数即可，但是 0，1 是非素数 故p可以直接从2开始取
count = 2
mason_num = 2 ** count
while count < 32:
# 梅森素数应当满足 2^p-1 的格式
mason_nums = mason_num - 1
for i in range(2 , mason_num // 2 + 1 ):
if mason_nums % i == 0:
break
else:
print(mason_nums , "是一个梅森素数" , sep = "")
mason_num *= 2
count += 1
Demo60
# 平方根的近似求法
"""
有几种实现开平方 n ** 1/2 的技术，其中一个称为巴比伦法
它通过使用下面公式的反复计算近似地得到：
nextGuess = (lastGuess + n / lastGuess) / 2
当nextGuess和lastGuess几乎相同时，nextGuess就是平方根的近似值
lastGuess初始值为1，如果nextGuess和lastGuess的差值小于一个很小的数，比如0.0001，就可以认为
nextGuess是n的平方根的近似值；否则，nextGuess成为下一次计算的lastGuess，近似过程继续执行
编写代码，求解n的平方根的近似值
"""
num = eval(input("请输入需要开方的数："))
# 精度检测
epsilon = 1e-6
# lastGuess的初始值是1
lastGuess = 1.0
while True:
nextGuess = (lastGuess + num / lastGuess) / 2
if abs(nextGuess - lastGuess) < epsilon :
break
lastGuess = nextGuess
print( "sqr(" , num , ")=" , "%.6f" %(nextGuess) )
扫一扫
44万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
