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

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

examination questions

2022.08.06

给你一个 m * n 的矩阵，矩阵中的数字各不相同。请你按任意顺序返回矩阵中的所有幸运数。
幸运数 是指矩阵中满足同时下列两个条件的元素：
在同一行的所有元素中最小
在同一列的所有元素中最大

#test case
matrix = [[3,7,8],[9,11,13],[15,16,17]]
#Method
class Solution(object):
    def luckyNumbers (self, matrix):
        """
        :type matrix: List[List[int]]
        :rtype: List[int]
        """
        row_min = [min(i) for i in matrix]
        col_max = [max(i) for i in zip(*matrix)]
        lucky = list(set(row_min) & set(col_max))
        # lucky = [i for i in col_max if i in row_min]
        return lucky

2022.08.07

以数组intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi] 。请你合并所有重叠的区间，并返回一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间。

example = [[1,3],[2,6],[8,10],[15,18]]
def merge(intervals):
    """
    :type intervals: List[List[int]]
    :rtype: List[List[int]]
    """
    intervals.sort()  #最为主要的排序过程
    element=[]
    for i,j in intervals:
        if len(element) == 0 or element[-1][1] < i:
            element.append([i,j])
        else:
            element[-1][1] = max(element[-1][1],j)
    return element
a = merge(example)

约好了早上七点和我妈一起去菜市场买菜，不知道咋地今天就是睡不着，那就再练一道再睡吧！！

给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。
不要使用额外的数组空间,你必须仅使用 O(1) 额外空间并 地修改输入数组。元素的顺序可以改变,你不需要考虑数组中超出新长度后面的元素。

#这是一道非常简单的题目，但难的地方在于现在限制了空间复杂度：O(1)
#但是出题的例子是有BUG的，直接按照sort 函数，暴力解法，用无限次for循环剔除val值元素
nums = [0,1,2,2,3,0,4,2]
val = 2
class Solution(object):
    def removeElement(self, nums, val):
        """
        :type nums: List[int]
        :type val: int
        :rtype: int
        """
        nums.sort()
        while val in nums:   
            for i in nums:
                if i == val:
                    nums.remove(i)
        return len(nums)

2022.08.08

已知函数 signFunc(x) 将会根据 x 的正负返回特定值：
如果 x 是正数，返回 1 。
如果 x 是负数，返回 -1 。
如果 x 是等于 0 ，返回 0 。
给你一个整数数组 nums 。令 product 为数组 nums 中所有元素值的乘积。
返回 signFunc(product)

