Python蓝桥杯训练：数组和字符串 Ⅳ

Python蓝桥杯训练：数组和字符串 Ⅳ

一、买卖股票的最佳时机

给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。

你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。

返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。

例如：

输入：[7,1,5,3,6,4]

输出：5

解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。

我们可以通过遍历数组中的每个价格，找到最低价格，然后计算最大收益，以此来找到最大收益。我们使用了一个变量minprice来保存最低价格，并使用maxprofit变量来记录最大收益。我们假设我们在第i天卖出股票，那么当天的利润就是prices[i] - minprice，因此我们只需要遍历一次数组，记录股票最低点，并且通过判断只有当价格大于最低价格时我们才会更新最大利润。

具体实现代码如下：

class Solution:
    def maxProfit(self, prices):
        minprice = float('inf') # python中表示无穷大
        maxprofit = 0
        for i in prices:
            if i < minprice:
                minprice = i
            else:
                maxprofit = max(maxprofit, i - minprice)
        return maxprofit

我们还可以优化一下，上述代码每次遍历都要从数组中取出元素，效率比较低，我们可以直接取出数组中的元素，提高效率。

class Solution:
    def maxProfit(self, prices):
        minprice = float('inf')
        maxprofit = 0
        for i in range(len(prices)):
            minprice = min(minprice, prices[i])
            maxprofit = max(maxprofit, prices[i] - minprice)
        return maxprofit

这题主要考察的是动态规划，前i天的最大收益 = max{前i-1天的最大收益，第i天的价格-前i-1天中的最小价格}，后面我会专门写一篇文章来学习一下该算法。

二、删除排序数组中的重复项

给你一个 升序排列 的数组 nums ，请你原地删除重复出现的元素，使每个元素只出现一次，返回删除后数组的新长度。元素的相对顺序应该保持一致 。

由于在某些语言中不能改变数组的长度，所以必须将结果放在数组nums的第一部分。更规范地说，如果在删除重复项之后有 k 个元素，那么nums的前 k 个元素应该保存最终结果。

将最终结果插入nums的前 k 个位置后返回 k 。

不要使用额外的空间，你必须在原地修改输入数组 并在使用 O(1) 额外空间的条件下完成。

示例：

输入：nums = [0,0,1,1,1,2,2,3,3,4]

输出：5, nums = [0,1,2,3,4]

解释：函数应该返回新的长度 5 ，并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4 。不需要考虑数组中超出新长度后面的元素。

这个题目我们需要使用快慢指针的思想去实现，快指针表示遍历数组到达的下标位置，慢指针表示下一个不同元素要填入的下标位置，初始时两个指针都指向下标 1，Slow指针指向新数组的末尾，Fast指针遍历原始数组，如果nums[Fast]不等于nums[Slow]，则将nums[Fast]复制到nums[Slow+1]，并将Fast加1，最后返回Slow+1。

我们来打个比方方便理解，例如将Fast比作一个星探，将Slow比作最后一位新人所站的位置，星探要在站在房间前的一队人中来选择新人并将其安排到队伍第一人的后面站着，因为要保证要选出人来，所以队中的第一人不用被选择直接保持不动，然后星探选择队列中的第二人，如果这个第二人是一个新手，那么他将被安排第一个人的后面站着，如果第二个人是老选手，那么就直接跳过，因为星探要选择新人，假如第二个人是新人，那么星探将继续选择第三人，第二个新人将站在之前的新人队伍的最后，依次类推，直到星探选完整个队列，然后看最后备选到的新人所站的位置在哪。

我的比方可能讲得并不是很好，我们来画一个图直观一点：

具体实现代码如下：

class Solution:
    def removeDuplicates(self, nums):
        if not nums:
            return 0
        i = 0
        for j in range(len(nums)):
            if nums[j] != nums[i]:
                i += 1
                nums[i] = nums[j]
        return i + 1

这个题目没有说数组会不会为空，避免报错，我们记得首先进行判断。

三、找出字符串中第一个匹配项的下标

给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串的第一个匹配项的下标（下标从 0 开始）。如果 needle 不是 haystack 的一部分，则返回 -1

示例1：

输入：haystack = “sadbutsad”, needle = “sad”

输出：0

解释：“sad” 在下标 0 和 6 处匹配。第一个匹配项的下标是 0 ，所以返回 0

示例2：

输入：haystack = “leetcode”, needle = “leeto”

输出：-1

解释：“leeto” 没有在 “leetcode” 中出现，所以返回 -1 。

这个题目我的做法很简单，直接通过if...else判断如果 needle 不在 haystack 中，则函数返回 -1，否则返回 needle 的索引。

具体实现代码如下：

class Solution:
    def strStr(self,haystack, needle):
        if needle not in haystack:
            return -1
        else:
            return haystack.index(needle)

因为我还有很多算法还没去学习过，所以我就去力扣看了一下别人的解法，有一个大佬他使用的是Sunday算法，我也不了解这个算法，我就去简单的搜索了一下。

Sunday算法是一种字符串模式匹配算法， 其核心思想是：在匹配过程中，模式串并不被要求一定要按从左向右进行比较还是从右向左进行比较，它在发现不匹配时，算法能跳过尽可能多的字符以进行下一步的匹配，从而提高了匹配效率。

具体的解释，待我去学习一波之后再写个博客。

他代码优化之后的代码：

class Solution:
    def strStr(self, haystack, needle):
        if not needle: return 0
        lnd = len(needle)
        lnf = len(haystack)
        if lnd > lnf: return -1

        # 偏移表预处理    
        dic ={v:lnd-k for k,v in enumerate(needle)}
        idx = 0

        while idx+lnd <= lnf:
            # 待匹配字符串
            str_cut = haystack[idx:idx+lnd]
            # 判断是否匹配
            if str_cut == needle:
                return idx
            elif idx+lnd == lnf:
                return -1
            else:
                # 不匹配情况下，根据下一个字符的偏移，移动idx
                nextc = haystack[idx+lnd]
                idx += dic[nextc] if dic.get(nextc) else lnd+1
        return -1

四、将整数转换为两个无零整数的和

「无零整数」是十进制表示中 不含任何 0 的正整数。

给你一个整数 n，请你返回一个 由两个整数组成的列表 [A, B]，满足：

A 和 B 都是无零整数
A + B = n
题目数据保证至少有一个有效的解决方案。

如果存在多个有效解决方案，你可以返回其中任意一个。

示例：

输入：n = 2

输出：[1,1]

解释：A = 1, B = 1. A + B = n 并且 A 和 B 的十进制表示形式都不包含任何 0 。

这题的思路就是使用一个for循环，从0开始，遍历n中的每一个数，将其与n-a相加，并检查它们是否不包含0。如果不包含0，则返回a和n-a，否则继续循环。

具体实现代码如下：

class Solution:
    def getNoZeroIntegers(self, n):
        for a in range(n):
            if '0' not in str(a) + str(n-a):
                return [a, n-a]