python题集

Demo01 摄氏温度转化为华氏温度

题目描述

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

转换的公式为如下：

输入输出描述

输入一个值表示摄氏温度celsius

输出华氏温度fahrenheit ，结果保留一位小数点

示例

输入：

43

输出：

109.4

celsius = float(input())
fahrenheit = 9 / 5 * celsius + 32
print(fahrenheit)

Demo02 计算圆柱体的体积

题目描述

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

输入输出描述

分别输入圆柱的半径radius和高度length，两个数据之间用空格分隔

输出两行，第一行为圆柱底面积area，第二行为圆柱体积volume，结果保留两位小数点

示例

输入：

5.5 12

输出：

95.03

1140.41

import math
 
input_str = input()
input_list = input_str.split()
 
radius = float(input_list[0])
length = float(input_list[1])
 
area = "%.2f" % (math.pi * radius * radius)
volume = "%.2f" % (float(area) * length)
 
print(area)
print(volume)

Demo03 将英尺数转换为米数

题目描述

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

输入输出描述

输入一个数据表示英尺数

输出转换后的米数，结果保留四位小数点

示例

输入：

16.5

输出：

5.0325

import math
yingchi = float(input())
length = "%.4f" % (yingchi * 0.3050)
print(length)

Demo04 计算小费

题目描述

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

输入输出描述

分别输入小计和酬金率，两个数据用之间用空格分隔

输出两行，第一行为小费，第二行为合计金额，结果保留两位小数

示例

输入：

15.69 15

输出：

2.35

18.04

import math
input_list = input()
input_str = input_list.split()
xiaoji = float(input_str[0])
choujinlv = float(input_str[1])
xiaofei = float("%.2f" % (xiaoji * choujinlv * 0.01))
sum = "%.2f" % (xiaoji + xiaofei)
print(xiaofei)
print(sum)

Demo05 对一个整数中的各位数字求和

题目描述

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

输入输出描述

输入一个[0,1000]之间的整数

输出该数字的各位数字之和

示例1

输入：

999

输出：

27

解释：

999各位数之和为9 + 9 + 9 = 27

示例2

输入：

12

输出：

3

a = input()
b = len(a)
a = int(a)
total = 0
while b > 0:
    c = a % 10
    total = int(total + c)
    a = a / 10
    b = b-1
print(total)

Demo06 计算年数和天数

题目描述

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

输入输出描述

输入一个分钟数

输出两行，第一行为年数，第二行为天数

示例

输入：

1000000000

输出：

1902

214

minutes = int(input())
minutes_per_day = 24 * 60
minutes_per_year = 365 * minutes_per_day
years = minutes // minutes_per_year
remaining_minutes = minutes % minutes_per_year
days = remaining_minutes // minutes_per_day
print(years)
print(days)

Demo07 计算能量

题目描述

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

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

输入输出描述

输入三行数据，第一行输入水量，第二行输入初始温度，第三行输入最终温度

输出所需的能量值，结果保留一位小数

示例

输入：

55.5

3.5

10.5

输出：

1625484.0

m = float(input())
initialTemperature = float(input())
finalTemperature = float(input())
q = m * (finalTemperature - initialTemperature) * 4184
print(q)

Demo08 分割数字

题目描述

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

输入输出描述

输入一个四位整数

输出四行，第一行为个位，第二行为十位，第三行为百位，第四行为千位

示例

输入：

5213

输出：

3

1

2

5

a = int(input())
b = 4
while b > 0:
    print(a % 10)
    a = int(a / 10)
    b = b - 1

Demo09 计算三角形的面积

题目描述

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

输入输出描述

输入六个数据，分别表示三角形三个顶点的坐标x1、y1、x2、y2、x3和y3，数据之间用空格分隔

输出三角形的面积，结果保留一位小数

示例

输入：

1.5 -3.4 4.6 5 9.5 -3.4

输出：

33.6

import math
input_list = input()
input_str = input_list.split()
x1 = float(input_str[0])
y1 = float(input_str[1])
x2 = float(input_str[2])
y2 = float(input_str[3])
x3 = float(input_str[4])
y3 = float(input_str[5])
side1 = pow(pow(x2-x1, 2) + pow(y2-y1, 2), 0.5)
side2 = pow(pow(x3-x1, 2) + pow(y3-y1, 2), 0.5)
side3 = pow(pow(x3-x2, 2) + pow(y3-y2, 2), 0.5)
s = (side1 +side2 +side3) / 2
area = "%.1f" % (pow(s * (s-side1) * (s-side2)* (s-side3),0.5))
print(area)

Demo10 显示当前时间

题目描述

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

输入输出描述

输入时区，如东八区为8，西五区为-5

输出二十四小时制的时间，格式为 时:分:秒

