Python的初级题目

ohayo吧嗒吧嗒

于 2023-12-02 20:11:56 发布

阅读量138

点赞数

文章标签： python

本文链接：https://blog.csdn.net/qq_73704466/article/details/134755924

版权

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

0 0 0 0 0 0 0 0

这是一个八行五列的棋盘

n = 8
m = 5
def dfs(i, j):
    if i == n - 1 and j == m - 1:
        return 1
    if i < 0 or j < 0 or i >= n or j >= m:
        return 0
    return dfs(i + 1, j) + dfs(i, j + 1)

print(dfs(0, 0))

这里使用到了函数的递归，我们先进行俩个判断，1.不是最后一个 2.判断有没有越界

他们是一个从列走，一个从行走，其累计的值就是总的

结果是330

输入一行符号，以#结束，判断其中的对称符号是否匹配。

对称符号包括：
{ } 、 [ ] 、 ( )、 < >

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

def is_match(s):
    stack = []#定义一个空栈
    for c in s:#将输入的值一个一个拿出来
        if c == '{' or c == '[' or c == '(' or c == '<':
            stack.append(c)#插入到空栈里面
        elif c == '}' or c == ']' or c == ')' or c == '>':
            if len(stack) == 0:#判断插入的栈是不是空
                return False
            top = stack.pop()
            if (c == '}' and top == '{') or (c == ']' and top == '[') or (c == ')' and top == '(') or (c == '>' and top == '<'):
                continue
            else:
                return False
    return len(stack) == 0

if __name__ == '__main__':
    s = input()
    if is_match(s):
        print('yes')
    else:
        print('no')

这里我们运用到栈，先判断输入一个数量可以整除2的符号串，利用栈先进先出的规则和列表的字符串进行比较（弹栈的方法）

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

def find_duplicate(nums):
    n = len(nums)
    hash_map = {}
    for i in range(n):
        if nums[i] in hash_map:
            return nums[i]
        else:
            hash_map[nums[i]] = True
    return -1

if __name__ == '__main__':
    nums = [1,1, 2,2,2, 3, 4, 5, 5]
    print(find_duplicate(nums))

这里我们用字典和return -1 来帮助我们求重复值，当某个值已经重复的时候就会return 出来，但是这里，问你用到的递归的方法，只有次数重复最长的数字会被反回，如果有相同重复次数的，则反回先重复的数字，return -1 表示有重复的值，注意字典是一个key和Value是一对值，

读入学生成绩，获取最高分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

这里方法很多，可以不断用elif,

 for i in range(n):
        score = scores[i]
        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)
    return grades

## Demo62 计算数字的出现次数

题目描述

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

输入输出描述

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

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

这里和前面的求重复有差不多的方法

 if number in occurrences:
            occurrences[number] += 1
        else:
            occurrences[number] = 1

加上计算器就可以了

## Demo63 打印不同的数

题目描述

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

输入输出描述

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

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

示例

> 输入：
>
> 10
>
> 1 2 3 2 1 6 3 4 5 2
>
> 输出：
>
> 1 2 3 6 4 5

用哈希表就可以了，再遍历哈希表，看看是否重复，这里用“ （） ”

我就不多赘述

题目描述

输入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 find_gcd(numbers):
    n = len(numbers)
    result = numbers[0]
    for i in range(1, n):
        result = gcd(result, numbers[i])

第一个函数gcd，我们来进行求约数

我们很巧妙的运用了

while b!=0

a,b = b,a%b判断公约数

第二个函数进行两两比较，不断覆写result值，求出最大的公约数

## Demo65 打乱数组

题目描述

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

def shuffle_array(nums):
    random.shuffle(nums)
    return nums

运用random模块进行随机方法 .shuffle() 进行打乱

## Demo67 相似词

题目描述

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

输入输出描述

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

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

示例

> 输入：
>
> listen
>
> silent
>
> 输出：
>
> YES

直接让俩个字母列表进行字母顺序排序，一样就行

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

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

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

输入输出描述

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

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

示例

> 输入：
>
> 5 8
>
> 输出：
>
> LRLRLRR
>
> RRLLLRR
>
> LLRLLRR
>
> RRLLLLL
>
> LRLRRLR
>
> 0 0 1 1 3 0 0 0

def simulate_bean_machine(ball_count, slot_count):
    slots = [0] * slot_count
    paths = []
    
    for _ in range(ball_count):
        path = ""
        position = 0
        
        for _ in range(slot_count - 1):
            direction = random.choice(["L", "R"])
            path += direction
            
            if direction == "R":
                position += 1
        
        slots[position] += 1
        paths.append(path)
    
    return paths, slots

我们首先定义了一个函数 simulate_bean_machine ，该函数接受小球个数和槽子个数作为输入，并返回小球的路径和最终每个槽子中小球的个数。在函数中，我们使用一个列表 slots 来表示每个槽子中小球的个数，初始化为全零。然后，我们进行小球模拟的循环，每次模拟一个小球的路径。在小球的路径模拟中，我们使用 random.choice 函数随机选择小球下落的方向，并根据方向更新小球的位置和路径。最后，我们将小球的路径添加到路径列表 paths 中，并根据小球的最终位置更新槽子中小球的个数。最后，我们返回路径列表和槽子列表。

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

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

这是一个很有意思的数学题，我们可以知每个门的状态是0,1开关，这里我们到第三间的时候会改变对应数字的数量的间隔的门的状态

a1=开

a2=开时，a1=关

有a3=开，a2=关。。。。

我们就可以

def simulate_lockers():
    lockers = [False] * 100

    for student in range(1, 101):
        for locker in range(student, 101, student):
            lockers[locker - 1] = not lockers[locker - 1]

    open_lockers = [i + 1 for i, locker in enumerate(lockers) if locker]
    return open_lockers

题目描述

给定两个有序递增的数组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

这里我们可以就将两个数组的数比较c数组内的数，放入对应位置

    merged_array = []
    i, j = 0, 0
    len_a, len_b = len(array_a), len(array_b)

    while i < len_a and j < len_b:
        if array_a[i] <= array_b[j]:
            merged_array.append(array_a[i])
            i += 1
        else:
            merged_array.append(array_b[j])
            j += 1

    while i < len_a:
        merged_array.append(array_a[i])
        i += 1

    while j < len_b:
        merged_array.append(array_b[j])
        j += 1

这里我使用较多的变量使得过程清晰一些

给定一个数组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]都可作为上述划分

这个有点类似于c语言里面的插入排序，存在一个“哨兵”的感觉，只不过这里面的哨兵不会改变

def partition_array(nums):
    pivot = nums[0]  # 选择第一个元素作为枢纽
    i = 0  # i指向第一个区间的末尾
    j = 0  # j指向第二个区间的末尾

    for k in range(1, len(nums)):
        if nums[k] < pivot:  # 小于枢纽的元素放入第一个区间
            nums[k], nums[i] = nums[i], nums[k]
            i += 1
            j += 1
        elif nums[k] == pivot:  # 等于枢纽的元素放入第二个区间
            nums[k], nums[j] = nums[j], nums[k]
            j += 1