python算法练习1

最新推荐文章于 2024-08-12 19:18:27 发布

TODO_D2D

最新推荐文章于 2024-08-12 19:18:27 发布

阅读量128

点赞数

分类专栏： python学习笔记文章标签：算法 python 开发语言

本文链接：https://blog.csdn.net/weixin_44605991/article/details/127658632

版权

python学习笔记专栏收录该内容

3 篇文章 0 订阅

订阅专栏

题目一：

给一个乱序的整数数组，请用冒泡排序的方式实现升序排列。函数的形参是一个数组，函数的返回值为一个数组。
输入：[5, 4, 3, 2, 1]
输出：[1, 2, 3, 4, 5]

def question_1(arra):
    lenth = len(arra)
    for j in range(lenth):
        for i in range(lenth - 1 - j):
            if arra[i] > arra[i + 1]:
                arra[i], arra[i + 1] = arra[i + 1], arra[i]

if __name__ == '__main__':
    #a = [5,4,3,2,1]
    arr = input("input:")
    num = [int(n) for n in arr.split(',')]

    import numpy as np
    arra = np.array(num)

    question_1(arra)
print(arra)

题目二：

现给一棵二叉树的根节点，以数组的形式返回二叉树中节点元素的后续遍历结果。
示例：
输入：root = [1,null,2,3]
输出：[3,2,1]

# -*- coding: utf-8 -*-

from typing import List, Optional

class TreeNode:
    def __init__(self, root=0, left=None, right=None):
        self.root = root
        self.left = left
        self.right = right

class Solution:
    def __init__(self):
        pass

    def Traver(self, root):
        if None == root:
            return []

        ret = []
        s1 = []
        s2 = []
        s1.append(root)
        s2.append(0)
        # 从根节点开始遍历,遍历左子树即将左子树压入数据栈，遍历右子树即将右子树压入数据栈，遍历根节点即输出根节点的值。
        while s1:
            # 获取当前根节点的操作状态，并弹出当前节点的操作状态。
            flag = s2.pop()

            # 对当前节点的具体操作
            if 0 == flag:  # 第一步：遍历当前根节点的左子树
                s2.append(1)  # 当前根节点的状态码由0转为1，即下一步遍历当前根节点的右节点
                if s1[-1].left:
                    s1.append(s1[-1].left)
                    s2.append(0)
            elif 1 == flag:  # 第二步：遍历当前根节点的右子树
                s2.append(2)
                if s1[-1].right:
                    s1.append(s1[-1].right)
                    s2.append(0)
            elif 2 == flag:  # 第三步：遍历根节点，输出根节点的值，并弹出根节点
                ret.append(s1.pop().root)

        length_ret = len(ret)
        result = []
        for j in range(len(ret)):
            if ret[j] == 'null':
                for i in range(j,length_ret - 1):
                    ret[i] = ret[i + 1]
                length_ret = length_ret - 1

        for i in range(length_ret):
            result.append(int(ret[i]))

        return result

def main():
    arr = input("input:")
    tree = [n for n in arr.split(',')]

    lenth = len(tree)
    if lenth == 1:
        TreeNodea = TreeNode(tree[0])
    elif lenth == 2:
        TreeNodea = TreeNode(tree[0])
        TreeNodeb = TreeNode(tree[1])
        TreeNodea.left = TreeNodeb
    elif lenth == 3:
        TreeNodea = TreeNode(tree[0])
        TreeNodeb = TreeNode(tree[1])
        TreeNodec = TreeNode(tree[2])
        TreeNodea.left = TreeNodeb
        TreeNodea.right = TreeNodec
    elif lenth == 4:
        TreeNodea = TreeNode(tree[0])
        TreeNodeb = TreeNode(tree[1])
        TreeNodec = TreeNode(tree[2])
        TreeNoded = TreeNode(tree[3])
        TreeNodea.left = TreeNodeb
        TreeNodea.right = TreeNodec
        TreeNodeb.left = TreeNoded
        TreeNodeb.right = None
        TreeNodec.left = None
        TreeNodec.right = None
    elif lenth == 5:
        TreeNodea = TreeNode(tree[0])
        TreeNodeb = TreeNode(tree[1])
        TreeNodec = TreeNode(tree[2])
        TreeNoded = TreeNode(tree[3])
        TreeNodee = TreeNode(tree[4])
        TreeNodea.left = TreeNodeb
        TreeNodea.right = TreeNodec
        TreeNodeb.left = TreeNoded
        TreeNodeb.right = TreeNodee
        TreeNodec.left = None
        TreeNodec.right = None
    elif lenth == 6:
        TreeNodea = TreeNode(tree[0])
        TreeNodeb = TreeNode(tree[1])
        TreeNodec = TreeNode(tree[2])
        TreeNoded = TreeNode(tree[3])
        TreeNodee = TreeNode(tree[4])
        TreeNodef = TreeNode(tree[5])
        TreeNodea.left = TreeNodeb
        TreeNodea.right = TreeNodec
        TreeNodeb.left = TreeNoded
        TreeNodeb.right = TreeNodee
        TreeNodec.left = TreeNodef
        TreeNodec.right = None
    elif lenth == 7:
        TreeNodea = TreeNode(tree[0])
        TreeNodeb = TreeNode(tree[1])
        TreeNodec = TreeNode(tree[2])
        TreeNoded = TreeNode(tree[3])
        TreeNodee = TreeNode(tree[4])
        TreeNodef = TreeNode(tree[5])
        TreeNodeg = TreeNode(tree[6])
        TreeNodea.left = TreeNodeb
        TreeNodea.right = TreeNodec
        TreeNodeb.left = TreeNoded
        TreeNodeb.right = TreeNodee
        TreeNodec.left = TreeNodef
        TreeNodec.right = TreeNodeg

    TreeNode_root = TreeNodea
    solution = Solution()
    print(solution.Traver(TreeNode_root))

