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

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

2022.09.03

给你一个字符串 sentence 作为句子并指定检索词为 searchWord ，其中句子由若干用 单个空格 分隔的单词组成。请你检查检索词 searchWord 是否为句子 sentence 中任意单词的前缀。
如果 searchWord 是某一个单词的前缀，则返回句子 sentence 中该单词所对应的下标（下标从 1 开始）。如果 searchWord 是多个单词的前缀，则返回匹配的第一个单词的下标（最小下标）。如果 searchWord 不是任何单词的前缀，则返回 -1 。
字符串 s 的 前缀 是 s 的任何前导连续子字符串。
输入：sentence = “i love eating burger”, searchWord = “burg”
输出：4
解释：“burg” 是 “burger” 的前缀，而 “burger” 是句子中第 4 个单词。
又是新的一周，冲冲冲！！

# 发现我做力扣题就是在无限套用for循环
class Solution(object):
    def isPrefixOfWord(self, sentence, searchWord):
        """
        :type sentence: str
        :type searchWord: str
        :rtype: int
        """
        length = len(searchWord)
        sentence_process = sentence.split()
        result = 0
        for index, i in enumerate(sentence_process):
            if i[:length] == searchWord:
                result = index +1
                break
            else:
                result = -1
        return result 

2022.09.04

给你一个整数数组 arr，请你检查是否存在两个整数 N 和 M，满足 N 是 M 的两倍（即，N = 2 * M）。
更正式地，检查是否存在两个下标 i 和 j 满足：
i != j
0 <= i, j < arr.length
arr[i] == 2 * arr[j]
输入：arr = [10,2,5,3]
输出：true
解释：N = 10 是 M = 5 的两倍，即 10 = 2 * 5

#这道题我的解法的话就是会对[0,0]报错，通过enumerate函数遍历索引的话，就可以很好规避了
class Solution:
    def checkIfExist(self, arr: List[int]) -> bool:
        for i, a in enumerate(arr):
            for j, b in enumerate(arr):
                if i != j and a * 2 == b:
                    return True
        return False
# for i in arr:
#     for j in arr:           
#         if i!=j and i*2 == j:
#             return True
# return False

2022.09.05

给定一个字符串 s ，你需要反转字符串中每个单词的字符顺序，同时仍保留空格和单词的初始顺序。
输入：s = “Let’s take LeetCode contest”
输出：“s’teL ekat edoCteeL tsetnoc”

class Solution:
    def reverseWords(self, s: str) -> str:
        a = s.split()
        for i,j in enumerate(a):
            a[i] = j[::-1]
        c = " ".join(a)
        return c

2022.09.06

给你一个整数数组 nums （下标从 0 开始）。每一次操作中，你可以选择数组中一个元素，并将它增加 1 。
比方说，如果 nums = [1,2,3] ，你可以选择增加 nums[1] 得到 nums = [1,3,3] 。
请你返回使 nums 严格递增 的 最少 操作次数。
我们称数组 nums 是 严格递增的 ，当它满足对于所有的 0 <= i < nums.length - 1 都有 nums[i] < nums[i+1] 。
一个长度为 1 的数组是严格递增的一种特殊情况。
输入：nums = [1,1,1]
输出：3
解释：你可以进行如下操作：

1. 增加 nums[2] ，数组变为 [1,1,2] 。
2. 增加 nums[1] ，数组变为 [1,2,2] 。
3. 增加 nums[2] ，数组变为 [1,2,3] 。
   输入：nums = [1,5,2,4,1]
   输出：14

#一次通过，看着就是让人舒服，虽然复杂度挺...
class Solution(object):
    def minOperations(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        result = []
        i = 0
        while i < len(nums)-1:
            c = 0
            if nums[i] >= nums[i+1]:
                c = nums[i] - nums[i+1] + 1
                nums[i+1] +=  nums[i] - nums[i+1] + 1
                i +=1
                result.append(c) 
            else:
                i +=1
                result.append(c)
        return sum(result)

2022.09.07

给你一个数字数组 arr 。
如果一个数列中，任意相邻两项的差总等于同一个常数，那么这个数列就称为 等差数列 。
如果可以重新排列数组形成等差数列，请返回 true ；否则，返回 false 。
输入：arr = [3,5,1]
输出：true
解释：对数组重新排序得到 [1,3,5] 或者 [5,3,1] ，任意相邻两项的差分别为 2 或 -2 ，可以形成等差数列。

#仍然一次通过
class Solution(object):
    def canMakeArithmeticProgression(self, arr):
        """
        :type arr: List[int]
        :rtype: bool
        """
        a = sorted(arr)
        c = []
        for i in range(len(a)-1):
            b = a[i+1] - a[i]
            c.append(b)
        return len(set(c)) == 1

2022.09.08

给你一份旅游线路图，该线路图中的旅行线路用数组 paths 表示，其中 paths[i] = [cityAi, cityBi] 表示该线路将会从 cityAi 直接前往 cityBi 。请你找出这次旅行的终点站，即没有任何可以通往其他城市的线路的城市。
题目数据保证线路图会形成一条不存在循环的线路，因此恰有一个旅行终点站。
输入：paths = [[“London”,“New York”],[“New York”,“Lima”],[“Lima”,“Sao Paulo”]]
输出：“Sao Paulo”
解释：从 “London” 出发，最后抵达终点站 “Sao Paulo” 。本次旅行的路线是 “London” -> “New York” -> “Lima” -> “Sao Paulo” 。

#法一是看别人的代码写的，法二自己写的，时间复杂度太大了
#法一
class Solution(object):
    def destCity(self, paths):
        """
        :type paths: List[List[str]]
        :rtype: str
        """
        start_set = set()
        finish_set = set()
        for start, finish in paths:
            start_set.add(start)
            finish_set.add(finish)
        return list(finish_set - start_set)[0]
#法二
# result_num = []
# i = 0

# if len(paths) == 1:
#     result_num.append(paths[0][1])
# else:
#     while i < len(paths):
#         for j in range(len(paths)):
#             if i != j and paths[i][1] not in paths[j]:
#                 result_num.append(paths[i][1])
#         i +=1
    
# result = max(result_num,key=result_num.count)   

2022.09.09

给你一个二维整数数组 matrix， 返回 matrix 的 转置矩阵 矩阵的转置是指将矩阵的主对角线翻转，
交换矩阵的行索引与列索引。
输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
输出：[[1,4,7],[2,5,8],[3,6,9]]

#做LeetCode题已经五周了，一个月的时间学到了很多东西，但是未来的路还没有定，分叉口的选择，我总归是要去抉择的，
#那就按下暂停键，选择好道路以后，再收拾包袱继续出发！
class Solution(object):
    def transpose(self, matrix):
        """
        :type matrix: List[List[int]]
        :rtype: List[List[int]]
        """
        n = len(matrix)
        m = len(matrix[0])
        result = []
        for i in range(m):
            x = []
            for j in range(n):
                x.append(matrix[j][i])
            result.append(x)
        return result