2023开发通用编程题集

已于 2023-12-04 17:04:14 修改
阅读量126 收藏
点赞数
文章标签： 算法
于 2023-11-14 17:42:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73832254/article/details/134099824
版权

第一部分 语法基础

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

题目描述

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

转换的公式为如下：fahrenheit=(9/5)*celsius+32

输入输出描述

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

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

示例

输入：

43

输出：

109.4

def temperature():
    '''摄氏温度转化为华氏温度'''
    celsius = float(input("输入："))
    fahrenheit =(9 / 5) * celsius + 32
    return fahrenheit


fa = temperature()
print("输出:%.1f"%fa)

Demo02 计算圆柱体的体积

题目描述

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

area=radius*radius*Pi

volume=area*length

输入输出描述

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

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

示例

输入：

5.5 12

输出：

95.03

1140.41

import math


def cylinder_area():
    ''' 计算圆柱体的体积'''
    print("输入：")
    radius, length = input().split()
    area = float(radius) ** 2 * math.pi
    volume = area * float(length)
    print("输出：")
    print("%.2f"%area)
    print("%.2f"%volume)


cylinder_area()

Demo03 将英尺数转换为米数

题目描述

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

输入输出描述

输入一个数据表示英尺数

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

示例

输入：

16.5

输出：

5.0325

def convert_feet_to_meters():
    '''英尺数转换为米数'''
    print("输入：")
    feet = float(input())
    meters = feet * 0.305
    print("输入：%.4f"%meters)


convert_feet_to_meters()

Demo04 计算小费

题目描述

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

输入输出描述

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

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

示例

输入：

15.69 15

输出：

2.35

18.04

def calculate_tips():
    '''计算小费'''
    print("输入：")
    subtotal, Remuneration_rate = input().split()
    tip = float(subtotal) * float(Remuneration_rate) / 100
    total_amount = float(subtotal) + tip
    print("输出：")
    print("%.2f"%tip)
    print("%.2f"%total_amount)


calculate_tips()

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

题目描述

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

输入输出描述

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

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

示例1

输入：

999

输出：

27

解释：

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

示例2

输入：

12

输出：

3

def sum_all():
    '''对一个整数中的各位数字求和'''
    sum_al = 0
    print("输入：")
    integer = float(input())
    while 0 > integer or integer > 1000:
        integer = float(input("输入错误，请重新输入："))
    while integer > 0:
        sum_al += (integer % 10)
        integer //= 10
    print("输出：")
    print("%d"%sum_al)


sum_all()

Demo06 计算年数和天数

题目描述

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

输入输出描述

输入一个分钟数

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

示例

输入：

1000000000

输出：

1902

214

def  calculate_years_and_days():
    '''计算年数和天数'''
    print("输入：")
    minutes = int(input())
    Years = minutes / 1440 // 365
    Days =  minutes / 1440 % 365
    print("输出：")
    print(int(Years))
    print(int(Days))


calculate_years_and_days()

Demo07 计算能量

题目描述

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

Q = M * (finalTemperature - initialTemperature) * 4184

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

输入输出描述

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

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

示例

输入：

55.5

3.5

10.5

输出：

1625484.0

def calculate_energy():
    '''计算能量'''
    print("输入：")
    M = float(input())
    initialTemperature = float(input())
    finalTemperature = float(input())
    Q = M * (finalTemperature - initialTemperature) * 4184
    print("输出：")
    print("%.1f"%Q)


calculate_energy()

Demo08 分割数字

题目描述

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

输入输出描述

输入一个四位整数

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

示例

输入：

5213

输出：

3

1

2

5

def dividing_numbers():
    '''分割数字'''
    print("输入：")
    num = int(input())
    while num < 1000 or num > 10000:
        num = input("输入错误，请重新输入：")
    print("输出：")
    while num > 0:
        print(num % 10)
        num //= 10


dividing_numbers()

Demo09 计算三角形的面积

题目描述

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

s=(side1+side2+side3)/2 \\ area = \sqrt{s(s-side1)(s-side2)(s-side3)}

输入输出描述

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

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

示例

输入：

1.5 -3.4 4.6 5 9.5 -3.4

输出：

33.6

def area_of_a_triangle():
    ''' 计算三角形的面积'''
    print("输入：")
    x1, y1, x2, y2, x3, y3 = input().split()
    x1 = float(x1)
    x2 = float(x2)
    x3 = float(x3)
    y1 = float(y1)
    y2 = float(y2)
    y3 = float(y3)
    side1 = ((x1 -x2) ** 2 + (y1 - y2) ** 2) ** 0.5
    side2 = ((x1 -x3) ** 2 + (y1 - y3) ** 2) ** 0.5
    side3 = ((x3 -x2) ** 2 + (y3 - y2) ** 2) ** 0.5
    s = (side1 + side2 + side3) / 2
    area = (s * (s - side1) * (s - side2) * (s- side3)) ** 0.5
    print("输出：")
    print("%.1f"%area)


area_of_a_triangle()

Demo10 显示当前时间

题目描述

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

输入输出描述

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

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

示例

输入：

8

输出：

21:43:12

import datetime


def get_current_time(timezone):
    current_time = datetime.datetime.now()
    adjusted_time = current_time + datetime.timedelta(hours=timezone)
    formatted_time = adjusted_time.strftime("%H:%M:%S")
    return formatted_time


timezone = int(input("请输入时区："))
current_time = get_current_time(timezone)
print("当前时间为：", current_time)

Demo11 计算三角形的三个角

题目描述

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

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三个角的度数，结果保留两位小数

示例

输入：

1 1 6.5 1 6.5 2.5

输出：

15.26

90.00

74.74

import math

def calculate_triangle_angles(x1, y1, x2, y2, x3, y3):
    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)
    A = math.acos((b ** 2 + c ** 2 - a ** 2) / (2 * b * c))
    B = math.acos((a ** 2 + c ** 2 - b ** 2) / (2 * a * c))
    C = math.acos((a ** 2 + b ** 2 - c ** 2) / (2 * a * b))
    A_degrees = math.degrees(A)
    B_degrees = math.degrees(B)
    C_degrees = math.degrees(C)
    return A_degrees, B_degrees, C_degrees


x1, y1, x2, y2, x3, y3 = map(float, input("请输入三角形的三个顶点坐标：").split())
A, B, C = calculate_triangle_angles(x1, y1, x2, y2, x3, y3)
print("A角度数：{:.2f}".format(A))
print("B角度数：{:.2f}".format(B))
print("C角度数：{:.2f}".format(C))

