Leetcode 随机题库练习(第二周)

假期 Leetcode 随机题库练习记录(第二周)

2022.08.13

给你一个含 n 个整数的数组 nums ，其中 nums[i] 在区间 [1, n] 内。请你找出所有在 [1, n] 范围内但没有出现在 nums 中的数字，并以数组的形式返回结果。
输入：nums = [4,3,2,7,8,2,3,1]
输出：[5,6]

class Solution(object):
    def findDisappearedNumbers(self, nums):
        """
        :type nums: List[int]
        :rtype: List[int]
        """
        max_value = len(nums)
        entire_nums = []
        for i in range(1,max_value+1):
            entire_nums.append(i)
        result = []
        for i in entire_nums:
            if i not in nums:
                result.append(i)
        return result
        #list(set(range(1, len(nums) + 1)).difference(set(nums)))
#这道题简直窒息，最后运行的时候，有个数据量很大的nums,
#导致我的解法超出时间限制，无奈妥协，查看其他解法发现difference 
#确实更好

2022.08.14

给你两个整数数组 nums1 和 nums2 ，请你以数组形式返回两数组的交集。返回结果中每个元素出现的次数，应与元素在两个数组中都出现的次数一致（如果出现次数不一致，则考虑取较小值）。可以不考虑输出结果的顺序。

#就没啥技巧可言，直接取交集，然后再对nums1 和nums2 计数就行了
class Solution(object):
    def intersect(self, nums1, nums2):
        """
        :type nums1: List[int]
        :type nums2: List[int]
        :rtype: List[int]
        """
        intersection = set(nums1) & set(nums2)
        result = []
        for i in intersection:
            result += [i] * min(nums1.count(i), nums2.count(i))  
        return result

2022.08.15

给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。
请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。
注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。
输入：nums1 = [1,2,3,0,0,0]，m = 3，nums2 = [2,5,6]，n = 3

#法1的方法是错误的，因为我是讲nums2和nums1进行了求和，但是题目是不允许这样做的
#不放在LeetCode测试上面运行的话，是很正常的解法
#法1：
nums1 = (nums2 + nums1)
nums1.sort(reverse=False)
val = 0
while val in nums1:
    if nums1[0] == 0:
        nums1.remove(0)
#法2：
class Solution(object):
    def merge(self, nums1, m, nums2, n):
        """
        :type nums1: List[int]
        :type m: int
        :type nums2: List[int]
        :type n: int
        :rtype: None Do not return anything, modify nums1 in-place instead.
        """
        for i in range(n):
            nums1[m+i] = nums2[i]
        nums1.sort(reverse=False)
        return nums1

2022.08.16

给出由小写字母组成的字符串 S，重复项删除操作会选择两个相邻且相同的字母，并删除它们。
在 S 上反复执行重复项删除操作，直到无法继续删除。
在完成所有重复项删除操作后返回最终的字符串。答案保证唯一。

#我原本的理解是两两之间进行配对，但是运行量大，后面思考从后往前配对，
#刚好和官网推荐的一样
class Solution(object):
    def removeDuplicates(self, s):
        """
        :type s: str
        :rtype: str
        """
        result = []
        for i in s:
            if result and result[-1] == i:
                result.pop()
            else:
                result.append(i)
        result = "".join(result)
        return result

2022.08.17

给定一个整数数组，找出总和最大的连续数列，并返回总和。
输入： [-2,1,-3,4,-1,2,1,-5,4]
输出： 6
解释： 连续子数组 [4,-1,2,1] 的和最大，为 6。

#题目还是很简单的，但是这个解法会超时
a = nums[0]
for i in range(len(nums)):
    b = 0
    for j in range(i,len(nums)):
        b += nums[j]
        a = max(b,a)
#这个是找的一个博主的解析
class Solution(object):
    def maxSubArray(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        zero = 0
        res = nums[0]
        n = len(nums)
        for i in range(n):
            zero = max(zero + nums[i],nums[i])
            res = max(zero,res)
        return res
#其实大家的想法都差不多，但是这个确实节省了一个for循环带来的运算量

2022.08.18

给你一个仅包含小写英文字母和 ‘?’ 字符的字符串 s，请你将所有的 ‘?’ 转换为若干小写字母，使最终的字符串不包含任何 连续重复 的字符。
注意：你不能修改非 ‘?’ 字符。
题目测试用例保证 除 ‘?’ 字符 之外，不存在连续重复的字符。
在完成所有转换（可能无需转换）后返回最终的字符串。如果有多个解决方案，请返回其中任何一个。可以证明，在给定的约束条件下，答案总是存在的。

输入：s = “?zs”
输出：“azs”
解释：该示例共有 25 种解决方案，从 “azs” 到 “yzs” 都是符合题目要求的。只有 “z” 是无效的修改，因为字符串 “zzs” 中有连续重复的两个 ‘z’ 。

#这道题有点死磕到底了，刚开始的想法是replace函数替换，但是会遇到 “？？” 替换成 “a a” 这样重复的问题
#于是替换变成了赋值，然后要遇到了 remain_alphabet 索引不够的问题，最后演变成了 *100
class Solution(object):
    def modifyString(self, s):
        """
        :type s: str
        :rtype: str
        """
        S = []
        for i in s:
            S.append(str(i))
            
        alphabet = list(map(chr, range(ord('a'), ord('z') + 1)))
        remain_alphabet =  [i for i in alphabet if i not in S]
        remain_alphabet = remain_alphabet*100    

        for i in range(len(S)):
            if S[i] == "?":
                S[i] = remain_alphabet[i]
            
        result = "".join(S)        
        return result

附一张我的执行结果图

2022.08.19

编写一个函数来查找字符串数组中的最长公共前缀。
如果不存在公共前缀，返回空字符串 “”。
输入：strs = [“flower”,“flow”,“flight”]
输出：“fl”

# 这是一个不会用while循环而引发的故事，其实最开始我就设定for 和 while循环来遍历的，但是
# 后面问题越来越多，我就不断的完善，最后得到这个。
class Solution(object):
    def longestCommonPrefix(self, strs):
        """
        :type strs: List[str]
        :rtype: str
        """
        len_str = len(strs[0])
        min_num_index = 0   
        stack = [strs[0]]   
        for index, string in enumerate(strs):
            if len(string) < len_str:
                stack.pop()
                len_str = len(string)
                min_num_index = index  
                stack.append(string)
        minlength = len(stack[0])
        if strs == [""]:
            result = ''
        elif len(strs) == 1:
            result = strs[0]
        else:
            for i in range(1,len(strs)):
                j = 0
                while j < len(strs[i]) and j < minlength and strs[i][j] == strs[i-1][j] == strs[0][j] == strs[1][j]\
                == strs[min_num_index ][j]:
                    j +=1
                minresult = min(minlength,j)
                result = strs[0][:minresult]
        return result

一周又过去了，时间过的真快，不知不觉做题已经两周了。回学校以后确实能更静下心去做题