demo01---demo30

demo01

"""

数据：cel fah

步骤：

1.输入cel

2.根据给定公式计算fah

3.输出fah

"""

cel = eval(input())

fah = 9 / 5 * cel + 32

print("%.1f" % fah)

demo02

"""

数据：radius length area volume

步骤：

1.输入radius和length

2.计算area底面积

3.计算volume体积

4.输出

"""

radius, length = eval(input())

area = radius * radius * 3.14

volume = area * length

print("%.2f" % area)

print("%.2f" % volume)

demo03

"""

它首先使用input函数等待用户输入一个表示英尺数的值。用户输入的值被转换为浮点数（float），以便在后续计算中可以进行数学运算。

接下来，代码将用户输入的英尺数乘以0.305，这是英尺到米的转换率。乘积的结果即为转换后的米数。

最后，使用print函数将结果输出到屏幕上。在输出时，使用了字符串的format方法，其中{:.4f}指定了输出格式，表示将浮点数四舍五入到小数点后四位。这样，输出的结果就是以四位小数的形式显示的米数。

"""

feet = float(input("请输入英尺数: "))

meter = feet * 0.305

print("转换后的米数为: {:.4f}".format(meter))

demo04

"""

首先使用input函数等待用户输入两个值：小计和酬金率。这两个值由用户输入，用空格分隔开。

接着，使用split()方法将用户输入的字符串分割成两部分，并且map(float, ...)将它们转换为浮点数。这样就得到了小计和酬金率的浮点数值。

然后，代码根据小计和酬金率计算小费。小费的计算公式是小计乘以酬金率除以100，即小计乘以酬金率的百分比。

接下来，计算合计金额，即小计加上小费。

最后，使用print函数输出计算结果。在输出时，使用了字符串的format方法，其中{:.2f}指定了输出格式，表示将浮点数四舍五入到小数点后两位。这样，输出的小费和合计金额就保留了两位小数。

"""

subtotal, gratuity_rate = map(float, input("请输入小计和酬金率（用空格分隔）: ").split())

# 计算小费

gratuity = subtotal * (gratuity_rate / 100)

# 计算合计金额

total_amount = subtotal + gratuity

# 输出结果

print("小费: {:.2f}".format(gratuity))

print("合计金额: {:.2f}".format(total_amount))

demo05

"""

数据：num ge shi bai total

步骤：

1.输入一个数字[0,1000）

2.按照顺序 从右往左拆

    123 % 10 = 3

    123 // 10 = 12

    12 % 10 = 2

    12 // 10 = 1

    1 % 10 = 1

    1 // 10 = 0

    3.三者相加 输出

"""

num = eval(input())

ge = num % 10

num //= 10

shi = num % 10

num //= 10

bai = num % 10

nsum = ge + shi + bai

print(nsum)

demo06

"""

数据：minutes hours days years

步骤:

1.输入minutes

2.计算总小时数 minutes // 60

3.计算总天数 hours // 24

4.计算总年数 days // 365

5.输出

"""

minutes = eval(input())

hours = minutes // 60

days = hours // 24

years = days // 365

days = days % 365

print(years)

print(days)

demo07

"""

1.获取输入值：

使用input函数分别获取三个输入值：水量（以千克为单位）、初始温度和最终温度（都以摄氏度为单位）。这些值由用户在控制台输入。

2.计算能量：

首先，定义了水的比热容 specific_heat_capacity 为常数值 (4.186 , J/(g \cdot °C))。比热容是指单位质量的物质温度升高1摄氏度所需要的热量。

然后，根据提供的公式

[ Q = M \times c \times (T_f - T_i) ]

计算所需的能量 energy。其中，( Q ) 是能量（以焦耳计），( M ) 是水的质量，( c ) 是水的比热容，( T_f ) 是最终温度，( T_i ) 是初始温度。

这里的水量是以千克为单位，所以需要将其乘以比热容和温度变化量来计算总能量。

3.输出结果：

最后，使用 print 函数将计算出的能量值输出到屏幕上。在输出时，使用了字符串的 format 方法，保留一位小数。

"""

# 输入水量、初始温度和最终温度

mass = float(input("请输入水量（kg）: "))

initial_temp = float(input("请输入初始温度（摄氏度）: "))

final_temp = float(input("请输入最终温度（摄氏度）: "))

# 水的比热容

