第一部分 语法基础
Demo01 摄氏温度转化为华氏温度
题目描述
输入一个摄氏温度的值，将它转变为华氏温度，并将结果输出
转换的公式为如下：
fahrenheit=(9/5)*celsius+32
**输入输出描述**
输入一个值表示摄氏温度celsius，输出华氏温度fahrenheit ，结果保留一位小数点
celsius = int (input('请输入温度(摄氏度):'))
fahrenheit = ( 9 / 5 ) * celsius + 32
print('等于' + str(fahrenheit) + '华氏度')
#输入43 输出109.4Demo02 计算圆柱体的体积
**题目描述**
输入圆柱的半径和高，并利用如下公式计算圆柱体的底面积和体积。
area=radius*radius*π volume=area*length
**输入输出描述**
分别输入圆柱的半径radius和高度length，两个数据之间用空格分隔
输出两行，第一行为圆柱底面积area，第二行为圆柱体积volume，结果保留两位小数点
radius = float(input("请输入圆柱体的半径："))
length = float(input("请输入圆柱体的高："))
import math
pi = math.pi
area = radius * radius * pi
volume = area * length
print(f"圆柱体的底面积是:{area} , 圆柱体的体积是:{volume}")
#输入5.5 12 输出59.03 1140.41Demo03 将英尺数转换为米数
**题目描述**
输入英尺数然后将它转换为米数，并输出结果，一英尺等于0.305米
**输入输出描述**
输入一个数据表示英尺数，输出转换后的米数，结果保留四位小数点
foot = float(input("请输入英尺："))
meter = foot * 0.305
print(f"对应米数为：{meter}")
#输入16.5 输出5.0325Demo04 计算小费
**题目描述**
读取小计和酬金率，然后计算小费以及合计金额。例如客户的小计为10元，酬金率为15%，那么小费是1.5元，合计金额为11.5元
**输入输出描述**
分别输入小计和酬金率，两个数据用之间用空格分隔
输出两行，第一行为小费，第二行为合计金额，结果保留两位小数
a,b=map(float,input("请输入小计和酬金率（用空格隔开）：").split())
print(f"小费为：{a * b * 0.01}")
print(f"合计金额为：{a + a * b * 0.01}")
#输入15.69 15 输出2.35 18.04 Demo05 对一个整数中的各位数字求和
**题目描述**
读取一个0到1000之间的整数，并计算它各位数字之和
**输入输出描述**
输入一个[0,1000]之间的整数，输出该数字的各位数字之和
num = int(input("请输入一个整数(0-1000)："))
count = 0
if 0 >= num or num >= 1000:
num = int(input("请重新输入一个整数(0-1000)："))
while num > 0:
count += num % 10
num //= 10
print(f"各位数字之和为：{count}")
#输入999 输出27 【因为999各个位数之和9+9+9=27】Demo06 计算年数和天数
**题目描述**
输入分钟数，然后将该分钟数转换为年数和天数，假定一年有365天
**输入输出描述**
输入一个分钟数，输出两行，第一行为年数，第二行为天数
minute = int(input("请输入分钟数："))
year = minute // (60 * 24 * 365)
day = minute // (60 * 24 ) - year * 365
print(f"年数为：{year}")
print(f"天数为：{day}")
# 输入：1000000000 输出：1902 214Demo07 计算能量
**题目描述**
水从初始温度加热到最终温度是需要能量的，请计算需要多少能量，公式如下：
Q = M * (finalTemperature - initialTemperature) * 4184
这里的M是按千克计的水量，初始温度和最终温度均为摄氏度，热量Q以焦耳计
**输入输出描述**
输入三行数据，第一行输入水量，第二行输入初始温度，第三行输入最终温度
输出所需的能量值，结果保留一位小数
M = float(input("请输入水量(kg)："))
initialTemperature = float(input("请输入初始温度："))
finalTemperature = float(input("请输入最终温度："))
Q = M * (finalTemperature - initialTemperature) * 4184
print(f"所需能量值为:{Q}")
# 输入：55.5 3.5 10.5 输出：1625484.0Demo08 分割数字
**题目描述**
输入一个四位整数，并以反向顺序显示
**输入输出描述**
输入一个四位整数
输出四行，第一行为个位，第二行为十位，第三行为百位，第四行为千位
num = int(input("请输入一个四位整数："))
if num < 1000 or num > 10000:
num = int(input("请重新输入一个四位整数："))
a = num // 1000
b = num // 100 % 10
c = num // 10 % 10
d = num % 10
print(f"{d}\n{c}\n{b}\n{a}")
# 输入：5213 输出：3 1 2 5Demo09 计算三角形的面积
**题目描述**
输入三角形的三个顶点坐标，并计算其面积，计算公式如下
s=(side1+side2+side3)/2 area = \sqrt{s(s-side1)(s-side2)(s-side3)}
**输入输出描述**
输入六个数据，分别表示三角形三个顶点的坐标x1、y1、x2、y2、x3和y3，数据之间用空格分隔
输出三角形的面积，结果保留一位小数
x1,y1,x2,y2,x3,y3 = map(float,input("请输入三角形的三个顶点坐标（用空格隔开）：").split())
side1 = (x1 ** 2 + y1 ** 2) ** 0.5
side2 = (x2 ** 2 + y2 ** 2) ** 0.5
side3 = (x3 ** 2 + y3 ** 2) ** 0.5
s = (side1 + side2 + side3) / 2
area = (s * (s - side1) * (s - side2) * (s - side3)) ** 0.5
print("三角形的面积为：", area)
#输入：1.5 -3.4 4.6 5 9.5 -3.4 输出：33.6Demo10 显示当前时间
**题目描述**
输入你所在的时区，并输出当前的时间
**输入输出描述**
输入时区，如东八区为8，西五区为-5
输出二十四小时制的时间，格式为 时:分:秒
# 从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("输入有误重新输入")
#输入：8 输出：21:43:12Demo11 计算三角形的三个角
**题目描述**
输入三角形的三个顶点坐标，并计算该三角形的三个角分别是多少（角度制）
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))
其中a、b、c分别表示三条边，A、B、C分别表示三边对应的角
**输入输出描述**
输入六个数据，分别表示三角形三个顶点的坐标x1、y1、x2、y2、x3和y3，数据之间用空格分隔
输出三行，分别为A、B、C三个角的度数，结果保留两位小数
import math
x1, y1 = map(float, input("请输入第一个顶点的坐标，以空格分隔：").split())
x2, y2 = map(float, input("请输入第二个顶点的坐标，以空格分隔：").split())
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))
#输入：1 1 6.5 1 6.5 2.5 输出：15.26 90.00 74.74Demo12 最小数量的硬币
**题目描述**
假设硬币种类分为：一元硬币、两角五分硬币、一角硬币、五分硬币、一分硬币
输入总金额，并将总金额兑换成若干个硬币，并保证所兑换的硬币个数最少
**输入输出描述**
输入总金额
输出每种硬币的个数
money = float(input("请输入总金额："))
coin_one = int(money)
money = money - coin_one
coin_25j = int(money / 0.25)
money = money - coin_25j * 0.25
coin_1j = int(money / 0.1)
money = money - coin_1j * 0.01
coin_5f = int(money / 0.05)
money = money - coin_5f *0.05
coin_1f = int(money / 0.01)
print(f"一元硬币：{coin_one}个, 两角五分硬币：{coin_25j}个, 一角硬币：{coin_1j}个, 五分硬币：{coin_5f}个, 一分硬币：{coin_1f}个")
#输入：11.56 输出：11个一元硬币 2个两角五分硬币 0个一角硬币 1个五分硬币 1个一分硬币Demo13 正多边形的面积
**题目描述**
正多边形是边长相等的多边形，而且所有的角相等，计算正多边形的公式为：
area = \frac{n*s^2}{4*tan(\frac{π}{n})}
**输入输出描述**
输入两个数据分别表示边的个数n和边的长度s，数据之间用空格分隔
输出边长为s的正n多边形的面积，结果保留两位小数
import math
n = int(input("请输入正多边形的边数："))
s = float(input("请输入正多边形的边长："))
pi = math.pi
area = (n * s**2) / (4 * math.tan(pi/n))
print(f"面积为：{area}")
#输入：5 6.5 输出：72.69Demo14 计算身体质量指数
**题目描述**
BMI是根据体重测量健康的方式，通过以千克为单位的体重除以以米为单位的身高的平方计算而出
BMI指数解读如下：
| BMI | 解释 |
| :----------------: | :--: |
| BMI ＜ 18.5 | 超轻 |
| 18.5 ≤ BMI ＜ 25.0 | 标准 |
| 25.0 ≤ BMI ＜ 30.0 | 超重 |
| 30.0 ≤ BMI | 肥胖 |
**输入输出描述**
输入体重和身高，数据之间用空格分隔，输出BMI指数结果
weight ,high = map(float,input("请输入体重和身高（空格分隔）：").split())
BMI = weight/(high**2)
if BMI<18.5:
print("超轻")
elif BMI<25.0:
print("标准")
elif BMI<30.0:
print("超重")
elif BMI>=30.0:
print("肥胖")
else:
print("输入错误")
#输入：60 1.8 输出：标准Demo15 判定闰年
**题目描述**
一个年份如果能被4整除但不能被100整除，或者能被400整除，那么这个年份就是闰年
**输入输出描述**
输入一个年份，输出Yes表示该年份为闰年，No则表示不是闰年
year = int ( input('请输入年份:') )
if year % 4 == 0 and year % 100 != 0 or year % 400 == 0:
print('yes')
else :
print('no')
#输入 2008 输出 yesDemo16 中彩票
**题目描述**
随机产生一个两位数数字，然后用户输入一个两位数数字，并根据以下规则判定用户赢得的奖金是多少
（1）输入的数字和随机产生的数字完全相同（包括顺序），奖金为10000元
（2）输入的数字和随机产生的数字相同（不包括顺序），奖金为3000元
（3）输入的数字和随机产生的数字有一位数相同，奖金为1000美元
（4）输入的数字和随机产生的数字都不相同，没有奖金，0元
**输入输出描述**
输入一个两位数，输出两行，第一行输出那个随机产生的两位数，第二行输出用户的奖金
import random
input_num = int (input("输入："))
input_str = str(input_num)
random_num = random.randint(10,100)
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")
#输入 12 输出 12 10000Demo17 解一元二次方程
**题目描述**
一元二次方程$ax^2+bx+c=0 (a != 0)$的解可以使用下面的公式计算
r_1=\frac{-b+\sqrt{b^2-4ac}}{2a},r_2=\frac{-b-\sqrt{b^2-4ac}}{2a}
其中$b^2-4ac$称为判别式，如果它为正，则方程有两个实数解；为零，方程只有一个实数解；为负，没有实数解
**输入输出描述**
输入a、b、c三个数据，数据之间用空格分隔
两个解每行输出一个；一个解单行输出；无解则单行输出无实数解，保留两位小数
import math
a, b, c = map(float,input("请输入a, b, c(空格分隔):").split())
if a == 0 :
print("输入错误")
elif b ** 2 - 4 * a * c > 0:
r_1 = round((-b + math.sqrt(b ** 2 - 4 * a * c))/(2 * a),2)
r_2 = round((-b - math.sqrt(b ** 2 - 4 * a * c))/(2 * a),2)
print(r_1)
print(r_2)
elif b ** 2 - 4 * a * c == 0:
r = round((-b + math.sqrt(b ** 2 - 4 * a * c))/(2 * a),2)
else:
print("无实数解")
#输入 1.0 3 1 输出 -0.38 -2.62Demo18 解2×2线程方程
**题目描述**
如有一个2×2的线程方程组：
ax+by=e cx+dy=f
你可以使用克莱姆法则解该线性方程：
x=\frac{ed-bf}{ad-bc},y=\frac{af-ec}{ad-bc}
其中$ad-bc$为判别式，如果为零则输出无解
**输入输出描述**
输入a、b、c、d、e、f六个数据，数据之间用空格分隔，
输出两行，第一行x的解，第二行y的解，保留一位小数
# 解2×2线程方程
a,b,c,d,e,f = map(float,input("输入：").split())
# 前提：(ad - bc)不等于0
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)
#输入 9.0 4.0 3.0 -5.0 -6.0 -21.0 输出 -2.0 3.0Demo19 未来是周几
题目描述
输入表示今天是一周内哪一天的数字（星期天是0，星期一是1，...，星期六是6）
并输入今天之后到未来某天的天数，然后输出该天是星期几
输入输出描述
输入两个数据，分别表示今日星期几的数字和未来某天的天数，数据之间用空格分隔
输出未来某天是星期几
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("星期六")
#输入 1 3 输出 星期四Demo20 本年中的第几天
题目描述
给定某年、某月、某日的一个日期，计算该日是今年中的第几天
输入输出描述
输入三个数据分别表示年、月、日，数据之间用空格分隔
输出该日是今年中的第几天
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)
#输入 2023 1 28 输出 28Demo21 剪刀石头布I
题目描述
计算机随机产生一个数字0、1和2分别表示剪刀、石头和布
用户输入数字0、1或2，输出用户赢、计算机赢或平局
输入输出描述
输入数字0、1或2
输出有三行，第一行输出计算机出的啥，第二行输出用户出的啥，第三行输出结果
import random
my = input('请输入(剪刀 = 1 、石头 = 2 、布 = 3):')
i = random.randint(1,4)
if my == i :
print('平局')
if my == 1 :
if i == 2:
print('you=剪刀,电脑=石头')
print('你输了')
else:
print('you=剪刀,电脑=布')
print('你赢了')
if my == 2 :
if i == 1:
print('you=石头,电脑=剪刀')
print('你赢了')
else:
print('you=石头,电脑=布')
print('你输了')
if my == 3 :
if i == 1:
print('you=布,电脑=剪刀')
print('你输了')
else:
print('you=布,电脑=石头')
print('你赢了')
#输入 0 输出 计算机出的 石头 用户出的 剪刀 计算机赢Demo22 三角形的周长
题目描述
输入三角形三边的长度，如果输入合法则计算周长并输出结果；否则输出非法
如果任意两边之和大于第三边则输入都是合法的
输入输出描述
输入三个数据表示三边，数据之间用空格分隔
输出三角形的周长，如果非法则输出非法
a , b , c = map(float,input("请输入三边边长：").split())
if a + b > c and b + c > a and a + c > b :
print(f"三角形周长为：{a + b + c}")
else:
print("非法输入")
#输入 1 1 1 输出 3Demo23 一周的星期几
题目描述
泽勒的一致性是一个由泽勒开发的算法，用于计算一周的星期几，公式如下：
h=(q+\lfloor\frac{26(m+1)}{10}\rfloor+k+\lfloor\frac{k}{4}\rfloor+\lfloor\frac{j}{4}\rfloor+5j) \% 7
（1）$h$是指一周的星期几（0表示星期六、1表示星期天、...、6表示星期五）
（2）$q$是一个月的哪一天
（3）$m$是月份（3表示三月、4表示四月、...、12表示十二月），其中一月和二月都是按照前一年的13月和14月来计数的，所以还得把年份改为前一年
（4）$j$是世纪数，即$\lfloor\frac{year}{100}\rfloor$
（5）$k$是一个世纪的某一年，即$year \% 100$
（6）$\lfloor\rfloor$为向下取整符号
from calendar import *
def num_to_string(num):
numbers={
0:"日",1:"一",2:"二",3:"三",4:"四",5:"五",6:"六"
}
return numbers.get(num,None)
def weekday(y,m,d):
monthDay1=[31,28,31,30,31,30,31,31,30,31,30,31]
days=0
for i in range(1,y):
if(isleap(i)):
days=days+366
else:
days=days+365
for j in range(1,m):
if(j==2 and isleap(y)):
days=days+29
else:
days=days+monthDay1[j-1]
total_days=days+d
xingqi=(total_days)%7
print("{0} 年 {1} 月 {2} 日是 星期{3}".format(y,m,d,num_to_string(int(xingqi))))
y=int(input("请输入年份:"))
m=int(input("请输入月份："))
d=int(input("请输入日期："))
if y<1 or m<1 or m>12 or d<1 or d>31:
print("输入错误！")
else:
total=weekday(int(y),int(m),int(d))
#输入 2013 1 25 输出 星期五Demo24 直线的交点
题目描述
直线A上的两个点是$(x1,y1)$和$(x2,y2)$，直线B上的两个点是$(x3,y3)$和$(x4,y4)$
如果两条直线有交点，可以通过解下面的线性等式找出：
(y_1-y_2)x-(x_1-x_2)y=(y_1-y_2)x_1-(x_1-x_2)y_1 \\ (y_3-y_4)x-(x_3-x_4)y=(y_3-y_4)x_3-(x_3-x_4)y_3
如果没有解，则表示两条直线平行
输入输出描述
输入八个数据，分别为x1 y1 x2 y2 x3 y3 x4 y4，数据之间用空格分隔
如有交点则输出交点的坐标x y，否则输出两条直线平行
x1, y1 = map(float, input("请输入第一个顶点的坐标，以空格分隔：").split())
x2, y2 = map(float, input("请输入第二个顶点的坐标，以空格分隔：").split())
x3, y3 = map(float, input("请输入第三个顶点的坐标，以空格分隔：").split())
x4, y4 = map(float, input("请输入第三个顶点的坐标，以空格分隔：").split())
try:
#(y1 - y2)*x - (x1 - x2)*y == (y1 - y2)*x1 - (x1 - x2)*y1
#(y3 - y4)*x - (x3 - x4)*y == (y3 - y4)*x3 - (x3 - x4)*y3
x = ( (x3-x4) * ( (y1 - y2)*x1 - (x1 - x2)*y1 ) - (x1 - x2) * ( (y3 - y4)*x3 - (x3 - x4)*y3 ) ) / ( (y1 - y2)*(x3 - x4) - (y3 - y4)*(x1 - x2) )
y = ( (y3-y4) * ( (y1 - y2)*x1 - (x1 - x2)*y1 ) - (y1 - y2) * ( (y3 - y4)*x3 - (x3 - x4)*y3 ) ) / ( (y1 - y2)*(x3 - x4) - (y3 - y4)*(x1 - x2) )
except ZeroDivisionError:
print("两直线平行")
else:
print("直线的交点是：(",x,",",y,")")
#输入 2 2 5 -1 4 2 -1 -2 输出 2.89 1.11Demo25 回文数
题目描述
输入一个三位整数，然后判断其是否为一个回文数
如果一个数从左向右和从右向左读取时是一样的，那么这个数就是回文数
输入输出描述
输入一个数字
输出Yes表示是回文数，否则输出No
num = int (input("输入："))
temp =num
change_num =0
while num >0:
change_num *= 10
change_num += num%10
num //= 10
if temp == change_num:
print("yes")
else:
print("no")
#输入 121 输出 yesDemo26 两个矩形
题目描述
判断两个矩形之间的关系：包含，重叠，相离
输入输出描述
输入两行，每行四个数据，分别是矩形的中心坐标x、y和矩形的宽、高
输出两者的关系
x1,y1,w1,h1 = map(float ,input("输入：").split())
x2,y2,w2,h2 = map(float ,input("输入：").split())
#求水平距离和垂直距离
level =abs(x1-x2)
vertical = abs(y1-y2)
# 判断：
if level < (w1+w2)/2 and vertical<(h1+h2)/2:
# 包含：如果两个矩形的中心点之间的水平距离小于两个矩形宽度之和的一半，并且垂直距离小于两个矩形高度之和的一半，则两个矩形相交。
print("包含")
elif level<abs(w1-w2) and vertical<abs(h1-h2):
# 重叠： 如果一个矩形的中心点到另一个矩形的中心点的水平距离小于两个矩形宽度之差的一半，并且垂直距离小于两个矩形高度之差的一半
print("重叠")
else:
print("相离")
#输入 2.5 4 2.5 43 1.5 5 0.5 3 输出 包含第二部分 循环语句
Demo27-32打印数字或图形
题目描述
利用循环，寻找规律，打印如下数字模式：
#第一题
# 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("输入"))
def print_num (row):
for i in range(1,rows+1):
print(" "*(row*2-2*i),end="")
for j in range(i,0,-1):
print(str(j)+" ",end="")
for j in range(2,i+1):
print(str(j)+" ",end="")
print()
print_num(rows)
#第二题
# 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
# 用户输入需要的层数
row = int(input("输入"))
def print_row (row):
for i in range(1,row+1):
print(" "*(row*2-2*i),end="")
num = 1
for j in range(1,i*2):
if j<i:
print(str(num)+" ",end="")
num*=2
else:
print(str(num)+" ",end="")
num = int(num/2)
print()
print_row(row)
#空心菱形
#方法一
layer = int(input('请输入图案输出行数(奇数)：'))
p = 1
j = 1
if layer % 2 == 0:
layer = int(input('请输入图案输出行数(奇数)：'))
print(' '*(layer // 2 - p + 2) + '*')
while p <= layer//2:
print(' '*(layer // 2 - p + 1) + '*' + ' '*(2 * p - 1) + '*')
p += 1
p = 1
while p <= layer//2 - 1:
print(' '*(p+1) + '*' + ' '*(layer - 2 * p - 2) + '*')
p += 1
j -= 1
p = 1
print(' '*(layer // 2 - p + 2) + '*')
#方法二
layer = int(input('请输入图案输出行数：'))
if layer % 2 == 0:
while layer % 2 == 0:
layer = int(input('请输入图案输出行数(奇数):'))
for i in range(1,(layer+1)//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+1)//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('请输入图案输出行数(奇数)：'))
p = 1
j = 1
if layer % 2 == 0:
while layer % 2 == 0:
layer = int(input('请输入图案输出行数(奇数)：'))
while p <= layer/2:
print( ' '*(layer // 2 - p + 1) + '*'*(2 * p - 1))
p += 1
p = 0
while p <= layer:
print(' '*p + '*'*(layer - 2 * p) )
p += 1
j -= 1
#方法二
layer = int(input('请输入图案输出行数：'))
if layer % 2 == 0:
while layer % 2 == 0:
layer = int(input('请输入图案输出行数(奇数):'))
for i in range(1,(layer + 1) // 2):
print(' '*(layer - i) + '*'*(i * 2 - 1))
for i in range((layer + 1) // 2,0,-1):
print(' '*(layer - i) + '*'*(2 * i - 1))Demo33 猜数字
题目描述
计算机随机生成一个[0,100]之间的整数，程序提示用户连续地输入数字直到它与那个随机生成的数字相同
对于用户输入的数字，程序会提示它是过高还是过低
输入输出描述
每次输入一个整数，每次输出该数字是过高还是过低，如果猜中则输出猜中的数字并结束
import random
computer = random.randint(0,101)
person = int(input("输入"))
while computer != person:
if computer>person:
print("猜低了")
else:
print("猜高了")
person = int(input("输入"))
print(f"恭喜你猜中了！ ：{person}")Demo34 最大公约数I
题目描述
输入两个正整数，计算其最大公约数，例如4和2的最大公约数是2，16和24的最大公约数是8
输入输出描述
输入两个数字，输出最大公约数
tmp = 0
x , y =map(int,input("请输入两个数字：").split())
def common_divisor(x,y) -> int:
while ( y != 0):
tmp = x % y
x = y
y = tmp
return x
print(f"最大公约数是：{common_divisor(x,y)}")
#输入 16 24 输出 8Demo35 判断素数
题目描述
一个大于1的整数如果只能被正整数1和它本身整除，则它就是素数，例如2、3、5和7都是素数，而4、6、8、9则不是
输入输出描述
输入一个大于1的正整数，输出Yes表示该数字是素数，否则输出No
import math
def prime(num):
if num<2:
return False
else:
for i in range(2,int(math.sqrt(num)+1)):
if num % i == 0:
return False
return True
num = int(input("输入"))
flag = prime(num)
if flag:
print("yes")
else:
print("no")
#输入 9 输出 NoDemo36 最小公倍数
题目描述
输入两个正整数，计算其最小公倍数，例如4和2的最小公倍数是4，3和5的最小公倍数是15
输入输出描述
输入两个正整数，输出最小公倍数
x , y = map(int,input("请输入两个数字：").split())
def commom_multiples(x,y):
# 将大的数值赋值给tmp
if x < y:
tmp = y
else:
tmp = x
while True :
if tmp % x == 0 and tmp % y == 0:
break
tmp += 1
return tmp
print(f"最小公倍数是:{commom_multiples(x,y)}")
#输入 3 9 输出 9Demo37 整数的素因子
题目描述
输入一个正整数，然后找出它所有的最小因子，也称之为素因子
输入输出描述
输入一个正整数，输出多行，每行输出一个素因子
def prime(num):
arr=[]
i = 2
while i * i <= num :
if num % i == 0:
arr.append(i)
else:
i += 1
if num > 1 :
arr.append(num)
return arr
num = int(input("输入"))
print(prime(num))
#输入 120 输出 2 2 2 3 5 【因为 2*2*2*3*5=120】Demo38 完全数
题目描述
如果一个正整数等于除了它本身之外所有正因子的和，那么这个数称为完全数
例如 6 = 3 + 2 + 1，28 = 14 + 7 + 4 + 2 + 1
输入输出描述
输入一个正整数，输出该数是否为完全数
num = int(input("输入"))
def perfect_num (num):
sum = 1
for i in range (2,num // 2 + 1):
if num % i == 0:
sum += i
if num == sum:
return True
else:
return False
if perfect_num(num):
print("yes")
else:
print("no")
#输入 6 输出 yesDemo39 前50个素数
题目描述
打印前50个素数，每打印10个素数换行
import math
arr = []
def prime_num (num):
if num < 2:
return False
elif num == 2 or num == 3:
return True
elif num % 2 == 0 or num % 3 == 0:
return False
sqrt_num = int(math.sqrt(num))
i = 1
while 6 * i - 1 <= sqrt_num:
if num%(6 * i - 1) == 0 or num % (6 * i + 1) == 0:
return False
i += 1
return True
num = 2
i = 1
while i <= 50:
if prime_num(num):
arr.append(num)
i += 1
num += 1
i = 1
while i <= 50:
print(str(arr[i-1]) + " " ,end=" ")
if i % 10 == 0:
print()
i += 1Demo40 计算π
题目描述
你可以使用下面的数列近似计算π
π=4(1-\frac{1}{3}+\frac{1}{5}-\frac{1}{7}+\frac{1}{9}-\frac{1}{11}+...+\frac{(-1)^{i+1}}{2i-1})
当i越大时，计算结果越近似于π
j = 1
sum = 0
for i in range(10000):
if (i + 1) % 2 == 0:
j = -(2 * (i + 1) - 1)
else:
j = (2 * (i + 1) - 1)
n = 4 / j
sum = sum + n
print(sum)Demo41 计算e
题目描述
你可以使用下面的数列近似计算e
e=1+\frac{1}{1!}+\frac{1}{2!}+\frac{1}{3!}+\frac{1}{4!}+...+\frac{1}{i!}
当i越大时，计算结果越近似于e
import math
def calc_e(n):
e = 1
for i in range(1, n+1):
e += 1 / math.factorial(i)
return e
print(calc_e(1000)) Demo42 剪刀石头布II
题目描述
延伸【Demo21剪刀石头布I】的问题，利用循环将程序改为，计算机和电脑谁先赢三次，谁就是终极胜利者
import random
count_use = 0
count_com = 0
while True:
use_num = int( input("输入："))
com_num = random.randint(0,2)
def change(num):
if num ==0:
return " 剪刀"
elif num == 1:
return " 石头"
elif num ==2:
return " 布"
else :
return 0
if change(use_num)==0 :
print("输入不合法")
continue
else:
print("计算机输出" + change(com_num))
print("用户出的" + change(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):
count_com += 1
print("计算机赢"+str(count_com)+"回")
else:
count_use += 1
print("用户赢了" + str(count_use) + "回")
if count_use == 3:
print("用户获得了胜利")
break
elif count_com == 3:
print("电脑获得了胜利")
breakDemo43 组合问题I
题目描述
在数字范围[1,7]之间，任意选择两个不相同的数作为一个组合，输出每一组组合，并统计所有组合的个数
注：组合（a，b）与组合（b，a）算同一种组合，只记录一次
count = 0
for i in range(1,7):
for j in range(i + 1,8):
if i != j :
print(f"({i} , {j})",end="")
count +=1
print()
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 j!=k and i!=k:
count+=1
print(f'{i}{j}{k}',end=" ")
print()
print(f'一共有{count}个')Demo45 水仙花数
题目描述
水仙花数，是一个三位数，且这个数的个位、十位和百位的立方和等于该数字本身，例如$153=1^3+5^3+3^3$
编写程序，输出所有的水仙花数
# 打印输出标准水仙花数，输出这些水仙花数
num = 100
while num >= 100 and num < 1000:
a = num // 100 # a得到百位的
b = (num // 10) % 10 # b得到十位的
c = num % 10 # c得到个位的
if num == a ** 3 + b ** 3 + c ** 3:
print(num,end=' ')
num += 1Demo46 青蛙跳台阶
题目描述
一只青蛙，一次可以跳一个台阶或者两个台阶，现有n个台阶，问该青蛙有多少种不同的跳法？
例如：两个台阶，有两种跳法（1+1，2）；四个台阶，有五种跳法（1+1+1+1，2+1+1，1+2+1，1+1+2，2+2）
def get_staircase(n:int) -> int:
if n == 1 or n == 2:
return n
return get_staircase(n - 1) + get_staircase(n - 2)
n = int(input("请输入台阶数："))
print(get_staircase(n))Demo47 堆叠相加
题目描述
现有堆叠相加模式$a+aa+aaa+aaaa+aaaaa+......$
例如：$2+22+222+2222+22222$，其中a为2，且有5组数字
输入输出描述
输入两个数据分别为数字a和组数n，输出按照堆叠相加模式算出的和
num , group = map(int ,input("输入数字和组数:").split())
def get_num(num,group):
sum = 0
for i in range(1,group+1):
sum += int(str(num)*i)
return sum
print(get_num(num,group))
#输入 3 4 输出 3702 【因为 3+33+333+3333=3702】Demo48 十进制转二进制
题目描述
输入一个十进制正整数，输出其二进制形式
输入输出描述
输入一个十进制正整数，输出二进制字符串
num = int(input('请输入一个正整数：'))
i = 0
count = ''
num_1 = 0
num_0 = 0
while num > 0 :
i = num % 2
num //= 2
if i == 1:
num_1 += 1
if i == 0:
num_0 += 1
count += str(i)
j = 0
for j in range(-1,-len(count)-1,-1):
print(count[j],end='')
#输入 9 输出 1001Demo49 二进制转十进制
题目描述
输入一个二进制字符串，输出其对应的十进制数字
输入输出描述
输入一个二进制字符串，输出十进制数字
num = int(input('请输入一个二进制数：'))
def num_turn_d(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(num_turn_d(num))
#输入 1001 输出 9Demo50 十进制转十六进制
题目描述
输入一个十进制正整数，输出其十六进制形式
输入输出描述
输入一个十进制正整数，输出十六进制字符串
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))
#输入 123321 输出 1e1b9Demo51 十六进制转十进制
题目描述
输入一个十六进制字符串，输出其对应的十进制数字
输入输出描述
输入一个十六进制字符串，输出十进制数字
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))
#输入 1e1b9 输出 123321Demo52 最长公共前缀
题目描述
给定两个字符串 s1 和 s2 ，求两个字符串最长的公共前缀串，字符区分大小写
输入输出描述
输入两行，分别表示s1和s2，输出前缀串
str1 = str(input("请输入str1:"))
str2 = str(input("请输入str2:"))
def find_lcs(str1,str2):
lcs=set()
if len(str1)>len(str2):
str1,str2=str2,str1
for i in range(len(str1),0,-1):
flag=False
for j in range(len(str1)-i+1):
s=str1[j:i+j]
if str2.find(s)>-1:
lcs.add(s)
flag=True
else:
flag=False
if flag:
break
print("最长公共子串为：",lcs)
find_lcs(str1,str2)
#输入 abcdefg abcdhko 输出 abcdDemo53 子串出现的次数
题目描述
给定两个字符串 s1 和 s2 ，求 s2 在 s1 中出现的次数，字符区分大小写，已匹配的字符不计入下一次匹配
输入输出描述
输入两行字符串，分别为s1和s2，s2的长度小于等于s1，输出s2在s1中出现的次数
str1 = str(input("请输入str1:"))
str2 = str(input("请输入str2:"))
def count_occurrences(s1, s2):
count = 0
i = 0
while i < len(s1):
if s1[i:i+len(s2)] == s2:
count += 1
i += len(s2)
else:
i += 1
return count
print(count_occurrences(str1,str2))
#输入 ABCsdABsadABCasdhjabcsaABCasd ABC 输出 3Demo54 最长公共子串
题目描述
给定两个字符串 s1 和 s2 ，求 s1 与 s2 之间的最长公共子串，字符区分大小写
输入输出描述
输入两行字符串，分别为s1和s2，输出最长公共子串
str1 = str(input("请输入str1:"))
str2 = str(input("请输入str2:"))
def find_lcs(str1,str2):
lcs=set()
if len(str1)>len(str2):
str1,str2=str2,str1
for i in range(len(str1),0,-1):
flag=False
for j in range(len(str1)-i+1):
s=str1[j:i+j]
if str2.find(s)>-1:
lcs.add(s)
flag=True
else:
flag=False
if flag:
break
print("最长公共子串为：",lcs)
find_lcs(str1,str2)
#输入 123ABCDEFG83hsad iughABCDEFG23uy 输出 ABCDEFGDemo55 检测密码
题目描述
一些网站会给密码强加一些规则：
（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))
#输入 123456ab 输出 No
#输入 123abcABC 输出 YesDemo56 回文素数
题目描述
回文素数是指一个数既是素数又是回文数，例如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 += 1Demo57 反素数
题目描述
反素数是指一个将其逆向拼写后也是一个素数的非回文数，例如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 += 1Demo58 双素数
题目描述
双素数是指一对差值为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 += 2Demo59 梅森素数
如果一个素数可以写成$2^p-1$的形式，其中p是某个正整数，那么这个素数就称作梅森素数
输出p≤31的所有梅森素数
def is_prime(p):
for i in range(2, p // 2 + 1):
if p % i == 0:
return False
return True
def is_prime_range(start, end):
arr = []
b = []
for p in range(start, end + 1):
if is_prime(p):
arr.append(p)
for p in arr:
b.append(2 ** (p - 1))
print(b)
res = is_prime_range(2, 31)
print(res)Demo60 平方根的近似求法
有几种实现开平方$\sqrt{n}$的技术，其中一个称为巴比伦法
它通过使用下面公式的反复计算近似地得到：
nextGuess=(lastGuess+n/lasetGuess)/2
当nextGuess和lastGuess几乎相同时，nextGuess就是平方根的近似值
lastGuess初始值为1，如果nextGuess和lastGuess的差值小于一个很小的数，比如0.0001，就可以认为nextGuess是n的平方根的近似值；否则，nextGuess成为下一次计算的lastGuess，近似过程继续执行
编写代码，求解n的平方根的近似值
def square_root(n):
lastGuess = n / 2
for i in range(20):
nextGuess =(1 / 2) * (lastGuess + (n / lastGuess))
lastGuess = nextGuess
return nextGuess
print(square_root(6))目录
5371
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
