python 练习7

最新推荐文章于 2024-11-05 15:32:33 发布

zyp246810

最新推荐文章于 2024-11-05 15:32:33 发布

阅读量1.6k

点赞数 46

文章标签： python 开发语言

本文链接：https://blog.csdn.net/zyp246810/article/details/134698005

版权

作业1：

某个人进入如下一个棋盘中，要求从左上角开始走，
最后从右下角出来（要求只能前进，不能后退），
问题：共有多少种走法？

0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0

代码：

def uniquePaths(m, n):
    # 创建一个二维数组dp，用于存储到达每个位置的不同走法数量
    dp = [[0] * n for _ in range(m)]
    
    # 第一行和第一列的格子上的走法数量都为1
    for i in range(m):
        dp[i][0] = 1
    for j in range(n):
        dp[0][j] = 1
    
    # 从第二行和第二列开始，计算每个位置的走法数量
    for i in range(1, m):
        for j in range(1, n):
            dp[i][j] = dp[i-1][j] + dp[i][j-1]
    
    # 返回右下角格子的走法数量
    return dp[m-1][n-1]

# 调用函数计算棋盘上的走法数量
m = 5  # 行数
n = 8  # 列数
result = uniquePaths(m, n)
print(result)

运行结果：

PS C:\Users\21223\Desktop\云计算\Python学习\作业> & D:/Python/python.exe c:/Users/21223/Desktop/云计算/Python学习/作业/2.py
330

作业2：

输入一行符号，以#结束，判断其中的对称符号是否匹配。对称符号包括：
{ } 、 [ ] 、 ( )、 < >

如果对称符号能够实现中间对称，则输出yes
否则输出no

用例一：

输入：
(<{(({<>}))}>)
输出：
yes

输入：
()()()
输出：
no

代码:

def is_symmetric(symbols):
    stack = []
    for symbol in symbols:
        if symbol in ['{', '[', '(', '<']:
            stack.append(symbol)
        elif symbol in ['}', ']', ')', '>']:
            if not stack:
                return "no"
            top = stack.pop()
            if symbol == '}' and top != '{':
                return "no"
            elif symbol == ']' and top != '[':
                return "no"
            elif symbol == ')' and top != '(':
                return "no"
            elif symbol == '>' and top != '<':
                return "no"
    return "yes" if not stack else "no"

symbols = input().strip()
print(is_symmetric(symbols))

作业3：
给定一个包含n+1个整数的数组nums，其数字在1到n之间（包含1和n），
可知至少存在一个重复的整数，假设只有一个重复的整数，
请找出这个重复的数

代码：

def find_duplicate(nums):
    slow = nums[0]
    fast = nums[0]
    while True:
        slow = nums[slow]
        fast = nums[nums[fast]]
        if slow == fast:
            break
    ptr1 = nums[0]
    ptr2 = slow
    while ptr1 != ptr2:
        ptr1 = nums[ptr1]
        ptr2 = nums[ptr2]
    return ptr1

nums = [1, 2, 3, 4, 4, 5]
print(find_duplicate(nums))

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

代码：

n = int(input())
grades = list(map(int, input().split()))
best = max(grades)

level = []
for score in grades:
    if score >= best - 10:
        level.append('A')
    elif score >= best - 20:
        level.append('B')
    elif score >= best - 30:
        level.append('C')
    elif score >= best - 40:
        level.append('D')
    else:
        level.append('F')

for l in level:
    print(l)

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次

代码：

n = int(input())
numbers = list(map(int, input().split()))

count_dict = {}
for num in numbers:
    if num in count_dict:
        count_dict[num] += 1
    else:
        count_dict[num] = 1

sorted_keys = sorted(count_dict.keys())
for key in sorted_keys:
    print(f"{key} {count_dict[key]}")

Demo63 打印不同的数

题目描述

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

输入输出描述

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

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

示例

输入：

10

1 2 3 2 1 6 3 4 5 2

输出：

1 2 3 6 4 5

Demo64 最大公约数II

题目描述

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

输入输出描述

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

输出最大公约数

示例

输入：

9 12 18 21 15

输出：

3

代码：

from math import gcd

n = int(input())
numbers = list(map(int, input().split()))