specific_heat_capacity = 4.186  # 单位：J/(g·°C)

# 计算所需的能量

energy = mass * specific_heat_capacity * (final_temp - initial_temp)

# 输出结果

print("所需的能量值为: {:.1f} J".format(energy))

demo08

"""

1.获取输入值：

使用input函数获取用户输入的一个四位整数，并将其转换为整数类型，存储在变量num中。

2.提取各个位数：

通过数学运算和取模运算，将这个四位整数的各个位数提取出来：

thousands用来表示千位数，通过整除1000得到；

hundreds用来表示百位数，先通过取模1000得到千位和百位的数字，然后再整除100得到百位数；

tens用来表示十位数，先通过取模100得到百位和十位的数字，然后再整除10得到十位数；

units用来表示个位数，通过取模10得到个位数。

3.输出结果：

最后，使用print函数将反向顺序的各个位数分别输出到四行中，依次为个位数、十位数、百位数和千位数。每行都打印对应的位数，并以冒号和空格结尾，然后输出相应的位数值。

"""

# 输入一个四位整数

num = int(input("请输入一个四位整数: "))

# 获取各个位上的数字

thousands = num // 1000

hundreds = (num % 1000) // 100

tens = (num % 100) // 10

units = num % 10

# 输出反向顺序的各个位数

print("千位数为:", units)

print("百位数为:", tens)

print("十位数为:", hundreds)

print("个位数为:", thousands)

demo09

"""

数据：三个顶点坐标x-1-2-3 y1-2-3 三边side1-2-3 半周长s area

步骤:

1.输入数据

2.分别计算三边长度

3.通过三边算面积

4.输出

"""

x1, y1, x2, y2, x3, y3 = eval(input())

side1 = ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5

side2 = ((x3 - x2) ** 2 + (y3 - y2) ** 2) ** 0.5

side3 = ((x1 - x3) ** 2 + (y1 - y3) ** 2) ** 0.5

s = (side1 + side2 + side3) / 2

area = (s * (s - side1) * (s - side2) * (s - side3)) ** 0.5

print("%.1f" % area)

demo10

"""

时间戳是指从 1970 年 1 月 1 日 00:00:00 开始经过的秒数。

"""

import time

print(time.time())

demo11

"""

首先，程序使用 input 函数从用户获取输入。用户需要按照指定格式输入三角形的三个顶点坐标，即 x1、y1、x2、y2、x3 和 y3，这些数据之间用空格分隔。

接着，程序使用 math.sqrt 函数和平方根运算符 ** 计算了三条边的长度。这里使用的是直角三角形的勾股定理，即 ( c = \sqrt{(x2 - x1)^2 + (y2 - y1)^2} )，( b = \sqrt{(x3 - x1)^2 + (y3 - y1)^2} )，( a = \sqrt{(x3 - x2)^2 + (y3 - y2)^2} )。

然后，程序计算了三个角度的余弦值，利用了余弦定理：

[

\cos© = \frac{a^2 + b^2 - c^2}{2ab}

]

接着，使用 math.degrees 函数将弧度值转换为角度制，并将结果保留两位小数。

最后，程序输出计算得到的三个角度值，分别对应三角形的 A、B、C 三个角，格式为 “A: xx.xx”、“B: xx.xx”、“C: xx.xx”，其中 xx.xx 表示角度值保留两位小数。

这样，用户就可以通过输入三角形的三个顶点坐标，得到该三角形的三个角度值。

"""

import math

# 获取输入

x1, y1, x2, y2, x3, y3 = map(float, input("请输入三角形三个顶点的坐标(x1 y1 x2 y2 x3 y3): ").split())

# 计算两点之间的距离

a = math.sqrt((x2 - x3)**2 + (y2 - y3)**2)

b = math.sqrt((x1 - x3)**2 + (y1 - y3)**2)

c = math.sqrt((x1 - x2)**2 + (y1 - y2)**2)

# 计算三个角度的余弦值

cos_A = (b**2 + c**2 - a**2) / (2 * b * c)

cos_B = (a**2 + c**2 - b**2) / (2 * a * c)

cos_C = (a**2 + b**2 - c**2) / (2 * a * b)

# 将余弦值转换为角度制

angle_A = math.degrees(math.acos(cos_A))

angle_B = math.degrees(math.acos(cos_B))

angle_C = math.degrees(math.acos(cos_C))

# 输出结果