Demo12 最小数量的硬币

题目描述

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

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

输入输出描述

输入总金额

输出每种硬币的个数

示例

输入：

11.56

输出：

11个一元硬币

2个两角五分硬币

0个一角硬币

1个五分硬币

1个一分硬币

def exchange_coins(total_amount):
    coin_values = [100, 25, 10, 5, 1]
    coin_counts = [0] * len(coin_values)
    total_amount = int(total_amount * 100)
    for i in range(len(coin_values)):
        coin_count = total_amount // coin_values[i]
        total_amount -= coin_count * coin_values[i]
        coin_counts[i] = coin_count
    return coin_counts


total_amount = float(input("请输入总金额："))
coin_counts = exchange_coins(total_amount)
coin_names = ["一元硬币", "两角五分硬币", "一角硬币", "五分硬币", "一分硬币"]
for i in range(len(coin_names)):
    print("{}个{}".format(coin_counts[i], coin_names[i]))

Demo13 正多边形的面积

题目描述

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

area=\frac{n*s^2}{4*tan(\frac{Pi}{n})}

输入输出描述

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

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

示例

输入：

5 6.5

输出：

72.69

import math

def calculate_polygon_area(n, s):
    area = (n * s ** 2) / (4 * math.tan(math.pi / n))
    return area