示例

输入：

8

输出：

21:43:12

from datetime import datetime, timedelta
timezone = int(input())
current_time = datetime.utcnow() + timedelta(hours=timezone)
formatted_time = current_time.strftime("%H:%M:%S")
print(formatted_time)

Demo11 计算三角形的三个角

题目描述

输入三角形的三个顶点坐标，并计算该三角形的三个角分别是多少（角度制）

其中a、b、c分别表示三条边，A、B、C分别表示三边对应的角

输入输出描述

输入六个数据，分别表示三角形三个顶点的坐标x1、y1、x2、y2、x3和y3，数据之间用空格分隔

输出三行，分别为A、B、C三个角的度数，结果保留两位小数

示例

输入：

1 1 6.5 1 6.5 2.5

输出：

15.26

90.00

74.74

import math
input_list = input()
input_str = input_list.split()
x1 = float(input_str[0])
y1 = float(input_str[1])
x2 = float(input_str[2])
y2 = float(input_str[3])
x3 = float(input_str[4])
y3 = float(input_str[5])
a = pow(pow(x2-x1, 2) + pow(y2-y1, 2), 0.5)
b = pow(pow(x3-x1, 2) + pow(y3-y1, 2), 0.5)
c = pow(pow(x3-x2, 2) + pow(y3-y2, 2), 0.5)
A = "%.2f" %(math.degrees(math.acos((a*a - b*b - c*c) / (-2*b*c))))
B = "%.2f" %(math.degrees(math.acos((b*b - a*a - c*c) / (-2*a*c))))
C = "%.2f" %(math.degrees(math.acos((c*c - b*b - a*a) / (-2*a*b))))
print(A)
print(B)
print(C)

Demo12 最小数量的硬币

题目描述

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

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

输入输出描述

输入总金额

输出每种硬币的个数

示例

输入：

11.56

输出：

11个一元硬币

2个两角五分硬币

0个一角硬币

1个五分硬币

1个一分硬币

total = float(input())
a = int(total)
b = int((total - a) / 0.25)
c = int((total - a - b * 0.25) / 0.1)
d = int((total - a - b * 0.25 - c * 0.1) / 0.05)
e = int((total - a - b * 0.25 - c * 0.1 - d * 0.05) / 0.01)
print(str(a) + "个一元硬币")
print(str(b) + "个两角五分硬币")
print(str(c) + "个一角硬币")
print(str(d) + "个五分硬币")
print(str(e) + "个一分硬币")

Demo13 正多边形的面积

题目描述

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

输入输出描述

输入两个数据分别表示边的个数n和边的长度s，数据之间用空格分隔

输出边长为s的正n多边形的面积，结果保留两位小数

示例

输入：

5 6.5

输出：

72.69

import math
n, s = map(float, input().split())
area = (n * s**2) / (4 * math.tan(math.pi / n))
print("{:.2f}".format(area))

Demo14 计算身体质量指数

题目描述

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

BMI指数解读如下：

BMI	解释
BMI ＜ 18.5	超轻
18.5 ≤ BMI ＜ 25.0	标准
25.0 ≤ BMI ＜ 30.0	超重
30.0 ≤ BMI	肥胖

输入输出描述

输入体重和身高，数据之间用空格分隔

输出BMI指数结果

示例

输入：

60 1.8

输出：

标准

str_list = input()
str = str_list.split()
weight = float(str[0])
height = float(str[1])
bmi = weight / height / height
if bmi < 18.5:
    print("超轻")
if 25.0 > bmi >= 18.5:
    print("标准")
if 25.0 <= bmi < 30:
    print("超重")
if bmi >= 30.0:
    print("肥胖")

Demo15 判定闰年

题目描述

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

输入输出描述

输入一个年份

输出Yes表示该年份为闰年，No则表示不是闰年

示例1

输入：

2008

输出：

Yes

示例2

输入：

2002

输出：

No

year = int(input())
if year % 4 == 0  and year % 100 != 0 or year % 400 == 0:
    print("yes")
else:
    print("no")

Demo16 中彩票

题目描述

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

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

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

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

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

输入输出描述

输入一个两位数

输出两行，第一行输出那个随机产生的两位数，第二行输出用户的奖金

示例1

输入：

12

输出：

12

10000

示例2

输入：

12

输出：

21

3000

示例3

输入：

12

输出：

23

1000

示例4

输入：

12

输出：

45

0

import random
random_number = random.randint(10, 99)
prize = int(input())
str_list1 = str(random_number).split()
str_list2 = str(prize).split()
t = 0
c = 0
if prize == random_number:
    t = t + 10000
else:
    for i in range(0, 1):
        for j in range(0, 1):
            if str_list1[i] == str_list2[j]:
                c = c+1