print("A:", format(angle_A, ".2f"))

print("B:", format(angle_B, ".2f"))

print("C:", format(angle_C, ".2f"))

demo12

"""

首先，代码定义了一个字典 coin_values，其中包含了不同硬币种类及其对应的面值。每种硬币都是一个键值对，键是硬币的名称，值是硬币的面值。

接着，程序通过 input 函数获取用户输入的总金额，并将其转换为浮点数。

然后，初始化了一个字典 coin_counts，用于记录每种硬币的数量，初始值都为0。

随后，代码通过一个循环从面值最大的硬币开始兑换。循环中使用了 sorted 函数对硬币种类进行排序，关键字参数 key=lambda x: x[1] 表示按照硬币面值进行排序，reverse=True 表示降序排列。这样，在循环中就能够按照面值从大到小的顺序依次兑换硬币。

在循环中，首先计算当前面值硬币的数量，即 count = int(total_amount // value)，然后更新硬币数量和剩余金额。这里用到了整除运算符 //，它可以得到除法运算的整数部分。

最后，程序输出了兑换结果，遍历 coin_counts 字典，打印出每种硬币的名称和数量。

"""

# 定义硬币种类和对应面值

coin_values = {

    "一元硬币": 1,

    "两角五分硬币": 0.25,

    "一角硬币": 0.1,

    "五分硬币": 0.05,

    "一分硬币": 0.01

}

# 获取总金额

total_amount = float(input("请输入总金额："))

# 初始化每种硬币的数量为0

coin_counts = {coin: 0 for coin in coin_values}

# 从面值最大的硬币开始兑换

for coin, value in sorted(coin_values.items(), key=lambda x: x[1], reverse=True):

    count = int(total_amount // value)  # 计算当前面值硬币的数量

    coin_counts[coin] = count  # 更新硬币数量

    total_amount -= count * value  # 更新剩余金额

# 输出结果

print("兑换结果：")

for coin, count in coin_counts.items():

    print(coin, ":", count)

demo13

"""

首先，通过 input 函数获取用户输入的边的个数和边长，并使用 map 函数将输入的字符串分割后转换为浮点数。

这里的 map(float, input("请输入边的个数和边长（以空格分隔）：").split()) 将输入的字符串按空格分割成两部分，然后将它们转换为浮点数，并将结果分别赋值给变量 n 和 s，分别表示边的个数和边长。

接着，根据正多边形的面积公式进行计算，并将结果存储在变量 area 中。公式为：

[

\text{area} = \frac{n \times s^2}{4 \times \tan(\pi / n)}

]

其中，(n) 表示边的个数，(s) 表示边长。

最后，使用格式化字符串将计算得到的正多边形的面积输出，保留两位小数。

通过 "正{}多边形的面积为：{:.2f}".format(int(n), area) 这一行代码，将 n 转换为整数，然后将其插入到字符串中的 {} 处，将 area 插入到字符串中的 {:.2f} 处，表示保留两位小数。

"""

import math

# 获取输入数据

n, s = map(float, input("请输入边的个数和边长（以空格分隔）：").split())

# 计算正多边形的面积

area = (n * s**2) / (4 * math.tan(math.pi / n))

# 输出正多边形的面积，保留两位小数

print("正{}多边形的面积为：{:.2f}".format(int(n), area))

demo14

"""

数据:体重weight 身高height BMI

步骤:

1.输入体重和身高

2.计算BMI的值

3.参照表格

4.输出对应的结果

"""

weight, height = eval(input())

BMI = weight / height ** 2

if BMI < 18.5:

    print("超轻")

elif BMI < 25.0:

    print("标准")

elif BMI < 30.0:

    print("超重")

else:

    print("肥胖")

demo15

"""

这段代码首先通过 input 函数获取用户输入的年份，并将其转换为整数类型。

然后，通过条件判断语句 if，判断输入的年份是否为闰年。根据闰年的定义，如果年份能被4整除但不能被100整除，或者能被400整除，则为闰年。因此，判断条件为 (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0)。

如果满足条件，则输出 “Yes” 表示该年份为闰年，否则输出 “No” 表示不是闰年。

"""

# 获取输入的年份

year = int(input("请输入一个年份："))

# 判断是否为闰年

if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):

    print("Yes")

else:

    print("No")

demo16