n, s = map(float, input("请输入正多边形的边数和边长：").split())
area = calculate_polygon_area(n, s)
print("正{}边形的面积为：{:.2f}".format(int(n), 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

输出：

标准

def calculate_bmi(weight, height):
    bmi = weight / (height ** 2)
    if bmi < 18.5:
        result = "超轻"
    elif 18.5 <= bmi < 25.0:
        result = "标准"
    elif 25.0 <= bmi < 30.0:
        result = "超重"
    else:
        result = "肥胖"
    return result


weight, height = input().split()
weight = float(weight)
height = float(height)

bmi_result = calculate_bmi(weight, height)
print(bmi_result)

Demo15 判定闰年

题目描述

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

输入输出描述

输入一个年份

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

示例1

输入：

2008

输出：

Yes

示例2

输入：

2002

输出：

No

def is_leap_year(year):
    if (year % 4 == 0 and year % 100 != 0) or year % 400 == 0:
        return "Yes"
    else:
        return "No"


year = int(input())
leap_year_result = is_leap_year(year)
print(leap_year_result)

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


def calculate_prize(user_input, random_num):
    if user_input == random_num:
        return random_num, 10000
    elif set(str(user_input)) == set(str(random_num)):
        return random_num, 3000
    elif any(i in str(random_num) for i in str(user_input)):
        return random_num, 1000
    else:
        return random_num, 0


user_input = int(input())
random_num = random.randint(10, 99)
prize_num, prize_amount = calculate_prize(user_input, random_num)
print(prize_num)
print(prize_amount)

Demo17 解一元二次方程

题目描述

一元二次方程$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三个数据，数据之间用空格分隔

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

示例1

输入：

1.0 3 1

输出：

-0.38

-2.62

示例2

输入：

1 2.0 1

输出：

-1.00

-2.62

示例3

输入：

1 2 3

输出：

无实数解

import math


def solve_quadratic_equation(a, b, c):
    delta = b ** 2 - 4 * a * c
    if delta > 0:
        r1 = (-b + math.sqrt(delta)) / (2 * a)
        r2 = (-b - math.sqrt(delta)) / (2 * a)
        return r1, r2
    elif delta == 0:
        r = -b / (2 * a)
        return r,
    else:
        return None


a, b, c = map(float, input().split())
result = solve_quadratic_equation(a, b, c)
if result is None:
    print("无实数解")
else:
    for r in result:
        print("{:.2f}".format(r))

Demo18 解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的解，保留一位小数

示例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

输出：

无解

def solve_linear_equations(a, b, c, d, e, f):
    determinant = a * d - b * c
 
    if determinant != 0:
        x = (e * d - b * f) / determinant
        y = (a * f - e * c) / determinant
        return x, y
    else:
        return "无解"
 
a, b, c, d, e, f = map(float, input("请输入a、b、c、d、e、f的值（以空格分隔）：").split())
 
result = solve_linear_equations(a, b, c, d, e, f)
 
if isinstance(result, tuple):
    print("{:.1f}".format(result[0]))
    print("{:.1f}".format(result[1]))
else:
    print(result)

Demo19 未来是周几

题目描述

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

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

输入输出描述

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

输出未来某天是星期几

示例1

输入：

1 3

输出：

星期四

示例2

输入：

0 31

输出：

星期三

def calculate_future_day(today, future_days):
    days_of_week = ["星期天", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"]
    
    future_day = (today + future_days) % 7
    
    return days_of_week[future_day]


today, future_days = map(int, input("输入：").split())
future_day_of_week = calculate_future_day(today, future_days)
print("输出：",future_day_of_week)

Demo20 本年中的第几天

题目描述

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

输入输出描述

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

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

示例1

输入：

2023 1 28

输出：

28

示例2

输入：

2023 3 2

输出：

61

def calculate_day_of_year(year, month, day):
    days_in_month = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
    if year % 4 == 0 and (year % 100 != 0 or year % 400 == 0):
        days_in_month[1] = 29
    day_of_year = sum(days_in_month[:month-1]) + day 
    return day_of_year


year, month, day = map(int, input("输入：").split())
day_of_year = calculate_day_of_year(year, month, day)
print("输出：",day_of_year)

Demo21 剪刀石头布I

题目描述

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

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

输入输出描述

输入数字0、1或2

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

示例1

输入：

0

输出：

计算机出的 石头

用户出的 剪刀

计算机赢

示例2

输入：

1

输出：

计算机出的 剪刀

用户出的 石头

用户赢

示例3

输入：

2

输出：

计算机出的 布

用户出的 布

平局

import random

def rock_paper_scissors(user_choice):
    choices = ["剪刀", "石头", "布"]
    computer_choice = random.randint(0, 2)
    result = ""
    if user_choice == computer_choice:
        result = "平局"
    elif (user_choice == 0 and computer_choice == 2) or (user_choice == 1 and computer_choice == 0) or (user_choice == 2 and computer_choice == 1):
        result = "用户赢"
    else:
        result = "计算机赢"
    return choices[computer_choice], choices[user_choice], result


user_choice = int(input("输入："))
computer_choice, user_choice, result = rock_paper_scissors(user_choice)
print("计算机出的",computer_choice)
print("用户出的",user_choice)
print(result)

Demo22 三角形的周长

题目描述

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

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

输入输出描述

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

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

示例1

输入：

1 1 1

输出：

3

示例2

输入：

1 3 1

输出：

非法

def calculate_triangle_perimeter(a, b, c):
    if a + b > c and a + c > b and b + c > a:
        perimeter = a + b + c
        return perimeter
    else:
        return "非法"
    

print("输入")
a, b, c = map(float, input().split())
perimeter = calculate_triangle_perimeter(a, b, c)
print("输出")
print(perimeter)

Demo23 一周的星期几

题目描述

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

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

def calculate_day_of_week(year, month, day):
    if month == 1 or month == 2:
        month += 12
        year -= 1
    j = year // 100
    k = year % 100
    h = (day + (26 * (month + 1)) // 10 + k + k // 4 + j // 4 + 5 * j) % 7
    days = [0, 1, 2, 3, 4, 5, 6]
    days1 = ["星期六", "星期天", "星期一", "星期二", "星期三", "星期四", "星期五"]
    for i in days:
        if h == days[i]:
            return days1[i]


print("输入")
year, month, day = map(int, input().split())
day_of_week = calculate_day_of_week(year, month, day)
print("输出")
print(day_of_week)

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，否则输出两条直线平行

示例1

输入：

2 2 5 -1 4 2 -1 -2

输出：

2.89 1.11

示例2

输入：

2 2 7 6 4 2 -1 -2

输出：

两条直线平行

def calculate_intersection(x1, y1, x2, y2, x3, y3, x4, y4):
    denominator = (y1 - y2) * (x3 - x4) - (x1 - x2) * (y3 - y4)
    if denominator == 0:
        return "两条直线平行"
    x = ((y1 - y2) * (x1 - x3) * (x4 - x3) + (y3 - y4) * (x1 - x2) * (x3 - x1)) / denominator
    y = ((y1 - y2) * (y3 - y1) * (x4 - x3) + (y3 - y4) * (x1 - x2) * (y1 - y3)) / denominator
    return x, y


print("输入：")
x1, y1, x2, y2, x3, y3, x4, y4 = map(float, input().split())
result = calculate_intersection(x1, y1, x2, y2, x3, y3, x4, y4)
print("输出：")
print(result)

Demo25 回文数

题目描述

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

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

输入输出描述

输入一个数字

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

示例1

输入：

121

输出：

Yes

示例2

输入：

123

输出：

No

def is_palindrome_number(num):
    num_str = str(num)
    if num_str == num_str[::-1]:
        return "Yes"
    else:
        return "No"
    

print("输入：")
num = int(input())
result = is_palindrome_number(num)
print("输出：")
print(result)

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 calculate_rectangle_relation(x1, y1, width1, height1, x2, y2, width2, height2):
    left1 = x1 - width1 / 2
    right1 = x1 + width1 / 2
    top1 = y1 + height1 / 2
    bottom1 = y1 - height1 / 2
    
    left2 = x2 - width2 / 2
    right2 = x2 + width2 / 2
    top2 = y2 + height2 / 2
    bottom2 = y2 - height2 / 2
    
    if left1 > right2 or left2 > right1 or top1 < bottom2 or top2 < bottom1:
        return "相离"
    elif left1 >= left2 and right1 <= right2 and top1 <= top2 and bottom1 >= bottom2:
        return "包含"
    elif left2 >= left1 and right2 <= right1 and top2 <= top1 and bottom2 >= bottom1:
        return "包含"
    else:
        return "重叠"
    

print("输入：")
x1, y1, width1, height1 = map(float, input().split())
x2, y2, width2, height2 = map(float, input().split())
relation = calculate_rectangle_relation(x1, y1, width1, height1, x2, y2, width2, height2)
print("输出：")
print(relation)

第二部分 循环语句

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

def modeA():
    print("模式A:")
    for i in range(1, 7):
        for j in range(1, i+1):
            print(j, end=' ')
        print()


def modeB():
    print("模式B:")
    for i in range(6, 0, -1):
        for j in range(1, i+1):
            print(j, end=' ')
        print()


def modeC():
    print("模式C:")
    for i in range(1, 7):
        for j in range(i, 0, -1):
            print(j, end=' ')
        print()


def modeD():
    print("模式D:")
    for i in range(6, 0, -1):
        for k in range(6-i):
            print(' ', end=' ')
        for j in range(1, i+1):
            print(j, end=' ')
        print()


modeA()
modeB()
modeC()
modeD()

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):
        print(" " * (2*(n - i)), end="")
        for j in range(i, 1, -1):
            print(j, end=" ")
        for j in range(1, 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(n):
    for i in range(0, n):
        for j in range(0, n-i-1):
            print(" ", end=" ")
        num = 1
        for j in range(0, i+1):
            print(num, end=" ")
            num *= 2
        num //= 2
        for j in range(0, i):
            num //= 2
            print(num, end=" ")
        print()
 

n = int(input("请输入一个整数："))
print_pattern(n)

Demo30 打印菱形I

题目描述

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

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

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

输入输出描述

输入高度n，n为奇数

输出该高度的菱形

示例

输入：

5

输出：

  *
 * *
* * *
 * *
  *

def print_diamond(n):
    for i in range(n):
        for j in range(n-i-1):
            print(" ", end="")
        for j in range(i+1):
            print("* ", end="")
        print()
    for i in range(n-1, 0, -1):
        for j in range(n-i):
            print(" ", end="")
        for j in range(i):
            print("* ", end="")
        print()
 

print("输入：")
n = int(input())
print("输出：")
print_diamond(n)

Demo31 打印菱形II

题目描述

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

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

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

输入输出描述

输入高度n，n为奇数

输出该高度的菱形

示例

输入：

5

输出：

  *
 * *
*   *
 * *
  *

def print_hollow_diamond(n):
    for i in range(n):
        for j in range(n-i-1):
            print(" ", end="")
        for j in range(i*2+1):
            if j == 0 or j == i*2:
                print("*", end="")
            else:
                print(" ", end="")
        print()
    
    for i in range(n-2, -1, -1):
        for j in range(n-i-1):
            print(" ", end="")
        for j in range(i*2+1):
            if j == 0 or j == i*2:
                print("*", end="")
            else:
                print(" ", end="")
        print()
 

print("输入：")
n = int(input())
print("输出：")
print_hollow_diamond(n)

Demo32 打印菱形III

题目描述

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

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

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

输入输出描述

输入高度n，n为奇数

输出该高度的菱形

示例

输入：

5

输出：

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

def print_diamond(n):
    for i in range(n):
        for j in range(n-i-1):
            print(" ", end="")
        for j in range(i*2+1):
            print("*", end="")
        print()
 
    for i in range(n-2, -1, -1):
        for j in range(n-i-1):
            print(" ", end="")
        for j in range(i*2+1):
            print("*", end="")
        print()
 

print("输入：")
n = int(input())
print("输出：")
print_diamond(n)

Demo33 猜数字

题目描述

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

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

输入输出描述

每次输入一个整数

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

示例

输入：50

输出：高了

输入：25

输出：低了

输入：42

输出：高了

输入：39

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

import random


def guess_number():
    target = random.randint(0, 100)
    
    while True:
        guess = int(input("请输入一个整数："))
        
        if guess < target:
            print("过低")
        elif guess > target:
            print("过高")
        else:
            print("猜中！答案是", target)
            break


guess_number()

Demo34 最大公约数I

题目描述

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

输入输出描述

输入两个数字

输出最大公约数

示例1

输入：

16 24

输出：

8

示例2

输入：

7 3

输出：

1

def gcd(a, b):
    if b == 0:
        return a
    else:
        return gcd(b, a % b)


print("输入：")
a, b=map (int, input().split())
print("最大公约数是：", gcd(a, b))

Demo35 判断素数

题目描述

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

输入输出描述

输入一个大于1的正整数

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

示例1

输入：

9

输出：

No

示例2

输入：

11

输出：

Yes

def is_prime(n):
    if n <= 1:
        return False
    
    for i in range(2, int(n**0.5)+1):
        if n % i == 0:
            return False
    
    return True


num = int(input("请输入一个大于1的正整数："))
if is_prime(num):
    print("Yes")
else:
    print("No")

Demo36 最小公倍数

题目描述

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

输入输出描述

输入两个正整数

输出最小公倍数

示例1

输入：

3 9

输出：

9

示例2

输入：

4 6

输出：

12

def lcm(a, b):
    if a == 0 or b == 0:
        return 0
    else:
        gcd = 1
        for i in range(1, min(a, b) + 1):
            if a % i == 0 and b % i == 0:
                gcd = i
        lcm = a * b // gcd
        return lcm

# 测试
a, b = map (int, input("请输入两个正整数：").split())
print("最小公倍数是：", lcm(a, b))

Demo37 整数的素因子

题目描述

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

输入输出描述

输入一个正整数

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

示例1

输入：

120

输出：

2 2 2 3 5

解释：

2 * 2 * 2 *3 * 5 = 120

示例2

输入：

100

输出：

2 2 5 5

def find_prime_factors(n):
    factors = []
    i = 2
    while i <= n:
        if n % i == 0:
            factors.append(i)
            n = n // i
        else:
            i += 1
    return factors


num = int(input("请输入一个正整数："))
prime_factors = find_prime_factors(num)
print("素因子为：")
for factor in prime_factors:
    print(factor, end=" ")

Demo38 完全数

题目描述

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

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

输入输出描述

输入一个正整数

输出该数是否为完全数

示例1

输入：

6

输出：

Yes

示例2

输入：

9

输出：

No

def is_perfect_number(n):
    factors_sum = 0
    for i in range(1, n):
        if n % i == 0:
            factors_sum += i
    if factors_sum == n:
        return True
    else:
        return False


num = int(input("请输入一个正整数："))
if is_perfect_number(num):
    print("Yes")
else:
    print("No")

Demo39 前50个素数

题目描述

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

def is_prime(n):
    if n < 2:
        return False
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            return False
    return True
 
count = 0
num = 2
 
while count < 50:
    if is_prime(num):
        print("%-4d"%num, end=' ')
        count += 1
        if count % 10 == 0:
            print()
    num += 1

Demo40 计算π

题目描述

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

π=4(1-\frac{1}{3}+\frac{1}{5}-\frac{1}{7}+\frac{1}{9}-\frac{1}{11}+...+\frac{(-1)^{i+1}}{2i-1})

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

def calculate_pi(n):
    pi = 0
    sign = 1
 
    for i in range(1, n+1):
        term = 1 / (2*i - 1)
        pi += sign * term
        sign *= -1
 
    pi *= 4
    return pi
 

n = int(input("i = "))
result = calculate_pi(n)
print(result)

Demo41 计算e

题目描述

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

e=1+\frac{1}{1!}+\frac{1}{2!}+\frac{1}{3!}+\frac{1}{4!}+...+\frac{1}{i!}

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

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

Demo42 剪刀石头布II

题目描述

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

import random
 
def rock_paper_scissors():
    choices = ["剪刀", "石头", "布"]
    computer_score = 0
    player_score = 0
    
    while computer_score < 3 and player_score < 3:
        computer_choice = random.choice(choices)
        player_choice = input("输入：")
        
        print("计算机出的：", computer_choice)
        print("用户出的：", choices[int(player_choice)])
        
        if player_choice == "0" and computer_choice == "石头":
            computer_score += 1
        elif player_choice == "1" and computer_choice == "布":
            computer_score += 1
        elif player_choice == "2" and computer_choice == "剪刀":
            computer_score += 1
        elif computer_choice == "0" and player_choice == "石头":
            player_score += 1
        elif computer_choice == "1" and player_choice == "布":
            player_score += 1
        elif computer_choice == "2" and player_choice == "剪刀":
            player_score += 1
 
    if computer_score == 3:
        return "计算机是终极胜利者"
    else:
        return "用户是终极胜利者"
 
result = rock_paper_scissors()
print(result)

Demo43 组合问题I

题目描述

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

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

def combination():
    count = 0
    for i in range(1, 7):
        for j in range(i+1, 8):
            print(f"组合({i},{j})")
            count += 1
    return count
 
total_count = combination()
print("所有组合的个数：", total_count)

Demo44 组合问题II

题目描述

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

def combination():
    count = 0
    combinations = []
    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
                    combinations.append(i * 100 + j * 10 + k)
    return count, combinations
 
total_count, combinations = combination()
print("能组成的互不相同且无重复数字的三位数的个数：", total_count)
print("具体的数字组合：", combinations)

Demo45 水仙花数

题目描述

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

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

def find_armstrong_numbers():
    armstrong_numbers = []
    for number in range(100, 1000):
        digit1 = number // 100
        digit2 = (number % 100) // 10
        digit3 = number % 10
        if number == (digit1 ** 3 + digit2 ** 3 + digit3 ** 3):
            armstrong_numbers.append(number)
    return armstrong_numbers
 

numbers = find_armstrong_numbers()
print("所有的水仙花数：", end="")
for i in numbers:
    print(i, end=" ")

Demo46 青蛙跳台阶

题目描述

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

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

def frog_jump(n):
    if n == 1:
        return 1
    elif n == 2:
        return 2
    else:
        return frog_jump(n-1) + frog_jump(n-2)


n = int(input("请输入台阶的数量："))
result = frog_jump(n)
print("青蛙跳台阶的方法数为：", 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

def calculate_stacked_sum(a, n):
    sum = 0
    curr = a
    for i in range(n):
        sum += curr
        curr = curr * 10 + a
    return sum
 

a, n = map(int, input("请输入数字a和组数n：").split())
result = calculate_stacked_sum(a, n)
print(result)

Demo48 十进制转二进制

题目描述

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

输入输出描述

输入一个十进制正整数

输出二进制字符串

示例

输入：

9

输出：

1001

def decimal_to_binary(n):
    binary = ""
    while n > 0:
        binary = str(n%2) + binary
        n = n // 2
    return binary


n = int(input("请输入一个十进制正整数：")) 
binary = decimal_to_binary(n)
print(binary)

Demo49 二进制转十进制

题目描述

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

输入输出描述

输入一个二进制字符串

输出十进制数字

示例

输入：

1001

输出：

9

def binary_to_decimal(binary):
    decimal = 0
    power = len(binary) - 1
    for digit in binary:
        decimal += int(digit) * (2 ** power)
        power -= 1
    return decimal


binary = input("请输入一个二进制字符串：") 
decimal = binary_to_decimal(binary)
print(decimal)

Demo50 十进制转十六进制

题目描述

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

输入输出描述

输入一个十进制正整数

输出十六进制字符串

示例

输入：

123321

输出：

1e1b9

def decimal_to_hexadecimal(decimal):
    hexadecimal = hex(decimal)[2:]
    return hexadecimal


decimal = int(input("请输入一个十进制正整数：")) 
hexadecimal = decimal_to_hexadecimal(decimal)
print(hexadecimal)

Demo51 十六进制转十进制

题目描述

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

输入输出描述

输入一个十六进制字符串

输出十进制数字

示例

输入：

1e1b9

输出：

123321

def hexadecimal_to_decimal(hexadecimal):
    decimal = int(hexadecimal, 16)
    return decimal


hexadecimal = input("请输入一个十六进制字符串：") 
decimal = hexadecimal_to_decimal(hexadecimal)
print(decimal)

Demo52 最长公共前缀

题目描述

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

输入输出描述

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

输出前缀串

示例

输入：

abcdefg

abcdhko

输出：

abcd

def longest_common_prefix(s1, s2):
    i = 0
    while i < len(s1) and i < len(s2):
        if s1[i] != s2[i]:
            break
        i += 1
    return s1[:i]


s1 = input("请输入字符串s1：")
s2 = input("请输入字符串s2：")
result = longest_common_prefix(s1, s2)
print("最长公共前缀串为：", result)

Demo53 子串出现的次数

题目描述

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

输入输出描述

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

输出s2在s1中出现的次数

示例1

输入：

ABCsdABsadABCasdhjabcsaABCasd

ABC

输出：

3

示例2

输入：

AAAAAAAA

AAA

输出：

2

def count_substring(s1, s2):
    count = 0
    start = 0     
    while True:
        index = s1.find(s2, start)
        if index == -1:
            break
        count += 1
        start = index + len(s2)   
    return count
 

s1 = input("请输入字符串s1：")
s2 = input("请输入字符串s2：")
result = count_substring(s1, s2)
print(result)

Demo54 最长公共子串

题目描述

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

输入输出描述

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

输出最长公共子串

示例

输入：

123ABCDEFG83hsad

iughABCDEFG23uy

输出：

ABCDEFG

def longest_common_substring(s1, s2):
    m = len(s1)
    n = len(s2)
    dp = [[0] * (n+1) for _ in range(m+1)]
    max_length = 0
    end_index = 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
                if dp[i][j] > max_length:
                    max_length = dp[i][j]
                    end_index = i
    
    return s1[end_index-max_length:end_index]


s1 = input("请输入字符串s1：")
s2 = input("请输入字符串s2：") 
result = longest_common_substring(s1, s2)
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 False
    
    count_digit = 0
    count_upper = 0
    
    for char in password:
        if char.isdigit():
            count_digit += 1
        elif char.isupper():
            count_upper += 1
    
    if count_digit >= 2 and count_upper >= 2:
        return True
    else:
        return False


password = input("请输入密码：")
if check_password(password):
    print("Yes")
else:
    print("No")

Demo56 回文素数

题目描述

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

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

def is_prime(n):
    if n <= 1:
        return False
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            return False
    return True
 

def is_palindrome(n):
    return str(n) == str(n)[::-1]
 
 
count = 0
num = 2
 
print("前100个回文素数：")
while count < 100:
    if is_prime(num) and is_palindrome(num):
        print("%-4d"%num, end=' ')
        count += 1
        if count % 10 == 0:
            print()
    num += 1

Demo57 反素数

题目描述

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

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

def is_prime(n):
    if n <= 1:
        return False
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            return False
    return True
 
def is_reverse_prime(n):
    reverse_n = int(str(n)[::-1])
    return is_prime(n) and is_prime(reverse_n)
 
count = 0
num = 2
 
print("前100个反素数：")
while count < 100:
    if is_reverse_prime(num):
        print("%-4d"%num, end=' ')
        count += 1
        if count % 10 == 0:
            print()
    num += 1

Demo58 双素数

题目描述

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

输出显示小于1000的双素数

def is_prime(n):
    if n <= 1:
        return False
    for i in range(2, int(n**0.5)+1):
        if n % i == 0:
            return False
    return True


def twin_primes():
    twin_primes_list = []
    for num in range(3, 1000):
        if is_prime(num) and is_prime(num + 2):
            twin_primes_list.append((num, num + 2))
    return twin_primes_list


result = twin_primes()
print("小于1000的双素数为：")
i = 1
for twin_prime in result:
    print("%d"%twin_prime[0], "%-4d"%twin_prime[1], end=" ")
    i += 1
    if i == 5:
        print()
        i = 1

Demo59 梅森素数

题目描述

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

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

def is_prime(n):
    if n <= 1:
        return False
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            return False
    return True
 
def find_mersenne_primes():
    mersenne_primes = []
    for p in range(2, 32):
        num = 2**p - 1
        if is_prime(num):
            mersenne_primes.append((p, num))
    return mersenne_primes
 
print("p ≤ 31的所有梅森素数：")
mersenne_primes = find_mersenne_primes()
for mersenne_prime in mersenne_primes:
    print("p =", mersenne_prime[0], ", 梅森素数 =", mersenne_prime[1])

Demo60 平方根的近似求法

题目描述

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

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

nextGuess=(lastGuess+n/lasetGuess)/2

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

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

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

def sqrt_approximation(n):
    last_guess = 1
    next_guess = (last_guess + n / last_guess) / 2
 
    while abs(next_guess - last_guess) > 0.0001:
        last_guess = next_guess
        next_guess = (last_guess + n / last_guess) / 2
 
    return next_guess
 

n = float(input("请输入一个数：")) 
approximation = sqrt_approximation(n)
print("平方根的近似值：", approximation)

第三部分 容器操作

Demo61 指定等级

题目描述

读入学生成绩，获取最高分best，然后根据下面的规则赋等级值：

（1）如果分数≥best-10，等级为A

（1）如果分数≥best-20，等级为B

（1）如果分数≥best-30，等级为C

（1）如果分数≥best-40，等级为D

（1）其他情况，等级为F

输入输出描述

输入两行，第一行输入学生人数n，第二行输入n个学生的成绩

输入n行，表示每个学生的成绩等级

示例

输入：

4

40 55 70 58

输出：

学生0分数为40，等级为C

学生1分数为55，等级为B

学生2分数为70，等级为A

学生3分数为58，等级为B

def get_grade(scores):
    best = max(scores)
    grades = []
    for i, score in enumerate(scores):
        if score >= best - 10:
            grade = "A"
        elif score >= best - 20:
            grade = "B"
        elif score >= best - 30:
            grade = "C"
        elif score >= best - 40:
            grade = "D"
        else:
            grade = "F"
        grades.append(grade)
        print(f"学生{i}分数为{score}，等级为{grade}")
 
if __name__ == "__main__":
    print("输入")
    n = int(input())
    scores = list(map(int, input().split()))
    print("输出")
    get_grade(scores)

Demo62 计算数字的出现次数

题目描述

读取1到100之间的整数，然后计算每个数出现的次数

输入输出描述

输入两行，第一行为整数的个数n，第二行为n个整数

输出多行，每行表示某数及其出现的次数，顺序按照数字从小到大

示例

输入：

9

2 5 6 5 4 3 23 43 2

输出：

2出现2次

3出现1次

4出现1次

5出现2次

6出现1次

23出现1次

43出现1次

def count_occurrences(nums):
    occurrence = {}
    for num in nums:
        if num in occurrence:
            occurrence[num] += 1
        else:
            occurrence[num] = 1
    return occurrence
 
if __name__ == "__main__":
    print("输入")
    n = int(input())
    nums = list(map(int, input().split()))
    print("输出")
    occurrences = count_occurrences(nums)
    for num, count in sorted(occurrences.items()):
        print(f"{num}出现{count}次")

Demo63 打印不同的数

题目描述

读入n个数字，并显示互不相同的数（即一个数出现多次，但仅显示一次），数组包含的都是不同的数

输入输出描述

输入两行，第一行为数字的个数n，第二行为n个数字

输出数组，包含的都是不同的数

示例

输入：

10

1 2 3 2 1 6 3 4 5 2

输出：

1 2 3 6 4 5

def get_unique_numbers(nums):
    unique_nums = list(set(nums))
    return unique_nums
 
if __name__ == "__main__":
    print("输入")
    n = int(input())
    nums = list(map(int, input().split()))
    print("输出")
    unique_nums = get_unique_numbers(nums)
    for num in unique_nums:
        print(num, end=" ")

Demo64 最大公约数II

题目描述

输入n个数字，求该n个数字的最大公约数

输入输出描述

输入两行，第一行为数字个数n，第二行为n个整数

输出最大公约数

示例

输入：

9 12 18 21 15

输出：

3

def gcd(a, b):
    while b != 0:
        a, b = b, a % b
    return a
 

def get_gcd(nums):
    result = nums[0]
    for i in range(1, len(nums)):
        result = gcd(result, nums[i])
    return result
 

if __name__ == "__main__":
    print("输入")
    n = int(input())
    nums = list(map(int, input().split()))
    print("输出")
    gcd = get_gcd(nums)
    print(gcd)

Demo65 打乱数组

题目描述

编程程序，对给定的数组进行随机打乱，并输出打乱后的结果

import random
 
def shuffle_array(nums):
    random.shuffle(nums)
    return nums
 
 
if __name__ == "__main__":
    nums = [1, 2, 3, 4, 5, 6, 7]
    print("输出")
    shuffled_nums = shuffle_array(nums)
    print(shuffled_nums)

Demo66 是否有序

题目描述

编写程序，对给定的数组进行判断，判断其数组元素是否非单调递减

输入输出描述

第一行输入测试数据组数T，接下来有2T行，每第一行表示数组长度n，每第二行有n个元素

输出T行，表示该数组是否有序

示例

输入：

3

5

1 2 3 4 5

4

3 1 2 4

5

1 2 2 3 4

输出：

YES

NO

YES

def is_array_sorted(nums):
    for i in range(1, len(nums)):
        if nums[i] < nums[i-1]:
            return "NO"
    return "YES"
 

if __name__ == "__main__":
    print("输入")
    t = int(input())
    results = []
    for _ in range(t):
        n = int(input())
        nums = list(map(int, input().split()))
        result = is_array_sorted(nums)
        results.append(result)
    print("输出")
    for result in results:
        print(result)

Demo67 相似词

题目描述

输入两个英文单词，判断其是否为相似词，所谓相似词是指两个单词包含相同的字母

输入输出描述

输入两行，分别表示两个单词

输出结果，为相似词输出YES，否则输出NO

示例

输入：

listen

silent

输出：

YES

def is_similar_word(word1, word2):
    set1 = set(word1)
    set2 = set(word2)
    if set1 == set2:
        return "YES"
    else:
        return "NO"
 

if __name__ == "__main__":
    print("输入")
    word1 = input()
    word2 = input()
    result = is_similar_word(word1, word2)
    print("输出")
    print(result)

Demo68 豆机器

题目描述

豆机器，也称为梅花或高尔顿盒子，它是一个统计实验的设备，它是由一个三角形直立板和均匀分布的钉子构成，如下图所示：

小球从板子的开口处落下，每次小球碰到钉子，它就是50%的可能掉到左边或者右边，最终小球就堆积在板子底部的槽内

编程程序模拟豆机器，提示用户输入小球的个数以及机器的槽数，打印每个球的路径模拟它的下落，然后打印每个槽子中小球的个数

输入输出描述

输入两个数据，分别表示小球个数和槽子的个数

输出每个小球经过的路径，和最终每个槽子里小球的个数（因为牵扯随机数，程序结果不唯一，示例仅用于表明题意）

示例

输入：

5 8

输出：

LRLRLRR

RRLLLRR

LLRLLRR

RRLLLLL

LRLRRLR

0 0 1 1 3 0 0 0

Demo69 更衣室难题

题目描述

一个学校有100个更衣室和100个学生。所有的更衣室在开学第一天都是锁着的。随着学生进入，第一个学生表示为S1，打开每个更衣室；然后第二个学生S2，从第二个更衣室开始，用L2表示，关闭所有其他更衣室；学生S3从第三个更衣室L3开始，改变每三个更衣室（如果打开则关闭，如果关闭则打开）；学生S4从更衣室L4开始，改变每四个更衣室；学生S5开始从更衣室L5开始，改变每五个更衣室。依次类推，直到学生S100改变L100。

在所有学生都经过了操作后，哪些更衣室是打开的？编程找出答案。

def find_open_lockers():
    lockers = [False] * 100  
    for student in range(1, 101):
        for locker in range(student - 1, 100, student):
            lockers[locker] = not lockers[locker]  
    open_lockers = [i + 1 for i, status in enumerate(lockers) if status]  
    return open_lockers
 

if __name__ == "__main__":
    open_lockers = find_open_lockers()
    print("打开的更衣室编号：")
    print(open_lockers)

Demo70 合并两个有序数组

题目描述

给定两个有序递增的数组A和数组B，将其进行合并成一个新的数组C，且保持有序递增，并输出数组C

输入输出描述

第一行输入数组A的长度n，第二行输入n个元素，第三行输入数组B的长度m，第四行输入m个元素

输出数组C的n+m个元素

示例

输入：

5

1 5 16 61 111

4

2 4 5 6

输出：

1 2 4 5 5 6 16 61 111

def merge_arrays(a, b):
    merged = []
    i, j = 0, 0
    while i < len(a) and j < len(b):
        if a[i] <= b[j]:
            merged.append(a[i])
            i += 1
        else:
            merged.append(b[j])
            j += 1
    while i < len(a):
        merged.append(a[i])
        i += 1
    while j < len(b):
        merged.append(b[j])
        j += 1
    return merged


if __name__ == "__main__":
    print("输入")
    n = int(input())
    a = list(map(int, input().split()))
    m = int(input())
    b = list(map(int, input().split()))
    merged_array = merge_arrays(a, b)
    print("输出")
    print(" ".join(str(num) for num in merged_array))

Demo71 数组划分

题目描述

给定一个数组A，将第一个元素$A_0$作为枢纽，并把数组划分成三个区间，第一个区间所有元素$<A_0$，第二个区间所有元素$==A_0$，第三个区间所有元素$>A_0$

例如数组[5,2,9,3,6,8]，划分后的结果为[3,2,5,9,6,8]，第一个区间[3,2]，第二个区间[5]，第三个区间[9,6,8]

结果不唯一，只要保证划分后三个区间的元素特性即可，[2,3,5,9,8,6]、[3,2,5,6,8,9]都可作为上述划分的结果

输入输出描述

第一行输入数组的长度n，第二行输入n个元素

输出划分后的结果

示例

输入：

10

5 1 9 2 5 7 4 5 3 6

输出：

1 2 4 3 5 5 5 9 7 6

def partition_array(nums):
    pivot = nums[0]
    left = []
    middle = []
    right = []
    for num in nums:
        if num < pivot:
            left.append(num)
        elif num == pivot:
            middle.append(num)
        else:
            right.append(num)
    return left + middle + right
 

if __name__ == "__main__":
    print("输入")
    n = int(input())
    nums = list(map(int, input().split()))
    result = partition_array(nums)
    print("输出")
    print(" ".join(str(num) for num in result))

m0_73832254
关注
C语言基础（一）
m0_51325590的博客
12-01 258
C语言基础之C语言数据类型 常量与变量 C语言程序处理的数据有常量和变量两种形式。 常量 顾名思义，常量就是在程序中不能改变其值的量。按照类型划分有以下几种：整型常量、实型常量、字符常量、字符串常量和枚举常量 常量的类型 实例 备注 整型常量 10，-30，0 包括正整数、负整数和零在内的所有整数 实型常量 3.14，-0.56,18.0 由于计算机中的实型数是以浮点（Floating-point）形式表示的，即小数点位置可以是浮动的，因此实型常量既可以称为实数，也可以称为浮点数。
web开发中C#题集
11-01
### Web开发中C#题集知识点解析 #### 1. 强类型系统 **定义**： 强类型系统是指在程序设计语言中，变量必须明确指定其数据类型，并且一旦定义了变量的数据类型，在运行时该变量只能存储该类型的数据。在强类型语言...
【2023最新】C语言教程 第3章 数据和C 3.11 编程练习 3.11.4 第4题
谢谢你们的关注
03-31 63
【2023最新】C语言教程 第3章 数据和C 3.11 编程练习 3.11.4 第4题
2023开发通用编程题集（Ⅰ）
lthyc1314的博客
11-16 56
（3）$m$是月份（3表示三月、4表示四月、...、12表示十二月），其中一月和二月都是按照前一年的13月和14月来计数的，所以还得把年份改为前一年。直线A上的两个点是$(x1,y1)$和$(x2,y2)$，直线B上的两个点是$(x3,y3)$和$(x4,y4)$其中$b^2-4ac$称为判别式，如果它为正，则方程有两个实数解；输入六个数据，分别表示三角形三个顶点的坐标x1、y1、x2、y2、x3和y3，数据之间用空格分隔。输入表示今天是一周内哪一天的数字（星期天是0，星期一是1，...，星期六是6）
2023年开发通用编程题集
2202_75588230的博客
11-17 107
例如客户的小计为10元，酬金率为15%，那么小费是1.5元，合计金额为11.5元。四个台阶，有五种跳法（1+1+1+1，2+1+1，1+2+1，1+1+2，2+2）直线A上的两个点是$(x1,y1)$和$(x2,y2)$，直线B上的两个点是$(x3,y3)$和$(x4,y4)$一个大于1的整数如果只能被正整数1和它本身整除，则它就是素数，例如2、3、5和7都是素数，而4、6、8、9则不是。水仙花数，是一个三位数，且这个数的个位、十位和百位的立方和等于该数字本身，例如$153=1^3+5^3+3^3$
python开发通用编程题集
qq_73831912的博客
11-21 97
输入一个摄氏温度的值，将它转变为华氏温度，并将结果输出转换的公式为如下：fahrenheit=(9/5)*celsius+32。
汽车飞机电子开发原理
hursing的博客
12-05 4109
从电子运动开始，讲解飞机和汽车的制造原理。
java基础面试题集
dan_dan的博客
01-04 185
1、面向对象的特征有哪些方面 1.抽象：抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程抽象，二是数据抽象。 2.继承：继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类可以从它的基类那里继承方法
Java程序员经典面试题集大全（十）
2401_83977626的博客
04-26 757
学习技术是一条慢长而艰苦的道路，不能靠一时激情，也不是熬几天几夜就能学好的，必须养成平时努力学习的习惯。所以：贵在坚持！最后再分享的一些BATJ等大厂20、21年的面试题，把这些技术点整理成了视频和PDF（实际上比预期多花了不少精力），包含知识脉络 + 诸多细节，由于篇幅有限，上面只是以图片的形式给大家展示一部分。Mybatis面试专题MySQL面试专题并发编程面试专题MySQL面试专题[外链图片转存中…(img-NYUI0usE-1714136053136)]并发编程面试专题本文已被。
Java错题集一
m0_45861545的博客
03-30 1102
1，如果要建立一个java.scut.computer的包，叙述正确的是？ A.只需在代码中加入“package java.scut.computer;”一个语句，并且必须放在代码的第一行 B.只需在代码中加入“package java.scut;”一个语句 C.必须在代码中加入“package java.scut;”和“package java.scut.computer;”两个语句 D.在代码中，不一定是第一句，只要是类定义前，加入package语句即可 (D )正确答案A 此题有争议,以标准答案为准
Java面试题集最全版开发入门.pdf
10-05
【Java面试题集最全版开发入门.pdf】涵盖了多个Java及相关技术领域的面试知识点，包括技巧篇、智力篇、Java篇、JSP篇、Servlet篇、应用服务器篇、J2EE和MVC篇、设计模式篇、Hibernate性能优化篇以及数据库篇。...
C#/.NET笔试题集.rar
04-08
C#和.NET是微软开发的一种面向对象的编程语言和框架，广泛应用于软件开发，尤其是在企业级应用、桌面应用以及Web应用领域。这份"C#/.NET笔试题集.rar"压缩包显然是为准备C#和.NET技术面试或笔试的人设计的，包含了...
50道Java常见编程题(有精力的同学看看).rar
09-05
Java是一种广泛使用的面向...总的来说，这份Java编程题集是一份非常实用的资料，适合有一定Java基础的学习者进行自我挑战和提升。通过系统的练习，可以逐步熟悉和精通Java语言，为将来更高级的开发工作打下坚实的基础。
严蔚敏数据结构题集C语言版答案
08-21
掌握数据结构的概念和C语言编程技能对于进行计算机算法设计和软件开发至关重要。 从乱码部分可以推测，内容可能是在提示用户如何使用或者获取这些答案。例如，“(cid:10409)(cid:2139)(cid:16932)(cid:7230)(cid:...
排序算法之归并排序
最新发布
qq_64039411的博客
10-01 495
需要注意的是，在实际应用中，归并排序的空间复杂度较高，需要额外的空间来存储临时数组。如果对空间复杂度有要求，可以考虑使用其他排序算法。归并排序是一种分治算法，它将一个数组分成两个子数组，然后递归地对子数组进行排序，最后将两个有序的子数组合并成一个有序的数组。归并排序的时间复杂度是O(nlogn)，其中n是数组的长度。它是一种稳定的排序算法，适用于各种数据类型的排序。合并排序的关键在于合并操作。
＜使用生成式AI对四种冒泡排序实现形式分析解释的探讨整理＞
m0_57859086的博客
10-01 1127
/冒泡排序实现1——不常用（这个版本两层for循环分别是i++、j++）// 声明三个整型变量i、j和temp用于循环控制和交换元素for (i = 0;i < n - 1;i++) { // 外层循环，从数组的第一个元素开始遍历到倒数第二个元素j < n;j++) { // 内层循环，从当前外层循环位置的下一个元素开始遍历到最后一个元素if (A[i] > A[j]) { // 如果当前元素大于下一个元素// 将当前元素存储到临时变量temp中// 将下一个元素赋值给当前元素。
算法：按既定顺序创建目标数组
AWSDN的博客
09-29 239
本文主要介绍按既定顺序创建目标数组问题
DAY17||654.最大二叉树 |617.合并二叉树 |700.二叉搜索树中的搜索 |
2301_79865280的博客
09-29 1306
给定一个不含重复元素的整数数组。通过给定的数组构建最大二叉树，并且输出这个树的根节点。示例 ：构造二叉树一定要，因为要先找到中，才能分割左右子树。本题图解思路：本题做过上一题构建数组确实变得容易很多。代码优化方向有，不用每次找左右子树的时候构建新的数组的话效率就会高很多。（即直接用下标索引直接在原数组上操作）关于加不加if的问题，如果允许空节点进入递归，就不加。
嵌入式系统开发技术精选题集：实战与理论结合
FPGA强调可编程性，与SoC的定义不符，D选项错误。 5. 数码相机：数码相机由前端和后端组成，B、C选项正确。高端数码相机确实可能配备RTOS和图像处理软件，D选项正确。错误选项可能是关于前端或后端的具体细节。 6....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值