if c == 2:
    t = 3000
if c == 1:
    t = 1000
print(random_number)
print(t)

Demo17 解一元二次方程

题目描述

一元二次方程$ax^2+bx+c=0 (a != 0)$的解可以使用下面的公式计算

其中$b^2-4ac$称为判别式，如果它为正，则方程有两个实数解；为零，方程只有一个实数解；为负，没有实数解

输入输出描述

输入a、b、c三个数据，数据之间用空格分隔

两个解每行输出一个；一个解单行输出；无解则单行输出无实数解，保留两位小数

示例1

输入：

1.0 3 1

输出：

-0.38

-2.62

示例2

输入：

1 2.0 1

输出：

-1.00

-2.62

示例3

输入：

1 2 3

输出：

无实数解

import math
str_list = input()
str_num = str_list.split()
a = float(str_num[0])
b = float(str_num[1])
c = float(str_num[2])
if b*b - 4*a*c < 0:
    print("无实数解")
elif b*b - 4*a*c == 0:
    print("%.2f" % ((-b + math.sqrt(b*b - 4*a*c)) / (2 * a)))
else:
    r1 = (-b + math.sqrt(b*b - 4*a*c)) / (2 * a)
    r2 = (-b - math.sqrt(b*b - 4*a*c)) / (2 * a)
    print("%.2f" % r1)
    print("%.2f" % r2)

Demo18 解2×2线程方程

题目描述

如有一个2×2的线程方程组：

你可以使用克莱姆法则解该线性方程：

其中$ad-bc$为判别式，如果为零则输出无解

输入输出描述

输入a、b、c、d、e、f六个数据，数据之间用空格分隔

输出两行，第一行x的解，第二行y的解，保留一位小数

示例1

输入：

9.0 4.0 3.0 -5.0 -6.0 -21.0

输出：

-2.0

3.0

示例2

输入：

1.0 2.0 2.0 4.0 4.0 5.0

输出：

无解

import math
str_list = input()
str_num = str_list.split()
a = float(str_num[0])
b = float(str_num[1])
c = float(str_num[2])
d = float(str_num[3])
e = float(str_num[4])
f = float(str_num[5])
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("%.1f" % x)
    print("%.1f" % y)

Demo19 未来是周几

题目描述

输入表示今天是一周内哪一天的数字（星期天是0，星期一是1，...，星期六是6）

并输入今天之后到未来某天的天数，然后输出该天是星期几

输入输出描述

输入两个数据，分别表示今日星期几的数字和未来某天的天数，数据之间用空格分隔

输出未来某天是星期几

示例1

输入：

1 3

输出：

星期四

示例2

输入：

0 31

输出：

星期三

import math
str_list = input()
str_num = str_list.split()
week = int(str_num[0])
day = int(str_num[1])
week_day = day % 7
week = week + week_day
if week > 7:
    week = week % 7
if week == 1:
    print("星期一")
if week == 2:
    print("星期二")
if week == 3:
    print("星期三")
if week == 4:
    print("星期四")
if week == 5:
    print("星期五")
if week == 6:
    print("星期六")
if week == 7:
    print("星期日")

Demo20 本年中的第几天

题目描述

给定某年、某月、某日的一个日期，计算该日是今年中的第几天

输入输出描述

输入三个数据分别表示年、月、日，数据之间用空格分隔

输出该日是今年中的第几天

示例1

输入：

2023 1 28

输出：

28

示例2

输入：

2023 3 2

输出：

61

from datetime import date
str_list = input()
str_num = str_list.split()
year = int(str_num[0])
month = int(str_num[1])
day = int(str_num[2])
d = date(year, month, day)
print(d.timetuple().tm_yday)

Demo21 剪刀石头布I

题目描述

计算机随机产生一个数字0、1和2分别表示剪刀、石头和布

用户输入数字0、1或2，输出用户赢、计算机赢或平局

输入输出描述

输入数字0、1或2

输出有三行，第一行输出计算机出的啥，第二行输出用户出的啥，第三行输出结果

示例1

输入：

0

输出：

计算机出的 石头

用户出的 剪刀

计算机赢

示例2

输入：

1

输出：

计算机出的 剪刀

用户出的 石头

用户赢

示例3

输入：

2

输出：

计算机出的 布

用户出的 布

平局

import random
num0 = random.randint(0, 2)
num1 = int(input())
dir = {0: "剪刀", 1: "石头", 2: "布"}
print("计算机出的" + dir[num0])
print("用户出的" + dir[num1])
if (num0 == 0 and num1 == 1) and (num0 == 1 and num1 == 2) and (num0 == 2 and num1 == 0):
    print("用户赢")
else:
    print("计算机赢")

Demo22 三角形的周长

题目描述

