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

Leetcode 随机题库练习记录(第四周)

2022.08.27

给你一个非负整数数组 nums 。在一步操作中，你必须：
选出一个正整数 x ，x 需要小于或等于 nums 中 最小的非零元素。
nums 中的每个正整数都减去 x。
返回使 nums 中所有元素都等于 0 需要的最少操作数。

class Solution(object):
    def minimumOperations(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        S = set(nums)
        result = []
        for num in S:
            if num != 0:
                result.append(num)
        return len(result)

2022.08.28

数组中占比超过一半的元素称之为主要元素。给你一个 整数 数组，找出其中的主要元素。若没有，返回 -1 。请设计时间复杂度为 O(N) 、空间复杂度为 O(1) 的解决方案。
输入：[1,2,5,9,5,9,5,5,5]
输出：5

class Solution(object):
    def majorityElement(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        a = set(nums)
        mid = len(nums)//2

        for i in a:
            if nums.count(i) > mid:
                return i
        return -1

早上和一年级的新生食堂抢包子…他们真的很早起啊！！

2022.08.29

小扣在秋日市集选择了一家早餐摊位，一维整型数组 staple 中记录了每种主食的价格，一维整型数组 drinks 中记录了每种饮料的价格。小扣的计划选择一份主食和一款饮料，且花费不超过 x 元。请返回小扣共有多少种购买方案。
注意：答案需要以 1e9 + 7 (1000000007) 为底取模，如：计算初始结果为：1000000008，请返回 1
输入：staple = [10,20,5], drinks = [5,5,2], x = 15
输出：6
解释：小扣有 6 种购买方案，所选主食与所选饮料在数组中对应的下标分别是：
第 1 种方案：staple[0] + drinks[0] = 10 + 5 = 15；
第 2 种方案：staple[0] + drinks[1] = 10 + 5 = 15；
第 3 种方案：staple[0] + drinks[2] = 10 + 2 = 12；
第 4 种方案：staple[2] + drinks[0] = 5 + 5 = 10；
第 5 种方案：staple[2] + drinks[1] = 5 + 5 = 10；
第 6 种方案：staple[2] + drinks[2] = 5 + 2 = 7。

#这道题目我感觉就是遍历题，但是它最关键的是时间复杂度问题，解法一是最原始的方式，解法二是我想的先排序，后加一个break
#虽然有降低，但是也不明显，最后还是用二分法来做，刚好最近系统的学了一下
#解法一：
# b = 0 
# for i in staple:
#     for j in drinks:
#         if i+j <= x:
#             b += 1
#解法二：
# staple.sort() 
# drinks.sort() 
# b = 0 
# for i in staple:
#     for j in drinks:
#         if i+j <= x:
#             b += 1
#         else:
#             break
class Solution:
    def breakfastNumber(self, staple: List[int], drinks: List[int], x: int) -> int:
        import bisect
        b = 0
        staple.sort()
        drinks.sort()
        for i in range(len(staple)):
            if staple[i] >= x: 
                break
            b += bisect.bisect(drinks, x - staple[i])
        return b % 1000000007   

2022.08.30

国际摩尔斯密码定义一种标准编码方式，将每个字母对应于一个由一系列点和短线组成的字符串， 比如:
‘a’ 对应 “.-” ，
‘b’ 对应 “-…” ，
‘c’ 对应 “-.-.” ，以此类推。
为了方便，所有 26 个英文字母的摩尔斯密码表如下：
[“.-”,“-…”,“-.-.”,“-…”,“.”,“…-.”,“–.”,“…”,“…”,“.—”,“-.-”,“.-…”,“–”,“-.”,“—”,“.–.”,“–.-”,“.-.”,“…”,“-”,“…-”,“…-”,“.–”,“-…-”,“-.–”,“–…”]
给你一个字符串数组 words ，每个单词可以写成每个字母对应摩尔斯密码的组合。
例如，“cab” 可以写成 “-.-…–…” ，(即 “-.-.” + “.-” + “-…” 字符串的结合)。我们将这样一个连接过程称作 单词翻译 。
对 words 中所有单词进行单词翻译，返回不同 单词翻译 的数量。

输入: words = [“gin”, “zen”, “gig”, “msg”]
输出: 2
解释:
各单词翻译如下:
“gin” -> “–…-.”
“zen” -> “–…-.”
“gig” -> “–…–.”
“msg” -> “–…–.”
共有 2 种不同翻译, “–…-.” 和 “–…–.”.

#就暴力解法吧...字典都不建立
class Solution(object):
    def uniqueMorseRepresentations(self, words):
        """
        :type words: List[str]
        :rtype: int
        """
        Moore = [".-","-...","-.-.","-..",".","..-.","--.","....","..",".---","-.-",".-..","--",
         "-.","---",".--.","--.-",".-.","...","-","..-","...-",".--","-..-","-.--","--.."]
        alphabet = list(map(chr, range(ord('a'), ord('z') + 1)))

        result = []
        for i in words:
            moore_string = ''
            for j in i:
                moore_string += Moore[alphabet.index(j)]
            result.append(moore_string)
        return len(set(result))

2022.08.31

给定一种规律 pattern 和一个字符串 s ，判断 s 是否遵循相同的规律。
这里的 遵循 指完全匹配，例如， pattern 里的每个字母和字符串 s 中的每个非空单词之间存在着双向连接的对应规律。
输入: pattern = “abba”, s = “dog cat cat dog”
输出: true

#还是不知道自己哪里错了，下面是我的代码，注释是评论区的代码，做法不是一样的吗？？
#为什么pattern =  "abc"，s = "b c a" 就报错呢？？
s_split = [x for x in s.split()]

list1 = [i for i in range(len(s_split))]
list2 = [i for i in range(len(pattern))]

dict_s = dict(zip(s_split,list1))
dict_pattern = dict(zip(pattern,list2))

s_values = []
pattern_values = []

pattern_values = [i for i in dict_pattern.values()]
s_values = [i for i in dict_s.values()]
    
pattern_values == s_values

# class Solution(object):
#     def wordPattern(self, pattern, s):
#         """
#         :type pattern: str
#         :type s: str
#         :rtype: bool
#         """
#         s = s.split(' ')
#         pi = [pattern.index(i) for i in pattern]
#         si = [s.index(i) for i in s]
#         return True if pi == si else False

2022.09.01

给你一个由一些多米诺骨牌组成的列表 dominoes。
如果其中某一张多米诺骨牌可以通过旋转 0 度或 180 度得到另一张多米诺骨牌，我们就认为这两张牌是等价的。
形式上，dominoes[i] = [a, b] 和 dominoes[j] = [c, d] 等价的前提是 ac 且 bd，或是 ad 且 bc。
在 0 <= i < j < dominoes.length 的前提下，找出满足 dominoes[i] 和 dominoes[j] 等价的骨牌对 (i, j) 的数量。
输入：dominoes = [[1,2],[2,1],[3,4],[5,6]]
输出：1

#又是代码超时的一天，我感觉自己现在处于一种能做题，但是写的东西总是很繁琐的过程
#注释部分是我写的，其实和评论区这个大佬的思想是一样的。
class Solution(object):
    def numEquivDominoPairs(self, dominoes):
        """
        :type dominoes: List[List[int]]
        :rtype: int
        """
        ans = 0
        d = dict()
        for d1, d2 in dominoes:
            index = tuple(sorted((d1, d2)))
            if index in d:
                d[index] += 1
            else:
                d[index] = 1
                
        for i in d:
            ans += d[i] * (d[i] - 1) // 2
        return ans
# dominoes = [[1,1],[2,2],[1,1],[1,2],[1,2],[1,1]]
# process_dom = [tuple(sorted(i)) for i in dominoes]
# a={}
# for i in process_dom:
#     a[i] = process_dom.count(i)
# result_sum = []
# for i in a.values():
#     result = 0 
#     if i > 1:
#         result = (i-1)*i/2
#     result_sum.append(result)
# sum(result_sum)

2022.09.02

一个 句子 指的是一个序列的单词用单个空格连接起来，且开头和结尾没有任何空格。每个单词都只包含小写或大写英文字母。
我们可以给一个句子添加 从 1 开始的单词位置索引 ，并且将句子中所有单词 打乱顺序 。
比方说，句子 “This is a sentence” 可以被打乱顺序得到 “sentence4 a3 is2 This1” 或者 “is2 sentence4 This1 a3” 。
给你一个 打乱顺序 的句子 s ，它包含的单词不超过 9 个，请你重新构造并得到原本顺序的句子。
输入：s = “is2 sentence4 This1 a3”
输出：“This is a sentence”
解释：将 s 中的单词按照初始位置排序，得到 “This1 is2 a3 sentence4” ，然后删除数字。

#这道题目还是得心应手啊，非常简单
class Solution(object):
    def sortSentence(self, s):
        """
        :type s: str
        :rtype: str
        """
        vocabulary_list = s.split()
        result = ['' for i in range(len(vocabulary_list))]
            
        for i in vocabulary_list:
            result[int(i[-1])-1] = i[:-1]
            
        return ' '.join(result)

又是一周过去了，已经是坚持学的第四周了，希望坚持下去有一个好的收获，加油！！！