"""

数据:随机产生的数字randNum 用户输入的数字 userNum r1 r2 u1 u2

randNum = r1 * 10 + r2

userNum = u1 * 10 + u2

步骤:

1.输入

2.拆数字

3.判断

(1) randNum == userNum

(2) r1 == u2 and r2 == u1

(3) r1 == u1 or r1 == u2 or r2 == u1 or r2 == u2

(4) 啥也没有

4.输出对应的结果

"""

import random

randNum = random.randint(10, 99)

userNum = eval(input())

r1 = randNum // 10

r2 = randNum % 10

u1 = userNum // 10

u2 = userNum % 10

if randNum == userNum:

    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 delt x1 x2

步骤:

1.输入 a b c

2.计算 delt = b^2 - 4ac

3.delt判断

(1)> 0

(2)== 0

(3)< 0

4.根据不同结果输出

"""

a, b, c = eval(input())

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)

else:

    print("无实数解")

demo18

"""

这段代码首先通过 input 函数获取用户输入的系数和常数，并使用 map 函数将输入的字符串分割后转换为浮点数，然后分别赋值给变量 a、b、c、d、e、f，分别表示方程组的系数和常数。

接着，计算判别式 (D = ad - bc)。

然后，判断判别式是否为零。如果判别式为零，则输出 “无解”。

如果判别式不为零，则使用克莱姆法则计算方程组的解：(x = \frac{{ed - bf}}{{D}})，(y = \frac{{af - ec}}{{D}})。

最后，使用格式化字符串将计算得到的 (x) 和 (y) 的解输出，保留一位小数。

"""

# 获取输入的系数和常数

a, b, c, d, e, f = map(float, input("请输入a、b、c、d、e、f（以空格分隔）：").split())

# 计算判别式

D = a * d - b * c

# 判断是否有解

if D == 0:

    print("无解")

else:

    # 计算x和y的解

    x = (e * d - b * f) / D

    y = (a * f - c * e) / D

    # 输出解，保留一位小数

    print("{:.1f}".format(x))

    print("{:.1f}".format(y))

demo19

"""

1.用户通过input函数输入两个数字，分别表示今日星期几的数字和未来某天的天数。

2.代码定义了一个字典weekdays_dict，将数字表示的星期几映射到中文的星期表示上。

3.计算未来某天是星期几的索引，通过取模运算(today + future_days) % 7实现。

4.使用字典查找对应的星期几名称，将计算得到的索引作为字典的键来获取对应的中文星期表示。

5.最后，将结果输出到控制台。

"""

# 获取输入的今日星期几的数字和未来某天的天数

today, future_days = map(int, input("请输入今日星期几的数字和未来某天的天数（以空格分隔）：").split())

# 定义星期字典

weekdays_dict = {0: "星期天", 1: "星期一", 2: "星期二", 3: "星期三", 4: "星期四", 5: "星期五", 6: "星期六"}

# 计算未来某天是星期几的索引

future_day_index = (today + future_days) % 7

# 使用字典查找对应的星期几名称

future_weekday = weekdays_dict[future_day_index]

# 输出结果

print(future_weekday)

demo27

print("模式A")
for n in range(1, 7):
    for i in range(1, n + 1):
        print(i, end=" ")
    print()

print("模式B")
for n in range(1, 7):
    for i in range(1, 8 - n):
        print(i, end = " ")
    print()

print("模式C")
for n in range(1, 7):
    for k in range(6 - n):
        print(" ", end = " ")
    for i in range(n, 0, -1):
        print(i, end = " ")
    print()
print("模式D")
for n in range(6, 0, -1):
    for k in range(6 - n ):
        print(" ", end = " ")
    for i in range(1, n + 1):
            print(i, end = " ")
    print()
 

demo20

"""

这段代码中，首先通过input函数获取用户输入的年、月、日。

然后使用datetime模块创建一个日期对象，并使用timetuple().tm_yday方法获取该日期在年份中的天数。最后将结果输出到控制台。

"""

# 获取输入的年、月、日

year, month, day = map(int, input("请输入年、月、日（以空格分隔）：").split())

# 计算该日是今年中的第几天

import datetime

date = datetime.date(year, month, day)

day_of_year = date.timetuple().tm_yday

# 输出结果

print(f"该日是今年中的第{day_of_year}天")

demo21

import random

# 定义选择的字典

choices = {0: "剪刀", 1: "石头", 2: "布"}

# 计算机随机选择

computer_choice = random.randint(0, 2)

# 用户输入选择

user_choice = int(input("请输入数字（0表示剪刀，1表示石头，2表示布）："))

# 输出计算机和用户的选择

print("计算机出的是：" + choices[computer_choice])

print("用户出的是：" + choices[user_choice])

# 判断胜负

if computer_choice == user_choice:

    print("平局")

elif (computer_choice - user_choice) % 3 == 1:

    print("计算机赢")

else:

    print("用户赢")

demo22

"""

