LeetCode记录7（题目+答案+注释） 语言：python

1、长度为三且各字符不同的子字符串

如果一个字符串不含有任何重复字符，我们称这个字符串为 好 字符串。

给你一个字符串 s ，请你返回 s 中长度为 3 的 好子字符串 的数量。

注意，如果相同的好子字符串出现多次，每一次都应该被记入答案之中。

子字符串 是一个字符串中连续的字符序列。

示例 1：

输入：s = "xyzzaz"
输出：1
解释：总共有 4 个长度为 3 的子字符串："xyz"，"yzz"，"zza" 和 "zaz" 。
唯一的长度为 3 的好子字符串是 "xyz" 。
示例 2：

输入：s = "aababcabc"
输出：4
解释：总共有 7 个长度为 3 的子字符串："aab"，"aba"，"bab"，"abc"，"bca"，"cab" 和 "abc" 。
好子字符串包括 "abc"，"bca"，"cab" 和 "abc" 。

解答：

class Solution:
    def countGoodSubstrings(self, s: str) -> int:
        n=len(s)
        count=0
        for i in range(n-2):
            if(s[i]!=s[i+1] and s[i+1]!=s[i+2] and s[i]!=s[i+2]):
                count+=1
        return count

2、执行操作后的变量值

存在一种仅支持 4 种操作和 1 个变量 X 的编程语言：

++X 和 X++ 使变量 X 的值 加 1
--X 和 X-- 使变量 X 的值 减 1
最初，X 的值是 0

给你一个字符串数组 operations ，这是由操作组成的一个列表，返回执行所有操作后， X 的 最终值 。

示例 1：

输入：operations = ["--X","X++","X++"]
输出：1
解释：操作按下述步骤执行：
最初，X = 0
--X：X 减 1 ，X =  0 - 1 = -1
X++：X 加 1 ，X = -1 + 1 =  0
X++：X 加 1 ，X =  0 + 1 =  1
示例 2：

输入：operations = ["++X","++X","X++"]
输出：3
解释：操作按下述步骤执行： 
最初，X = 0
++X：X 加 1 ，X = 0 + 1 = 1
++X：X 加 1 ，X = 1 + 1 = 2
X++：X 加 1 ，X = 2 + 1 = 3
示例 3：

输入：operations = ["X++","++X","--X","X--"]
输出：0
解释：操作按下述步骤执行：
最初，X = 0
X++：X 加 1 ，X = 0 + 1 = 1
++X：X 加 1 ，X = 1 + 1 = 2
--X：X 减 1 ，X = 2 - 1 = 1
X--：X 减 1 ，X = 1 - 1 = 0

解答：

class Solution:
    def finalValueAfterOperations(self, operations: List[str]) -> int:
        p=operations.count("++X")+operations.count("X++")
        m=operations.count("--X")+operations.count("X--")
        return p-m

3、至少是其他数字两倍的最大数

给你一个整数数组 nums ，其中总是存在 唯一的 一个最大整数 。

请你找出数组中的最大元素并检查它是否 至少是数组中每个其他数字的两倍 。如果是，则返回 最大元素的下标 ，否则返回 -1 。

示例 1：

输入：nums = [3,6,1,0]
输出：1
解释：6 是最大的整数，对于数组中的其他整数，6 至少是数组中其他元素的两倍。6 的下标是 1 ，所以返回 1 。
示例 2：

输入：nums = [1,2,3,4]
输出：-1
解释：4 没有超过 3 的两倍大，所以返回 -1 。
示例 3：

输入：nums = [1]
输出：0
解释：因为不存在其他数字，所以认为现有数字 1 至少是其他数字的两倍。

解答：

class Solution:
    def dominantIndex(self, nums: List[int]) -> int:
        if(len(nums)==1):
            return 0
        arr=[[i,nums[i]]for i in range(len(nums))]
        arr.sort(key=lambda x:-x[1])
        return arr[0][0] if (arr[0][1]>=arr[1][1]*2) else -1

4、寻找旋转排序数组中的最小值

已知一个长度为 n 的数组，预先按照升序排列，经由 1 到 n 次 旋转 后，得到输入数组。例如，原数组 nums = [0,1,2,4,5,6,7] 在变化后可能得到：
若旋转 4 次，则可以得到 [4,5,6,7,0,1,2]
若旋转 7 次，则可以得到 [0,1,2,4,5,6,7]
注意，数组 [a[0], a[1], a[2], ..., a[n-1]] 旋转一次 的结果为数组 [a[n-1], a[0], a[1], a[2], ..., a[n-2]] 。

给你一个元素值 互不相同 的数组 nums ，它原来是一个升序排列的数组，并按上述情形进行了多次旋转。请你找出并返回数组中的 最小元素 。

你必须设计一个时间复杂度为 O(log n) 的算法解决此问题。

参考答案：

示例 1：

输入：nums = [3,4,5,1,2]
输出：1
解释：原数组为 [1,2,3,4,5] ，旋转 3 次得到输入数组。
示例 2：

输入：nums = [4,5,6,7,0,1,2]
输出：0
解释：原数组为 [0,1,2,4,5,6,7] ，旋转 4 次得到输入数组。
示例 3：

输入：nums = [11,13,15,17]
输出：11
解释：原数组为 [11,13,15,17] ，旋转 4 次得到输入数组。

参考答案：

class Solution:
    def findMin(self, nums: List[int]) -> int:
        low,high=0,len(nums)-1
        while(low<high):
            mid=low+(high-low)//2
            if(nums[mid]<nums[high]):
                high=mid
            else:
                low=mid+1
        return nums[low]

5、一次编辑

字符串有三种编辑操作:插入一个字符、删除一个字符或者替换一个字符。 给定两个字符串，编写一个函数判定它们是否只需要一次(或者零次)编辑。

示例 1:

输入: 
first = "pale"
second = "ple"
输出: True
 

示例 2:

输入: 
first = "pales"
second = "pal"
输出: False

解答：

class Solution:
    def oneEditAway(self, first: str, second: str) -> bool:
        if(abs(len(first)-len(second))>=2):
            return False
        if(max(len(first),len(second))<=1):
            return True
        for i in range(min(len(first),len(second))):
            if(first[i]!=second[i]):
                if(len(first)>len(second)):
                    if(i==0):
                        return second[::-1]==first[:i:-1]
                    else:
                        return second[:i]==first[:i] and second[:i-1:-1]==first[:i:-1]
                elif(len(first)<len(second)):
                    if(i==0):
                        return second[:i:-1]==first[::-1]
                    else:
                        return second[:i]==first[:i] and second[:i:-1]==first[:i-1:-1]
                else:
                    return second[:i]==first[:i] and second[:i:-1]==first[:i:-1]
            
        return True

参考答案：

class Solution:
    def oneEditAway(self, first: str, second: str) -> bool:
        if abs(len(first)-len(second)) > 1: return False
        if len(first) > len(second): first,second = second,first
        for i in range(len(first)):
            if first[i] == second[i]: continue
            return first[i:] == second[i + 1:] or first[i+1:] == second[i+1:]
        return True