#又是一道简单题，快速解答吧
nums = [-1,-2,-3,-4,3,2,1]
class Solution(object):
    def arraySign(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        product=1
        b=0
        for i in nums:
            a = i
            product = product*a
        if product > 0:
            b = 1
        elif product == 0:
            b = 0
        else:
            b = -1
        return b
#先求和再写一个符号函数，但是会浪费一部分的时间，下面是不求和的方法
class Solution:
    def arraySign(self, nums: List[int]) -> int:
        product = 1
        for x in nums:
            if x < 0:
                product *= (-1)
            elif x == 0:
                product = 0
                break
        return product

给你一个字符串 licensePlate 和一个字符串数组 words ，请你找出 words 中的 最短补全词 。
补全词 是一个包含 licensePlate 中所有字母的单词。忽略 licensePlate 中的 数字和空格 。不区分大小写。如果某个字母在 licensePlate 中出现不止一次，那么该字母在补全词中的出现次数应当一致或者更多。
例如：licensePlate = “aBc 12c”，那么它的补全词应当包含字母 ‘a’、‘b’ （忽略大写）和两个 ‘c’ 。可能的 补全词 有 “abccdef”、“caaacab” 以及 “cbca” 。
请返回 words 中的 最短补全词 。题目数据保证一定存在一个最短补全词。当有多个单词都符合最短补全词的匹配条件时取 words 中 第一个 出现的那个。

这道题目好变态啊， 明明Counter是需要from collections import Counter来调用的，但是默认居然安装了这个包！！我想通过set(dict.items())来绕过必须使用Counter的方法实现字典相减的功能，但是测试用例有个别无法通过。最后看一下官方答案，居然直接使用Counter函数，也是无力吐槽了。出门买菜去了，这也能叫简单题。

class Solution(object):
    def shortestCompletingWord(self, licensePlate, words):
        """
        :type licensePlate: str
        :type words: List[str]
        :rtype: str
        """
        licensePlate = licensePlate.encode("utf-8")
        new_alphabet = Counter(filter(str.isalpha, licensePlate.lower()))
        return min(filter(lambda w: not (new_alphabet - Counter(w.lower())), words), key=len)

2022.08.09

给你一个整数数组 coins ，表示不同面额的硬币；以及一个整数 amount ，表示总金额。
计算并返回可以凑成总金额所需的 最少的硬币个数 。如果没有任何一种硬币组合能组成总金额，返回 -1 。
你可以认为每种硬币的数量是无限的。

#这道题目很多人用二进制，BFS和DFS的做，但是我感觉这个更好理解
#直接遍历，得到所有的最小解，有解分为两种情况，无解直接为-1
#当然解题思路是从别人的代码中学到的，我样本是想做除数得余，发现套了好多if运算量太大了
class Solution(object):
    def coinChange(self, coins, amount):
        """
        :type coins: List[int]
        :type amount: int
        :rtype: int
        """
        dp = [amount + 1]*(amount + 1)
        dp[0] = 0
        for coin in coins:
            for j in range(coin, amount + 1):
                dp[j] = min(dp[j], dp[j - coin] + 1)
        return dp[amount] if dp[amount] < amount + 1 else -1

2022.08.10

给你一个整数数组 nums 。如果任一值在数组中出现至少两次 ，返回 true ；如果数组中每个元素互不相同，返回 false 。

#输入：nums = [1,2,3,1]
#输出：true
#太简单了，一分钟解题.....
class Solution(object):
    def containsDuplicate(self, nums):
        """
        :type nums: List[int]
        :rtype: bool
        """
        single_nums = set(nums)
        if len(single_nums) == len(nums):
            return False
        else:
            return True

2022.08.11

给定两个字符串形式的非负整数 num1 和num2 ，计算它们的和并同样以字符串形式返回。
你不能使用任何內建的用于处理大整数的库（比如 BigInteger），也不能直接将输入的字符串转换为整数形式。
输入：num1 = “11”, num2 = “123”
输出：“134”

#看不明白出题人的想法...（弱智题）
class Solution(object):
    def addStrings(self, num1, num2):
        """
        :type num1: str
        :type num2: str
        :rtype: str
        """
        a = str(int(num1)+int(num2))
        return a

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案
输入：nums = [2,7,11,15], target = 9
输出：[0,1]

#最开始我用的是for i,j in enumerate(nums):
#if i+j == target:
#result = [nums.index(i),nums.index(j)]
#但是在[3,3]和6这个地方会卡住，最后看了一个题解，还是蛮创新的
class Solution(object):
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        result = [0,0]
        for i in range(len(nums)):
            j = target - nums[i]
            if j in nums[:i]:
                result = [nums.index(j),i]
        return result          

2022.08.12

给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。
说明：
你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？
输入: [2,2,1]
输出: 1

#不使用额外的空间，那就用sort函数排序后进行两两遍历
class Solution(object):
    def singleNumber(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        nums.sort()
        i = 1
        while i <= len(nums)-1:
            if nums[i] == nums[i-1]:
                i +=2
            else:
               return nums[i-1]
        else:
            return nums[i-1]

这周算是蛮不错的，游泳学的差不多了，泡在健身房力量训练也还行。今天回乡下去脐橙园帮忙干活一个小时，带回来了旧电脑。下周把旧电脑拆解了，修理一下。假期快结束了…