这段代码首先通过 input() 函数接受用户输入的三个边长，然后使用 split() 方法将输入的字符串分割成三个部分，再利用 map() 函数将这三个部分转换为浮点数类型，并分别赋值给变量 a, b, c，即表示三角形的三个边长。

接着，代码使用条件语句 if 来判断输入的三边长度是否能构成一个合法的三角形。

合法的三角形条件是任意两边之和大于第三边。如果条件满足，则进入 if 分支，计算三角形的周长，并将其转换为整数类型，然后输出合法并显示周长；如果条件不满足，则进入 else 分支，输出非法。

"""

# 输入三个边长

a, b, c = map(float, input("请输入三角形的三个边长（用空格分隔）：").split())

# 判断是否构成合法三角形

if a + b > c and a + c > b and b + c > a:

    # 计算周长并输出结果

    perimeter = int(a + b + c)

    print("合法，三角形的周长为:", perimeter)

else:

    print("非法")

demo23

"""

1.year, month, day = map(int, input("请输入年、月、日（用空格分隔）：").split()):

这一行代码首先使用 input() 函数来提示用户输入年、月、日，并且使用 split() 方法将输入的字符串分割成一个由年、月、日组成的列表，

然后 map(int, ...) 将这些字符串转换为整数，并通过多重赋值将它们分别赋给 year、month、day 变量。

2.if month < 3: ...: 这一部分代码检查月份是否在1或2之间，如果是，将月份加上12，年份减去1，这是为了将一月和二月视为上一年的13月和14月，以符合 Zeller’s Congruence 算法的要求。

3.接下来的几行代码计算出 Zeller’s Congruence 算法中的各个参数值，包括 century、year_of_century 等。