if __name__ == "__main__":
    main()

题目三：

小明同学为参与信息学部算法大赛，他对已学算法知识进行整理，共整理出N（0<N<1000）个类型的算法题目，每个类型的算法题目数量是随机的。小明计划每天任意选取其中三类题目进行练习，同时为保证每日学习时间，小明拟计划每日完成n道题。请你设计一个算法，假设给出每个类型的题目数量的前提下，给出小明最合理的学习计划。
注意：三元组（a、b、c）中的元素必须按非降序排列。（即a≤b≤c）；
解集中不能包含重复的三元组。
例如，给定题目数量数组：S = {10 2 8 3 15 6 1 4 11}, 计划完成题目n=20，
解集为：(2, 8, 10),(3，6，11), (1, 4, 15)

def result(num):
    out = []  # 输出的和为20的嵌套列表
    if len(num) < 3:
        return []
    num.sort()  # 排序
    for j in range(0, int(len(num)/3)):
        if num[j] > 20:
            break
        left = 1  # 左指针
        right = len(num) - 1  # 右指针
        target = 20 - num[0]  # 剩余两个数的和
        while (left < right) or (len(num)==3):
            if num[left] + num[right] == target:
                out.append([num[0], num[left], num[right]])
                num.pop(right)
                num.pop(left)
                num.pop(0)
                break
            elif num[left] + num[right] > target:
                right -= 1
            else:
                left += 1
    return out

arr = input("input:")
n = [int(n) for n in arr.split(',')]
print(result(n))

题目四：

N（N<100000）个孩子做游戏，现在请你根据游戏得分来发糖果，要求如下：

每个孩子不管得分多少，起码分到一个糖果。
任意两个相邻的孩子之间，得分较多的孩子必须拿多一些糖果。(若相同则无此限制)
给定一个数组arr代表得分数组，请返回最少需要多少糖果。
示例：
输入：[1,1,2]
返回值：4
说明：最优分配方案为1,1,2

def main():
    arr = input("input:")
    score = [int(n) for n in arr.split(',')]
    length = len(score)
    candy = []
    sum = 0
    candy.append(1)
    for i in range(1,length):
        if score[i] > score[i-1]:
            candy.append(candy[i-1] + 1)
        else:
            candy.append(1)

    for i in range(length-2,0,-1):
        if score[i] == score[i+1]:
            candy[i] = max(candy[i],candy[i+1])
        elif score[i] > score[i+1]:
            if candy[i] < candy[i+1] or candy[i] == candy[i+1]:
                candy[i] = candy[i+1] + 1
    #print(candy)

    for i in range(length):
        sum = sum + candy[i]
    print(sum)

if __name__ == "__main__":
    main()

题目五：

由于虚拟货币的影响，很多人通过显卡买卖赚了钱。现在小明通过特殊方法知道了某型号显卡在未来一段时间内每天的价格，小明想知道如何买卖显卡才能获得最大收益。限制小明最多可以完成 a 次显卡的买卖操作，而且小明不能同时进行多张显卡的买卖，也就是小明不能在手中已有显卡的情况下再继续买显卡。函数的第一个形参是一个数组，数组中的元素表示显卡每天的价格。函数的第二个形参是交易次数。函数返回值是一个整数，表示最大收益。
示例1：
输入：显卡价格 = [2, 1, 2, 3, 4, 5, 6]，交易次数(a) = 2。
输出：5。
说明：第二天买入，第七天卖出，最大收益为：6 - 1 = 5。只完成一次交易即可获得最大收益。
示例2：
输入：显卡价格 = [2,3,5,6,0,3]，交易次数(a) = 2。
输出：7。
说明：在第一天的时候买入，在第四天的时候卖出, 这时获得收益：6-2 = 4 。随后，在第五天的时候买入，在第六天的时候卖出, 这时获得收益：3-0 = 3 。所以最大收益为：4 + 3 = 7。完成了两次交易才获得了最大收益。

def result(num,flag):
    sum = 0
    a = 0
    length = len(num)
    min_in = num[0]
    for i in range(1,length):
        max_out = num[i]
        if max_out > min_in: #
            sum = sum + max_out - min_in
            min_in = num[i]
        else:
            min_in = max_out
    return sum


arr = input("price:")
n = [int(n) for n in arr.split(',')]
a = input("a:")
a = int(a)
print(result(n,a))