输入三角形三边的长度，如果输入合法则计算周长并输出结果；否则输出非法

如果任意两边之和大于第三边则输入都是合法的

输入输出描述

输入三个数据表示三边，数据之间用空格分隔

输出三角形的周长，如果非法则输出非法

示例1

输入：

1 1 1

输出：

3

示例2

输入：

1 3 1

输出：

非法

str_list = input()
str_num = str_list.split()
a = float(str_num[0])
b = float(str_num[1])
c = float(str_num[2])
t = 0
if a+b < c or a+c < b or b+c < a or a+b == c:
    print("非法")
else:
    print(a+b+c)

Demo23 一周的星期几

题目描述

泽勒的一致性是一个由泽勒开发的算法，用于计算一周的星期几，公式如下：

（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$为向下取整符号

输入输出描述

输入年、月、日三个数据，数据之间用空格分隔

输出该日是周几

示例1

输入：

2013 1 25

输出：

星期五

示例2

输入：

2012 5 12

输出：

星期六

def zeller_congruence(year, month, day):
    if month < 3:
        month += 12
        year -= 1
    q = day
    m = month
    j = year // 100
    k = year % 100
    h = (q + (26 * (m + 1) // 10) + k + (k // 4) + (j // 4) + 5 * j) % 7
    return h
 
def weekday(year, month, day):
    days = ["星期六", "星期天", "星期一", "星期二", "星期三", "星期四", "星期五"]
    return days[zeller_congruence(year, month, day)]
 
year, month, day = map(int, input().split())
print(weekday(year, month, day))

Demo24 直线的交点

题目描述

直线A上的两个点是$(x1,y1)$和$(x2,y2)$，直线B上的两个点是$(x3,y3)$和$(x4,y4)$

如果两条直线有交点，可以通过解下面的线性等式找出：

如果没有解，则表示两条直线平行

输入输出描述

输入八个数据，分别为x1 y1 x2 y2 x3 y3 x4 y4，数据之间用空格分隔

如有交点则输出交点的坐标x y，否则输出两条直线平行

示例1

输入：

2 2 5 -1 4 2 -1 -2

输出：

2.89 1.11

示例2

输入：

2 2 7 6 4 2 -1 -2

输出：

两条直线平行

import math
def line_intersection(x1, y1, x2, y2, x3, y3, x4, y4):
    # 计算直线A的斜率和截距
    if x2 - x1 != 0:
        k1 = (y2 - y1) / (x2 - x1)
        b1 = y1 - k1 * x1
    else:
        return "两条直线平行"
 
    # 计算直线B的斜率和截距
    if x4 - x3 != 0:
        k2 = (y4 - y3) / (x4 - x3)
        b2 = y3 - k2 * x3
    else:
        return "两条直线平行"
 
    # 检查两条直线是否平行
    if k1 == k2:
        return "两条直线平行"
    else:
        # 计算交点的坐标
        x = (b2 - b1) / (k1 - k2)
        y = k1 * x + b1
        return x, y
 
x1, y1, x2, y2, x3, y3, x4, y4 = map(float, input().split())
print(line_intersection(x1, y1, x2, y2, x3, y3, x4, y4))

Demo25 回文数

题目描述

输入一个三位整数，然后判断其是否为一个回文数

如果一个数从左向右和从右向左读取时是一样的，那么这个数就是回文数

输入输出描述

输入一个数字

输出Yes表示是回文数，否则输出No

示例1

输入：

121

输出：

Yes

示例2

输入：

123

输出：

No

num = int(input())
num1 = num%10*100 + int(num%100-num%10) + int(num/100)
if num == num1:
    print("Yes")
else:
    print("No")

Demo26 两个矩形

题目描述

判断两个矩形之间的关系：包含，重叠，相离

输入输出描述

输入两行，每行四个数据，分别是矩形的中心坐标x、y和矩形的宽、高

输出两者的关系

示例1

输入：

2.5 4 2.5 43

1.5 5 0.5 3

输出：

包含

示例2

输入：

1 2 3 5.5

3 4 4.5 5

输出：

重叠

示例3

输入：

1 2 3 3

40 45 3 2

输出：

相离

def rectangle_relation(x1, y1, w1, h1, x2, y2, w2, h2):
 
    left1, right1 = x1 - w1 / 2, x1 + w1 / 2
    top1, bottom1 = y1 - h1 / 2, y1 + h1 / 2
 
    left2, right2 = x2 - w2 / 2, x2 + w2 / 2
    top2, bottom2 = y2 - h2 / 2, y2 + h2 / 2
 
    if left1 > right2 or right1 < left2 or top1 > bottom2 or bottom1 < top2:
        return "相离"
    elif (left1 <= left2 and right1 >= right2 and top1 <= top2 and bottom1 >= bottom2) or \
         (left2 <= left1 and right2 >= right1 and top2 <= top1 and bottom2 >= bottom1):
        return "包含"
    else:
        return "重叠"
 
input1 = input().split()
x1, y1, w1, h1 = map(float, input1)
 
input2 = input().split()
x2, y2, w2, h2 = map(float, input2)
 
result = rectangle_relation(x1, y1, w1, h1, x2, y2, w2, h2)
print(result)

Demo27 打印数字I

题目描述

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

模式A
1
1 2
1 2 3
1 2 3 4
1 2 3 4 5
1 2 3 4 5 6
模式B
1 2 3 4 5 6
1 2 3 4 5
1 2 3 4
1 2 3
1 2
1
模式C
          1
        2 1
      3 2 1
    4 3 2 1
  5 4 3 2 1
6 5 4 3 2 1
模式D
1 2 3 4 5 6
  1 2 3 4 5
    1 2 3 4
      1 2 3
        1 2
          1

# 模式A
for i in range(1, 7):
    for j in range(1, i + 1):
        print(j, end=' ')
    print()
 
# 模式B
for i in range(6, 0, -1):
    for j in range(1, i + 1):
        print(j, end=' ')
    print()
 
# 模式C
for i in range(1, 7):
    for j in range(6 - i):
        print(" ", end="")
    for j in range(i, 0, -1):
        print(j, end=" ")
    print()
 
# 模式D
for i in range(1, 7):
    for j in range(7 - i):
        print(" ", end="")
    for j in range(i, 0, -1):
        print(j, end=" ")
    print()

Demo28 打印数字II

题目描述

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

            1
          2 1 2
        3 2 1 2 3
      4 3 2 1 2 3 4
    5 4 3 2 1 2 3 4 5
  6 5 4 3 2 1 2 3 4 5 6
7 6 5 4 3 2 1 2 3 4 5 6 7

def print_pattern(n):
    for i in range(1, n + 1):
        for j in range(n - i):
            print(" ", end="")
        for j in range(i, 0, -1):
            print(j, end=" ")
        for j in range(2, i + 1):
            print(j, end=" ")
        print()
 
print_pattern(7)

Demo29 打印数字III

题目描述

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

                        1
                    1   2   1
                1   2   4   2   1
            1   2   4   8   4   2   1
        1   2   4   8   16  8   4   2   1
    1   2   4   8   16  32  16  8   4   2   1
1   2   4   8   16  32  64  32  16  8   4   2   1

def print_pattern(rows):
    for i in range(rows):
        # 打印前导空格
        for j in range(rows - i - 1):
            print("    ", end="")
 
        for j in range(i + 1):
            print(format(2 ** j, "4d"), end=" ")
 
        for j in range(i - 1, -1, -1):
            print(format(2 ** j, "4d"), end=" ")
 
        print()
 
rows = 7
 
print_pattern(rows)

Demo30 打印菱形I

题目描述

如下所示，是一个高度为9的菱形

    *
   * *
  * * *
 * * * *
* * * * *
 * * * *
  * * *
   * *
    *

用户输入菱形高度n，并打印出该高度下的菱形

输入输出描述

输入高度n，n为奇数

输出该高度的菱形

示例

输入：

5

输出：

  *
 * *
* * *
 * *
  *

def print_diamond(height):
    if height % 2 == 0:
        print("输入的高度必须是奇数")
        return
    for i in range(1, height, 2):
        spaces = (height - i) // 2
        stars = i
        print(" " * spaces + "* " * (stars // 2 + 1))
    for i in range(height, 0, -2):
        spaces = (height - i) // 2
        stars = i
        print(" " * spaces + "* " * (stars // 2 + 1))
height = int(input())
print_diamond(height)

Demo31 打印菱形II

题目描述

如下所示，是一个高度为9的菱形

    *
   * *
  *   *
 *     *
*       *
 *     *
  *   *
   * *
    *

用户输入菱形高度n，并打印出该高度下的菱形

输入输出描述

输入高度n，n为奇数

输出该高度的菱形

示例

输入：

5

输出：

  *
 * *
*   *
 * *
  *

def print_diamond(height):
    if height % 2 == 0:
        print("输入的高度必须是奇数")
        return5
    for i in range(1, height, 2):
        spaces = (height - i) // 2
        print(" " * spaces + "*", end="")
        if i > 1:
            print(" " * (i - 2) + "*", end="")
        print()
    for i in range(height, 0, -2):
        spaces = (height - i) // 2
        print(" " * spaces + "*", end="")
        if i > 1:
            print(" " * (i - 2) + "*", end="")
        print()
height = int(input())
print_diamond(height)

Demo32 打印菱形III

题目描述

如下所示，是一个高度为9的菱形

    *
   ***
  *****
 *******
*********
 *******
  *****
   ***
    *

用户输入菱形高度n，并打印出该高度下的菱形

输入输出描述

输入高度n，n为奇数

输出该高度的菱形

示例

输入：

5

输出：

  *
 ***
*****
 ***
  *

def print_diamond(height):
    if height % 2 == 0:
        print("输入的高度必须是奇数")
        return
    for i in range(1, height + 1, 2):
        spaces = (height - i) // 2
        print(" " * spaces + "*" * i)
    for i in range(height - 2, 0, -2):
        spaces = (height - i) // 2
        print(" " * spaces + "*" * i)
height = int(input("请输入奇数高度: "))
print_diamond(height)

Demo33 猜数字

题目描述

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

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

输入输出描述

每次输入一个整数

每次输出该数字是过高还是过低，如果猜中则输出猜中的数字并结束

示例

输入：50

输出：高了

输入：25

输出：低了

输入：42

输出：高了

输入：39

输出：猜中了！答案就是39

import random
num0 = random.randint(0,100)
user_num = int(input())
while num0 != user_num:
    if num0 > user_num:
        print("小了")
        user_num = int(input())
    if num0 < user_num:
        print("大了")
        user_num = int(input())
else:
    print("猜中了答案就是" + str(num0))

Demo34 最大公约数I

题目描述

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

输入输出描述

输入两个数字

输出最大公约数

示例1

输入：

16 24

输出：

8

示例2

输入：

7 3

输出：

1

def sort(a, b):
    if a > b:
        return b
    else:
        return a
str_list = input()
num0 = int(str_list.split()[0])
num1 = int(str_list.split()[1])
t = 0
for i in range(1,sort(num0, num1)+1):
    if num0 % i == 0 and num1 % i == 0:
        t = i
print(t)

Demo35 判断素数

题目描述

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

输入输出描述

输入一个大于1的正整数

输出Yes表示该数字是素数，否则输出No

示例1

输入：

9

输出：

No

示例2

输入：

11

输出：

Yes

num = int(input())
t = 0
for i in range(2,num):
    if num % i == 0:
        t = t + 1
if t == 0:
    print("Yes")
else:
    print("No")

Demo36 最小公倍数

题目描述

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

输入输出描述

输入两个正整数

输出最小公倍数

示例1

输入：

3 9

输出：

9

示例2

输入：

4 6

输出：

12

def sort(a, b):
    if a > b:
        return a
    else:
        return b
str_list = input()
num0 = int(str_list.split()[0])
num1 = int(str_list.split()[1])
t = 0
i = sort(num0, num1)
while i:
    if i % num0 == 0 and i % num1 == 0:
        t = i
        break
    i = i + 1
print(t)

Demo37 整数的素因子

题目描述

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

输入输出描述

输入一个正整数

输出多行，每行输出一个素因子

示例1

输入：

120

输出：

2 2 2 3 5

解释：

2 * 2 * 2 *3 * 5 = 120

示例2

输入：

100

输出：

2 2 5 5

def prime_factors(n):
    factors = []
    divisor = 2
    while n > 1:
        while n % divisor == 0:
            factors.append(divisor)
            n //= divisor
        divisor += 1
    return factors
number = int(input())
factors = prime_factors(number)
print(" ".join(map(str, factors)))

Demo38 完全数

题目描述

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

例如 6 = 3 + 2 + 1，28 = 14 + 7 + 4 + 2 + 1

输入输出描述

输入一个正整数

输出该数是否为完全数

示例1

输入：

6

输出：

Yes

示例2

输入：

9

输出：

No

num = int(input())
t = 0
for i in range(1, num):
    if num % i == 0:
        t = t + i
if t == num:
    print("Yes")
else:
    print("No")

Demo40 计算π

题目描述

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

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

def calculate_pi(n):
    result = 0
    sign = 1
    for i in range(1, n + 1):
        result += sign * (1 / (2 * i - 1))
        sign *= -1
    return 4 * result
terms = int(input())
approx_pi = calculate_pi(terms)
print("π的近似值:", approx_pi)

Demo41 计算e

题目描述

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

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

def calculate_e(n):
    result = 1
    factorial = 1
    for i in range(1, n + 1):
        factorial *= i
        result += 1 / factorial
    return result
terms = int(input())
approx_e = calculate_e(terms)
print("e的近似值:", approx_e)

Demo42 剪刀石头布II

题目描述

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

import random
user = 0
com = 0
while user < 3 and com < 3:
    num0 = random.randint(0, 2)
    num1 = int(input())
    dir = {0: "剪刀", 1: "石头", 2: "布"}
    print("计算机出的" + dir[num0])
    print("用户出的" + dir[num1])
    if (num0 == 0 and num1 == 1) or (num0 == 1 and num1 == 2) or (num0 == 2 and num1 == 0):
        user = user+1
    elif num0 == num1:
        user = user
        com = com
    else:
        com = com + 1
    print(user)
    print(com)
if user == 3 or com == 3:
    if user > com:
        print("用户赢")
    else:
        print("计算机赢")

Demo43 组合问题I

题目描述

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

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

for i in range(1, 8):
    for j in range(i+1,8):
        print(i,j)

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 i != k and j != k:
                num = i * 100 + j * 10 + k
                print(f"{num}")
                count += 1
 
print(f"总个数: {count}")

 

Demo45 水仙花数

题目描述

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

编写程序，输出所有的水仙花数

for i in range(100, 1000):
    a = i % 10
    b = int(i / 10) % 10
    c = int(i/100)
    if a*a*a + b*b*b + c*c*c == i:
        print(i)

 

Demo46 青蛙跳台阶

题目描述

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

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

def jump_ways_recursive(n):
    if n == 1:
        return 1
    elif n == 2:
        return 2
    else:
        return jump_ways_recursive(n - 1) + jump_ways_recursive(n - 2)
n = int(input())
result = jump_ways_recursive(n)
print(f"{n}个台阶的跳法有{result}种")

Demo47 堆叠相加

题目描述

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

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

输入输出描述

输入两个数据分别为数字a和组数n

输出按照堆叠相加模式算出的和

示例

输入：

3 4

输出：

3702

解释：

3 + 33 + 333 + 3333 = 3702

str_list = input()
a = int(str_list.split()[0])
n = int(str_list.split()[1])
t = 0
for i in range(1,n+1):
    c = str("1"*i)
    c = int(c)
    t = t + c*a
print(t)

Demo48 十进制转二进制

题目描述

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

输入输出描述

输入一个十进制正整数

输出二进制字符串

示例

输入：

9

输出：

1001

def decimal_to_binary(decimal):
    if decimal == 0:
        return '0'
    binary_str = ''
    while decimal > 0:
        remainder = decimal % 2
        binary_str = str(remainder) + binary_str
        decimal //= 2
    return binary_str
decimal_input = int(input())
binary_output = decimal_to_binary(decimal_input)
print(f"{binary_output}")

Demo49 二进制转十进制

题目描述

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

输入输出描述

输入一个二进制字符串

输出十进制数字

示例

输入：

1001

输出：

9

def binary_to_decimal(binary_str):
    decimal = 0
    power = len(binary_str) - 1 
    for bit in binary_str:
        decimal += int(bit) * (2 ** power)
        power -= 1
    return decimal
binary_input = input()
decimal_output = binary_to_decimal(binary_input)
print(f"{decimal_output}")

Demo50 十进制转十六进制

题目描述

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

输入输出描述

输入一个十进制正整数

输出十六进制字符串

示例

输入：

1233321

输出：

1e1b9

def decimal_to_hexadecimal(decimal):
    hex_chars = "0123456789ABCDEF"
    hex_str = ""
    while decimal > 0:
        remainder = decimal % 16
        hex_str = hex_chars[remainder] + hex_str
        decimal //= 16
    return hex_str
decimal_input = int(input())
hexadecimal_output = decimal_to_hexadecimal(decimal_input)
print(f"{hexadecimal_output}")

Demo51 十六进制转十进制

题目描述

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

输入输出描述

输入一个十六进制字符串

输出十进制数字

示例

输入：

1e1b9

输出：

123321

def decimal_to_hexadecimal(decimal):
    hex_chars = "0123456789ABCDEF"
    hex_str = ""
    while decimal > 0:
        remainder = decimal % 16
        hex_str = hex_chars[remainder] + hex_str
        decimal //= 16
    return hex_str
decimal_input = int(input("请输入一个十进制正整数: "))
hexadecimal_output = decimal_to_hexadecimal(decimal_input)
print(f"{decimal_input}的十六进制形式为: {hexadecimal_output}")

Demo52 最长公共前缀

题目描述

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

输入输出描述

输入两行，分别表示s1和s2

输出前缀串

示例

输入：

abcdefg

abcdhko

输出：

abcd

str1 = input()
str2 = input()
str_list1 = []
str_list2 = []
length1 = len(str1)
length2 = len(str2)
t = 0
for char in str1:
    str_list1.append(char)
for char1 in str2:
    str_list2.append(char1)
 
if length1 > length2:
    t = length2
else:
    t = length1
for i in range(0, t):
    if str_list1[i] == str_list2[i]:
        print(str_list1[i],end="")
    else:
        break

Demo53 子串出现的次数

题目描述

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

输入输出描述

输入两行字符串，分别为s1和s2，s2的长度小于等于s1

输出s2在s1中出现的次数

示例1

输入：

ABCsdABsadABCasdhjabcsaABCasd

ABC

输出：

3

示例2

输入：

AAAAAAAA

AAA

输出：

2

s1 = input().strip()
s2 = input().strip()
count = 0
i = 0
while i <= len(s1) - len(s2):
    if s1[i:i+len(s2)] == s2:
        count += 1
        i += len(s2)
    else:
        i += 1
print(count)

Demo54 最长公共子串

题目描述

给定两个字符串 s1 和 s2 ，求 s1 与 s2 之间的最长公共子串，字符区分大小写

输入输出描述

输入两行字符串，分别为s1和s2

输出最长公共子串

示例

输入：

123ABCDEFG83hsad

iughABCDEFG23uy

输出：

ABCDEFG

s1 = input().strip()
s2 = input().strip()
len_s1, len_s2 = len(s1), len(s2)
dp = [[0] * (len_s2 + 1) for _ in range(len_s1 + 1)]
max_length = 0
end_position = 0
for i in range(1, len_s1 + 1):
    for j in range(1, len_s2 + 1):
        if s1[i - 1] == s2[j - 1]:
            dp[i][j] = dp[i - 1][j - 1] + 1
            if dp[i][j] > max_length:
                max_length = dp[i][j]
                end_position = i - 1
        else:
            dp[i][j] = 0
if max_length == 0:
    print("No common substring")
else:
    start_position = end_position - max_length + 1
    result = s1[start_position:end_position + 1]
    print(result)

Demo55 检测密码

题目描述

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

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

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

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

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

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

输入输出描述

输入一串密码

输出该密码是否符合规则

示例1

输入：

123456ab

输出：

No

示例2

输入：

123abcABC

输出：

Yes

def check_password(password):
    if len(password) < 8:
        return "No"
    if not password.isalnum():
        return "No"
    if sum(c.isdigit() for c in password) < 2:
        return "No"
    if sum(c.isupper() for c in password) < 2:
        return "No"
    return "Yes"
password = input()
result = check_password(password)
print(result)

Demo56 回文素数

题目描述

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

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

def huiwen(num):
    num_str = str(num)
    return num_str == num_str[::-1]
 
def sushu(num):
    t = 0
    for i in range(2, num):
        if num % i == 0:
            t = t + 1
    if t == 0:
        return 1
    else:
        return 0
num = 10
a = 0
str_list = []
while a < 100:
    if huiwen(num) and sushu(num):
        str_list.append(num)
        a = a+1
    num = num+1
for i in range(0, 100):
    print(str_list[i], end=' ')
    if i % 10 == 0:
        print()

Demo57 反素数

题目描述

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

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

def huiwen(num):
    num_str = str(num)
    if num_str == num_str[::-1]:
        return 0
    else:
        return 1
 
def sushu(num):
    t = 0
    for i in range(2, num):
        if num % i == 0:
            t = t + 1
    if t == 0:
        return 1
    else:
        return 0
def fan(num):
    num_str = str(num)
    return num_str[::-1]
num = 10
a = 0
str_list = []
while a < 100:
    if huiwen(num) and sushu(num) and sushu(int(fan(num))):
        str_list.append(num)
        a = a+1
    num = num+1
for i in range(0, 100):
    print(str_list[i], end=' ')
    if i % 10 == 0:
        print()

 

Demo58 双素数

题目描述

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

输出显示小于1000的双素数

def sushu(n):
    if n < 2:
        return False
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            return False
    return True
 
def generate_twin_primes(limit):
    twin_primes = []
    for num in range(2, limit - 1):
        if sushu(num) and sushu(num + 2):
            twin_primes.append((num, num + 2))
    return twin_primes
 
twin_primes_list = generate_twin_primes(1000)
 
for twin_prime in twin_primes_list:
    print(twin_prime[0], twin_prime[1])

 

Demo59 梅森素数

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

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

def sushu(num):
    if num < 2:
        return False
    for i in range(2, int(num**0.5) + 1):
        if num % i == 0:
            return False
    return True
def mersenne_prime(p):
    return 2**p - 1
for p in range(1, 32):
    candidate = mersenne_prime(p)
    if sushu(candidate):
        print(f"{candidate}")

 

Demo60 平方根的近似求法

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

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

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

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

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

def babylonian_sqrt(n, epsilon=0.0001):
    last_guess = 1.0
    next_guess = (last_guess + n / last_guess) / 2.0
    while abs(next_guess - last_guess) >= epsilon:
        last_guess = next_guess
        next_guess = (last_guess + n / last_guess) / 2.0
    return next_guess
number = 25
result = babylonian_sqrt(number)
print(f"{result}")