【Python0002】排列组合序列
【题目描述】
用户输入整数n（1<=n<=26）和整数m（m<=n），然后输入n个不同的字母，请编写程序输出在这n个字母中选择m个字母的所有排列序列和组合序列。
【源代码程序】
import itertools
def generate_permutations_combinations(letters, m):
# 生成排列序列
permutations = list(itertools.permutations(letters, m))
print("排列序列：")
for perm in permutations:
print(''.join(perm))
# 生成组合序列
combinations = list(itertools.combinations(letters, m))
print("\n组合序列：")
for comb in combinations:
print(''.join(comb))
def main():
n = int(input("请输入整数n（1<=n<=26）："))
m = int(input("请输入整数m（m<=n）："))
if not 1 <= n <= 26 or not 1 <= m <= n:
print("输入不符合要求！")
return
letters = []
for i in range(n):
letter = input("请输入第{}个字母：".format(i+1))
letters.append(letter)
generate_permutations_combinations(letters, m)
if __name__ == "__main__":
main()
【运行测试】
（五）、【Python0003】蒙特·卡罗法计算圆周率
【题目描述】
蒙特·卡罗方法是一种通过概率来得到问题近似解的方法，在很多领域都有重要的应用，其中就包括圆周率近似值的计问题。假设有一块边长为2的正方形木板，上面画一个单位圆，然后随意往木板上扔飞镖，落点坐标(x,y)必然在木板上（更多的时候是落在单位圆内），如果扔的次数足够多，那么落在单位圆内的次数除以总次数再乘以4，这个数字会无限逼近圆周率的值。这就是蒙特·卡罗发明的用于计算圆周率近似值的方法。编写程序，模拟蒙特·卡罗计算圆周率近似值的方法，输入掷飞镖次数，然后输出圆周率近似值。
【源代码程序】
import random
def monte_carlo_pi(num_throws):
inside_circle = 0
for _ in range(num_throws):
# 随机生成飞镖的坐标
x = random.uniform(-1, 1)
y = random.uniform(-1, 1)
# 判断飞镖是否落在单位圆内
if x**2 + y**2 <= 1:
inside_circle += 1
# 计算圆周率的近似值
pi_approx = (inside_circle / num_throws) * 4
return pi_approx
def main():
num_throws = int(input("请输入掷飞镖次数: "))
if num_throws <= 0:
print("次数必须是正整数！")
return
pi_approx = monte_carlo_pi(num_throws)
print("圆周率的近似值为:", pi_approx)
if __name__ == "__main__":
main()
【运行测试】
（六）、【Python0004】验证6174猜想
【题目描述】
1955年，卡普耶卡(D.R.Kaprekar)对4位数字进行了研究，发现一个规律：对任意各位数字不相同的4位数，使用各位数字能组成的最大数减去能组成的最小数，对得到的差重复这个操作，最终会得到6174这个数字，并且这个操作最多不会超过7次。请编写程序验证这个猜想。
【源代码程序】
def kaprekar_iteration(num):
# 将数字转换为4位数的字符串
num_str = '{:04d}'.format(num)
# 转换为列表方便排序
digits = list(num_str)
# 排序得到最大数和最小数
max_num = int(''.join(sorted(digits, reverse=True)))
min_num = int(''.join(sorted(digits)))
# 计算差值
diff = max_num - min_num
return diff
def verify_kaprekar_conjecture():
# 初始化初始数字和迭代次数
num = int(input("请输入一个各位数字不相同的4位数: "))
iterations = 0
# 迭代直到得到6174或者达到最大迭代次数
while num != 6174 and iterations < 7:
num = kaprekar_iteration(num)
print(num)
iterations += 1
# 输出结果
if num == 6174:
print("经过", iterations, "次迭代，验证了6174猜想。")
else:
print("迭代次数超过7次，未能验证6174猜想。")
if __name__ == "__main__":
verify_kaprekar_conjecture()
【运行测试】
（七）、【Python0005】模拟页面调度LRU算法
【题目描述】
所谓LRU算法，是指在发生缺页并且没有空闲主存块时，把最近最少使用的页面换出主存块，腾出地方来调入新页面。
问题描述：一进程获得n个主存块的使用权，对于给定的进程访问页面次序，问当采用LRU算法时，输出发生的缺页次数。
【源代码程序】
def lru(page_sequence, num_frames):
# 使用一个列表来模拟主存块
frames = []
# 记录缺页次数
page_faults = 0
for page in page_sequence:
# 如果页面已经在主存块中，则将其移到列表末尾表示最近使用
if page in frames:
frames.remove(page)
frames.append(page)
else:
# 如果主存块未满，则直接将页面加入
if len(frames) < num_frames:
frames.append(page)
else:
# 如果主存块已满，则移除最近最少使用的页面，即列表头部的页面
frames.pop(0)
frames.append(page)
# 缺页次数加1
page_faults += 1
return page_faults
def main():
# 输入页面访问序列和主存块数量
page_sequence = list(map(int, input("请输入页面访问序列（以空格分隔）: ").split()))
num_frames = int(input("请输入主存块数量: "))
# 调用LRU算法模拟页面调度
faults = lru(page_sequence, num_frames)
# 输出缺页次数
print("缺页次数:", faults)
if __name__ == "__main__":
main()
【运行测试】
（八）、【Python0006】爬楼梯
【题目描述】
假设一段楼梯共n(n>1)个台阶，小朋友一步最多能上3个台阶，那么小朋友上这段楼梯一共有多少种方法。
【源代码程序】
def count_ways(n):
# 初始化前三个台阶的上楼梯方法数
if n == 1:
return 1
elif n == 2:
return 2
elif n == 3:
return 4
# 初始化台阶n的上楼梯方法数
ways = [0] * (n + 1)
ways[1] = 1
ways[2] = 2
ways[3] = 4
# 计算台阶i的上楼梯方法数
for i in range(4, n + 1):
ways[i] = ways[i - 1] + ways[i - 2] + ways[i - 3]
return ways[n]
def main():
n = int(input("请输入台阶数n（n>1）: "))
if n <= 1:
print("台阶数必须大于1！")
return
ways = count_ways(n)
print("小朋友上{}个台阶共有{}种方法。".format(n, ways))
if __name__ == "__main__":
main()
【运行测试】
（九）、【Python0007】杨辉三角形
【题目描述】
输出n（0<n）行杨辉三角形，n由用户输入。
【源代码程序】
def generate_pascal_triangle(n):
triangle = []
for i in range(n):
row = [1] * (i + 1)
for j in range(1, i):
row[j] = triangle[i - 1][j - 1] + triangle[i - 1][j]
triangle.append(row)
return triangle
def print_pascal_triangle(triangle):
for row in triangle:
print(" ".join(map(str, row)))
def main():
n = int(input("请输入杨辉三角形的行数n（n>0）: "))
if n <= 0:
print("请输入大于0的行数！")
return
pascal_triangle = generate_pascal_triangle(n)
print("杨辉三角形如下：")
print_pascal_triangle(pascal_triangle)
if __name__ == "__main__":
main()
【运行测试】
（十）、【Python0008】筛法求素数
【题目描述】
用户输入整数n和m（1<n<m<1000），应用筛法求[n,m]范围内的所有素数。
【源代码程序】
def sieve_of_eratosthenes(n, m):
primes = [True] * (m + 1)
primes[0] = primes[1] = False
p = 2
while p * p <= m:
if primes[p]:
for i in range(p * p, m + 1, p):
primes[i] = False
p += 1
prime_numbers = []
for i in range(n, m + 1):
if primes[i]:
prime_numbers.append(i)
return prime_numbers
def main():
n = int(input("请输入整数n（1<n）: "))
m = int(input("请输入整数m（n<m）: "))
if n >= m or n <= 1:
print("输入不符合要求！")
return
prime_numbers = sieve_of_eratosthenes(n, m)
print("在范围[{}, {}]内的素数为：".format(n, m))
print(prime_numbers)
if __name__ == "__main__":
main()
【运行测试】
（十一）、【Python0009】查找鞍点
【题目描述】
对于给定5X5的整数矩阵，设计算法查找出所有的鞍点的信息（包括鞍点的值和行、列坐标，坐标从1开始）。
提示：鞍点的特点：列上最小，行上最大。
【源代码程序】
'''求矩阵的靶点，即在矩阵行上最小而在列上最大的点'''
def get_andian(n):
#生成矩阵，将矩阵的元素存入广义表中，相当于C语言中的二维数组
i = 0
juzhen = []
while True:
if i >= n:
break
else:
hang = list(map(int,input("请按行输入矩阵的值，用空格隔开：").split(' ')))
i += 1
juzhen.append(hang)
#打印矩阵
print("矩阵：")
for i in juzhen:
for j in i:
print(j,end=' ')
print('')
#找鞍点
x = 0
for h in juzhen:
key = min(h) #找出每一行中最小值，然后再判断该最小值在矩阵这一列中是否为最大值
y = h.index(key)
if key >= max([hang[h.index(key)] for hang in juzhen]):
print("鞍点位置：(%d,%d)" %(x,y))
print(key)
x += 1
if __name__ == '__main__':
n = int(input("请输入矩阵行数n:"))
get_andian(n)
【运行测试】
（十二）、【Python0010】正整数的因子展开式
【题目描述】
编写程序，输出一个给定正整数x（x>1）的质因子展开式。
【源代码程序】
def prime_factors(n):
factors = []
divisor = 2
while n > 1:
if n % divisor == 0:
factors.append(divisor)
n //= divisor
else:
divisor += 1
return factors
def factor_expansion(x):
factors = prime_factors(x)
result = ''
for factor in factors:
power = 0
while x % factor == 0:
power += 1
x //= factor
if power > 1:
result += f"{factor}^{power} × "
else:
result += f"{factor} × "
return result[:-3]
def main():
x = int(input("请输入一个正整数（大于1）: "))
if x <= 1:
print("请输入大于1的正整数！")
return
expansion = factor_expansion(x)
print(f"{x}的质因子展开式为：{expansion}")
if __name__ == "__main__":
main()
【运行测试】
（十三）、【Python0011】牛顿迭代法
【题目描述】
编写程序，使用牛顿迭代法求方程在x附近的一个实根。
【源代码程序】
def newton_method(f, df, x0, tol=1e-6, max_iter=100):
"""
牛顿迭代法求解方程实根
:param f: 方程函数
:param df: 方程导函数
:param x0: 初值
:param tol: 允许误差
:param max_iter: 最大迭代次数
:return: 实根近似值
"""
x = x0
iteration = 0
while abs(f(x)) > tol and iteration < max_iter:
x = x - f(x) / df(x)
iteration += 1
if iteration == max_iter:
print("达到最大迭代次数，未能收敛到根。")
else:
print("经过", iteration, "次迭代，得到根的近似值为:", x)
def main():
# 定义方程函数及其导函数
def f(x):
return x**3 - 2*x - 5
def df(x):
return 3*x**2 - 2
# 设置初值和迭代参数
x0 = float(input("请输入初值x0: "))
tol = float(input("请输入允许误差(tol): "))
max_iter = int(input("请输入最大迭代次数(max_iter): "))
# 使用牛顿迭代法求解方程实根
newton_method(f, df, x0, tol, max_iter)
if __name__ == "__main__":
main()
【运行测试】
四 实验分析及问题思考
【Python0012】针对Python中的列表、元组、字典、集合、字符串，请以条目形式从各方面对比它们之间的异同。
【答案】
1.列表(List):
异同点：
列表是一种有序、可变的数据结构，可以存储任意类型的元素。
列表使用方括号[]来表示，元素之间用逗号,分隔。
列表中的元素可以通过索引访问和修改。
列表中可以包含重复元素。
例：
# 创建一个列表
my_list = [1, 2, 3, 4, 5]
# 访问列表中的元素
print(my_list[0]) # 输出：1
# 修改列表中的元素
my_list[0] = 10
print(my_list) # 输出：[10, 2, 3, 4, 5]
元组(Tuple):
异同点：
元组也是一种有序的数据结构，但是是不可变的，一旦创建就不能修改。
元组使用圆括号()来表示，元素之间用逗号,分隔。
元组中的元素可以通过索引访问，但不能修改。
元组中可以包含重复元素。
例：
# 创建一个元组
my_tuple = (1, 2, 3, 4, 5)
# 访问元组中的元素
print(my_tuple[0]) # 输出：1
# 尝试修改元组中的元素（会报错）
# my_tuple[0] = 10 # TypeError: 'tuple' object does not support item assignment
字典(Dictionary):
异同点：
字典是一种无序的数据结构，以键值对的形式存储数据。
字典使用花括号{}来表示，每个键值对之间用逗号,分隔，键和值之间用冒号:分隔。
字典中的键必须是唯一的，但值可以重复。
字典中的元素可以通过键来访问和修改。
例：
# 创建一个字典
my_dict = {'name': 'Alice', 'age': 30, 'city': 'New York'}
# 访问字典中的元素
print(my_dict['name']) # 输出：Alice
# 修改字典中的元素
my_dict['age'] = 31
print(my_dict) # 输出：{'name': 'Alice', 'age': 31, 'city': 'New York'}
集合(Set):
异同点：
集合是一种无序且不重复的数据结构。
集合使用花括号{}来表示，元素之间用逗号,分隔。
集合不支持索引，因此不能通过索引访问和修改元素。
集合可以执行并集、交集、差集等操作。
例：
# 创建一个集合
my_set = {1, 2, 3, 4, 5}
# 添加元素到集合中
my_set.add(6)
print(my_set) # 输出：{1, 2, 3, 4, 5, 6}
# 尝试通过索引访问集合中的元素（会报错）
# print(my_set[0]) # TypeError: 'set' object does not support indexing
字符串(String):
异同点：
字符串是由字符组成的有序序列。
字符串是不可变的，一旦创建就不能修改。
字符串可以通过索引访问其中的字符，但不能修改。
字符串可以进行拼接、切片、查找、替换等操作。
例：
# 创建一个字符串
my_string = "Hello, World!"
# 访问字符串中的字符
print(my_string[0]) # 输出：H
# 尝试修改字符串中的字符（会报错）
# my_string[0] = 'h' # TypeError: 'str' object does not support item assignment
