leetcode-hot100-2021-08-19

1. 34. 在排序数组中查找元素的第一个和最后一个位置
2. 912. 排序数组
3. 345. 反转字符串中的元音字母
4. 541. 反转字符串 II

34. 在排序数组中查找元素的第一个和最后一个位置

双指针

class Solution:
    def searchRange(self, nums: List[int], target: int) -> List[int]:
        if len(nums) == 0:
            return [-1,-1]
        l, r = 0, len(nums)-1
        res = []
        while l<len(nums) and nums[l]<target:
            l+=1 # 左边界
        if l<len(nums) and nums[l] == target:
            res.append(l)
        else:
            res.append(-1)
        while r>=0 and nums[r]>target:
            r-=1
        if r>=0 and nums[r] == target:
            res.append(r)
        else:
            res.append(-1)
        return res

912. 排序数组

class Solution:
    def convert(self, s: str, numRows: int) -> str:
        n = len(s)
        if n <= numRows or numRows<2:
            return s
        i = 0
        flag = -1
        res = ['' for _ in range(numRows)]
        for c in s:
            res[i]+=c
            if i == 0 or i == numRows-1:
                flag = -flag
            i += flag
        return ''.join(res)

345. 反转字符串中的元音字母

class Solution:
    def reverseVowels(self, s: str) -> str:
        list1 = ['a','e','i','o','u','A','E','I','O','U']
        l,r = 0, len(s)-1
        s = list(s)
        while l<r:
            while l<len(s) and s[l] not in list1:
                l += 1
            while r>0 and s[r] not in list1:
                r-=1
            if l<r:
                s[l],s[r] = s[r],s[l]
                l+=1 # 千万不要忘记交换之后，更改指针的位置，否则会陷入死循环
                r-=1 # 千万不要忘记交换之后，更改指针的位置，否则会陷入死循环
        return ''.join(s)

541. 反转字符串 II

class Solution:
    def reverseStr(self, s: str, k: int) -> str:
        l, r =-1,-1
        s=list(s)
        while r<len(s):
            for i in range(k):
                l+=1
                r+=2
            if r<=len(s)-1:
                j = l-k+1
                while j<l:
                    s[j],s[l] = s[l],s[j]
                    l-=1
                    j+=1
            elif r>len(s)-1 and l>len(s)-1:
                l=l-k+1
                j = len(s)-1
                while l<j:
                    s[j],s[l] = s[l],s[j]
                    l+=1
                    j-=1
                return ''.join(s)
            elif r>len(s)-1 and l<=len(s)-1:
                j = l-k+1
                while j<l:
                    s[j],s[l] = s[l],s[j]
                    l-=1
                    j+=1
                return ''.join(s)
            l = r
            if l == len(s)-1:
                return ''.join(s)