result = numbers[0]
for i in range(1, n):
    result = gcd(result, numbers[i])

print(result)

Demo65 打乱数组

题目描述

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

代码：

import random

arr = [1, 2, 3, 4, 5, 6, 7, 8, 9]  # Replace this with your array
random.shuffle(arr)
print(arr)

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

代码：

# 下面是一个Python程序，用于判断给定的数组是否为非单调递减：

def is_non_decreasing(arr):
    for i in range(len(arr) - 1):
        if arr[i] > arr[i+1]:
            return "NO"
    return "YES"

T = int(input("请输入测试数据组数T："))
results = []

for _ in range(T):
    n = int(input("请输入数组长度n："))
    elements = list(map(int, input("请输入该数组的元素，以空格分隔：").split()))
    result = is_non_decreasing(elements)
    results.append(result)

for res in results:
    print(res)

Demo67 相似词

题目描述

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

输入输出描述

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

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

示例

输入：

listen

silent

输出：

YES

代码：

word1 = input("请输入第一个单词：").lower()  # 将输入的单词转换为小写形式
word2 = input("请输入第二个单词：").lower()

# 使用集合操作检查两个单词包含的字母是否相同
if set(word1) == set(word2):
    print("YES")
else:
    print("NO")

Demo68 豆机器

题目描述

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

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

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

输入输出描述

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

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

示例

输入：

5 8

输出：

LRLRLRR

RRLLLRR

LLRLLRR

RRLLLLL

LRLRRLR

0 0 1 1 3 0 0 0

代码：

import random

def simulate_bean_machine(balls, slots):
    machine = [' '] * (slots - 1)  # 豆机器的槽数
    paths = []  # 用于存储每个小球的路径

    for _ in range(balls):
        path = ''
        position = 0  # 初始位置在最顶端
        for _ in range(slots - 1):
            if random.choice([True, False]):
                path += 'R'
                position += 1
            else:
                path += 'L'
            machine[position] += 1
        paths.append(path)

    return paths, machine

# 输入小球个数和槽子的个数
balls = int(input("请输入小球的个数："))
slots = int(input("请输入槽子的个数："))

# 模拟豆机器并打印结果
paths, final_machine = simulate_bean_machine(balls, slots)
for path in paths:
    print(path)
print(final_machine)

Demo69 更衣室难题

题目描述

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

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

代码：

def toggle_locks(num_lockers):
    lockers = [False] * num_lockers  # 初始化所有更衣室为关闭状态

    for student in range(1, num_lockers + 1):  # 从第一个学生到最后一个学生
        for locker in range(student - 1, num_lockers, student):  # 根据学生的编号改变更衣室的状态
            lockers[locker] = not lockers[locker]

    open_lockers = [i + 1 for i, locker in enumerate(lockers) if locker]  # 找出打开的更衣室编号
    return open_lockers

num_lockers = 100
open_lockers = toggle_locks(num_lockers)
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_sorted_arrays(arr1, arr2):
    merged = []
    i, j = 0, 0

    while i < len(arr1) and j < len(arr2):
        if arr1[i] < arr2[j]:
            merged.append(arr1[i])
            i += 1
        else:
            merged.append(arr2[j])
            j += 1

    merged.extend(arr1[i:])  # 将剩余的元素添加到merged中
    merged.extend(arr2[j:])

    return merged

# 输入数组A和数组B的长度及元素
n = int(input("请输入数组A的长度："))
arr1 = list(map(int, input("请输入数组A的元素，以空格分隔：").split()))
m = int(input("请输入数组B的长度："))
arr2 = list(map(int, input("请输入数组B的元素，以空格分隔：").split()))

# 合并两个有序数组并输出结果
result = merge_sorted_arrays(arr1, arr2)
print(result)

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(arr):
    pivot = arr[0]
    left, mid, right = [], [], []

    for num in arr:
        if num < pivot:
            left.append(num)
        elif num == pivot:
            mid.append(num)
        else:
            right.append(num)

    return left + mid + right

# 输入数组长度及元素
n = int(input("请输入数组的长度："))
arr = list(map(int, input("请输入数组的元素，以空格分隔：").split()))

# 对数组进行划分并输出结果
result = partition_array(arr)
print(result)