4.weekday = (day + (13 * (month + 1)) // 5 + year_of_century + year_of_century // 4 + century // 4 - 2 * century) % 7:

这一行应用了 Zeller’s Congruence 算法来计算星期几的值，结果被存储在 weekday 变量中。

5.weekday = (weekday + 6) % 7: 这一行对星期几的值进行调整，以确保星期日被表示为0，星期一为1，以此类推。

6.weekdays = ["星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"]: 这一行创建了一个列表 weekdays，其中包含了星期日到星期六的文字表示。

7.print(weekdays[weekday]): 最后一行根据计算得到的星期几的值来从 weekdays 列表中取出对应的星期几文字，并将其打印出来。

"""

# 输入年、月、日

year, month, day = map(int, input("请输入年、月、日（用空格分隔）：").split())

# 对月份进行调整，将一月和二月看作上一年的13月和14月

if month < 3:

    month += 12

    year -= 1

# 计算公式中的各个参数值

century = year // 100

year_of_century = year % 100

# 应用泽勒的一致性算法

weekday = (day + (13 * (month + 1)) // 5 + year_of_century + year_of_century // 4 + century // 4 - 2 * century) % 7

# 调整星期几的表示，0表示星期日，1表示星期一，...，6表示星期六

weekday = (weekday + 6) % 7

# 星期几的文字表示（去除空格）

weekdays = ["星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"]

# 输出结果

print( weekdays[weekday])

demo24

"""

1.用户通过 input() 函数输入八个数据，分别为四个点的坐标 (x1, y1), (x2, y2), (x3, y3), (x4, y4)。

这些数据被以空格分隔并用 split() 函数分割后，通过 map(int, ...) 函数转换为整数，并用 map() 函数一次性赋值给了变量 x1, y1, x2, y2, x3, y3, x4, y4。

2.接下来，代码计算了直线 A 和直线 B 的斜率 m 和 n。如果两条直线的横坐标差为零（即垂直于 x 轴），则斜率被设为正无穷（float('inf')）。

斜率的计算公式是 (y2 - y1) / (x2 - x1) 和 (y4 - y3) / (x4 - x3)。

3.然后，代码计算了直线 A 和直线 B 的截距 c1 和 c2。截距的计算公式是 y1 - m * x1 和 y3 - n * x3。同样地，如果直线斜率为无穷大，截距就被设置为相应的横坐标值。

4.接下来，代码通过比较斜率和截距，判断了两条直线是否平行或重合。如果斜率相等但截距不相等，则两条直线平行；如果斜率和截距都相等，则两条直线重合。

5.最后，如果两条直线不平行也不重合，代码计算了交点的横坐标和纵坐标，并将其格式化输出，保留两位小数。

"""

# 输入直线A和直线B上的点的坐标

x1, y1, x2, y2, x3, y3, x4, y4 = map(int, input("请输入八个数据，分别为x1 y1 x2 y2 x3 y3 x4 y4，数据之间用空格分隔：").split())

# 计算直线A和直线B的斜率

m = (y2 - y1) / (x2 - x1) if x2 != x1 else float('inf')  # 处理直线A斜率为无穷大的情况

n = (y4 - y3) / (x4 - x3) if x4 != x3 else float('inf')  # 处理直线B斜率为无穷大的情况

# 计算直线A和直线B的截距

c1 = y1 - m * x1 if m != float('inf') else x1  # 处理直线A斜率为无穷大的情况

c2 = y3 - n * x3 if n != float('inf') else x3  # 处理直线B斜率为无穷大的情况

# 判断两条直线是否平行或重合

if m == n and c1 != c2:

    print("两条直线平行")

elif m == n and c1 == c2:

    print("两条直线重合")

else:

    # 计算交点的坐标

    x = (c2 - c1) / (m - n)

    y = m * x + c1

    print("{:.2f}, {:.2f}".format(x, y))

demo25

"""

1.用户通过 input() 函数输入一个三位整数，输入的内容被存储在变量 num 中。

2.接着，程序使用条件语句 if 来判断输入的数字是否是回文数。条件部分是 num == num[::-1]，其中 num[::-1] 表示对字符串 num 进行逆序操作，即将其倒置。

这是通过切片操作来实现的，[::-1] 表示从字符串的最后一个字符到第一个字符的倒序遍历。如果倒置后的字符串与原始字符串相同，则说明输入的数字是回文数。

3.如果条件成立（即输入的数字是回文数），则输出 “Yes”；否则输出 “No”。

"""

# 输入一个三位整数

num = input("请输入一个三位整数：")

# 判断是否是回文数

if num == num[::-1]:

    print("Yes")

else:

    print("No")

demo26

"""

1.首先，程序通过 input() 函数分别获取两个矩形的数据。

每个矩形的数据包括矩形的中心坐标 x、y 以及矩形的宽和高，这些数据被以空格分隔，并通过 split() 函数分割后，通过 map(float, ...) 函数转换为浮点数，并用 map() 函数一次性赋值给了变量 rect1 和 rect2。

2.接下来，程序从 rect1 和 rect2 中分别取出矩形的中心坐标 x1, y1, x2, y2 和宽高 w1, h1, w2, h2。

3.然后，程序分别计算了两个矩形的四个顶点坐标，分别存储在 rect1_points 和 rect2_points 列表中。每个矩形的四个顶点由中心坐标加上宽高的一半或一半的负值组成。

4.接下来，程序通过遍历 rect1_points 中的每个点，检查它是否落在 rect2 所构成的矩形内部。如果有任意一个点在 rect2 内部，则说明两个矩形重叠，将 overlap 设为 True，并跳出循环。

5.然后，程序判断第一个矩形是否完全包含第二个矩形。这通过检查第一个矩形的左下角和右上角是否分别小于或大于等于第二个矩形的相应角来实现。

6.最后，程序根据重叠和包含的情况输出结果。如果包含，则输出 “包含”；如果重叠，则输出 “重叠”；如果既不包含也不重叠，则输出 “相离”。

"""

# 输入两个矩形的数据

rect1 = list(map(float, input().split()))

rect2 = list(map(float, input().split()))

x1, y1, w1, h1 = rect1

x2, y2, w2, h2 = rect2

# 计算矩形的四个顶点坐标

rect1_points = [(x1 - w1/2, y1 - h1/2), (x1 + w1/2, y1 - h1/2),

                (x1 - w1/2, y1 + h1/2), (x1 + w1/2, y1 + h1/2)]

rect2_points = [(x2 - w2/2, y2 - h2/2), (x2 + w2/2, y2 - h2/2),

                (x2 - w2/2, y2 + h2/2), (x2 + w2/2, y2 + h2/2)]

# 判断是否重叠

overlap = False

for point in rect1_points:

    if (rect2_points[0][0] <= point[0] <= rect2_points[1][0] and

        rect2_points[0][1] <= point[1] <= rect2_points[3][1]):

        overlap = True

        break

# 判断是否包含

contain = (x1 - w1/2 <= x2 - w2/2 and x1 + w1/2 >= x2 + w2/2 and

           y1 - h1/2 <= y2 - h2/2 and y1 + h1/2 >= y2 + h2/2)

# 输出结果

if contain:

    print("包含")

elif overlap:

    print("重叠")

else:

    print("相离")

demo27

print("模式A")

for n in range(1, 7):

    for i in range(1, n + 1):

        print(i, end=" ")

    print()

print("模式B")

for n in range(1, 7):

    for i in range(1, 8 - n):

        print(i, end = " ")

    print()

print("模式C")

for n in range(1, 7):

    for k in range(6 - n):

        print(" ", end = " ")

    for i in range(n, 0, -1):

        print(i, end = " ")

    print()

print("模式D")

for n in range(6, 0, -1):

    for k in range(6 - n ):

        print(" ", end = " ")

    for i in range(1, n + 1):

            print(i, end = " ")

    print()

demo28

"""

1.外部循环从 1 到 7 遍历 n，总共会执行内部循环 7 次。

2.第一个内部循环 (for k in range(7 - n)) 打印空格，以对齐数字形成一种特定的形状。

3.第二个内部循环 (for x in range(1 - n, n)) 根据当前行的位置计算要打印的数字。

4.要打印的数字是 abs(x) + 1，即内层循环变量 x 的绝对值加 1。这样就会形成一种逐渐增大然后逐渐减小的数字序列。

5.每行通过 print() 函数打印完毕后换行。

"""

for n in range(1, 8):

    for k in range(7 - n):

        print(" ",end=" ")

    for x in range(1 - n, n):

        print(abs(x) + 1, end = " ")

    print()

demo29

"""

1.外部循环从 1 到 7 遍历 n，总共会执行内部循环 7 次。

2.第一个内部循环 (for k in range(7 - n)) 打印空格，以对齐数字形成金字塔形状。

3.第二个内部循环 (for x in range(1 - n, n)) 根据金字塔的位置计算要打印的值。

4.要打印的值是 2 ** (n - 1 - abs(x))，即 2 的幂。从金字塔顶部开始，数字逐渐增大，按照 2 的幂增加。

5.格式化符号 %2d 用来确保数字打印出来时占据 2 个字符的宽度。

"""

n = 4

for n in range(1, 8):

    for k in range(7 - n):

        print("  ", end = " ")

    for x in range(1 - n, n):

        num = 2 ** (n - 1 - abs(x))

        print("%2d" % (num), end = " ")

    print()

demo30

"""

1.n = eval(input()): 这一行代码要求用户输入一个整数 n，并将其赋值给变量 n。eval() 函数用于执行一个字符串表达式，并返回表达式的值。这里用它来获取用户输入的整数。

2.for i in range(1, n + 1):: 这是外层循环，控制行数，从1到 n。

3.for k in range(abs(n // 2 + 1 - i)):: 这是用来打印每行的空格，根据当前行 i 的位置来确定每行星号前面的空格数。

abs() 函数是取绝对值的函数，n // 2 + 1 - i 表示当前行前面的空格数，abs() 函数保证了无论 n 是奇数还是偶数，都能正确地计算空格数。

4.for j in range(1, i + 1):: 这是内层循环，控制每行星号的个数，从1到当前行数 i。

5.if j <= i and i + j <= n + 1:: 这一行是一个条件判断，确保星号的打印范围在合适的位置，即保证每行打印的星号不会超过当前行数 i，并且保证星号的位置不会超过整个三角形的宽度 n。

6.print("*", end = " "): 打印一个星号，并且末尾不换行，而是打印一个空格。

7.print(): 打印完一行星号后，进行换行，开始打印下一行。

"""

n = eval(input())

for i in range(1, n + 1):

    for k in range(abs(n // 2 + 1 - i)):

        print (" ", end = "")

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

        if j <= i and i + j <= n + 1:

            print("*", end = " ")

    print()