leetcode-字符串（二）

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

class Solution:
    def reverseVowels(self, s: str) -> str:
        rev = ['a','e','i','o','u','A','E','I','O','U']
        res = [i for i in s if i in rev]                      
        return ''.join([i if i not in rev else res.pop() for i in s])

415. 字符串相加

class Solution:
    def addStrings(self, num1: str, num2: str) -> str:
        

        num1 = num1[::-1]
        num2 = num2[::-1]
        length = max(len(num1), len(num2))
        val = 0
        for i in range(length):
            a = ord(num1[i]) - ord('0') if i < len(num1) else 0
            b = ord(num2[i]) - ord('0') if i < len(num2) else 0
            c = ((a + b)//10) * (10**(i + 1))
            d = ((a + b)%10) * (10**i)
            val += c
            val += d
        return str(val)

1071. 字符串的最大公因子

class Solution:
    def gcdOfStrings(self, str1: str, str2: str) -> str:
        if str1 + str2 != str2 + str1:return ""
        n1 = len(str1)
        n2 = len(str2)     
        
        def gbc(a, b):
            r = 1
            while r:
                r = a % b
                a = b 
                b = r
            return a
            
        return str2[:gbc(n1, n2)]

925. 长按键入

class Solution:
    def isLongPressedName(self, name: str, typed: str) -> bool:
        if set(name) != set(typed):
            return False

        pre1, cur1, pre2, cur2, cnt1, cnt2 = 0, 0, 0, 0, 0, 0
        while cur1 < len(name):
            while cur1 < len(name) and name[cur1] == name[pre1]:
                cur1 += 1
                cnt1 += 1
            while cur2 < len(typed) and typed[cur2] == typed[pre2]:
                cur2 += 1
                cnt2 += 1  
            if pre1 == len(name) - 1 and pre2 > len(typed) - 1:
                return False            
            if name[pre1] != typed[pre2]:
                return False
            if cnt1 > cnt2:
                return False
            pre1 = cur1
            pre2 = cur2
            cnt1 = 0
            cnt2 = 0
        return True

459. 重复的子字符串

class Solution:
    def repeatedSubstringPattern(self, s: str) -> bool:
        for i in range(1, len(s)// 2 + 1):
            n = len(s)//len(s[:i])
            if s[:i] * n == s:
                return True
        return False

125. 验证回文串

class Solution:
    def isPalindrome(self, s: str) -> bool:
        a = [i.lower() for i in s if i.isalnum()]
        return a == a[::-1]

387. 字符串中的第一个唯一字符

• 由列表的value_couonts()生成字典
• 1：Counter()
• 2：count()方法

dic = {c:s.count(c) for c in set(s)}

class Solution:
    def firstUniqChar(self, s: str) -> int:  
        from collections import Counter
        dic = Counter(s)
        res = [k for k, v in dic.items() if v == 1]
        for i in s:
            if i in res: 
                return s.index(i)
        return -1

class Solution:
    def firstUniqChar(self, s: str) -> int: 
        dic = {c: s.count(c) for c in set(s)}
        for i, c in enumerate(s):
            if dic[c] == 1:
                return i
        return -1

28. 实现 strStr()

class Solution:
    def strStr(self, haystack: str, needle: str) -> int:
        if needle not in haystack or needle == None:
            return -1
        return haystack.index(needle)

819. 最常见的单词

class Solution:
    def mostCommonWord(self, paragraph: str, banned: List[str]) -> str:
        for i in ["!","'",",",".","?",";"]:
            paragraph = paragraph.replace(i,' ')
        s = paragraph.lower()    
        dic = {c:s.split().count(c) for c in s.split() if c not in banned}
        # n = max(dic.values())
        # for k, v in dic.items():
        #     if v == n:
        #         return k
        return sorted(dic.items(), key=lambda x:x[1], reverse=1)[0][0]

14. 最长公共前缀

class Solution:
    def longestCommonPrefix(self, strs: List[str]) -> str:
        if not strs:
            return ''
        s1 = min(strs)
        s2 = max(strs)
        for index, x in enumerate(s1):
            if x != s2[index]:
                return s1[:index]
        return s1

680. 验证回文字符串 Ⅱ

class Solution:
    def validPalindrome(self, s: str) -> bool:
        if s == s[::-1]:
            return True
        l,r = 0, len(s) - 1
        while l < r:
            if s[l] == s[r]:
                l,r = l + 1, r - 1
            else:
                a = s[l:r]
                b = s[l+1:r+1]
                return a == a[::-1] or b == b[::-1]

434. 字符串中的单词数

• split()当不带参数时以空格进行分割，当代参数时，以该参数进行分割。这里的空格指的是一个或者多个空格。

class Solution:
    def countSegments(self, s: str) -> int:
        return len(s.split())

686. 重复叠加字符串匹配

class Solution:
    def repeatedStringMatch(self, A: str, B: str) -> int:
        if len(A) <= len(B):
            n = len(B)//len(A)
            if B in A * n:
                return n
            elif B in A * (n + 1):
                return n + 1
            elif B in A * (n + 2):
                return n + 2
            else: 
                pass
        else:
            if B in A:
                return 1
            elif B in A * 2:
                    return 2
            else:
                pass
        return -1

58. 最后一个单词的长度

class Solution:
    def lengthOfLastWord(self, s: str) -> int:
        return len(s.rstrip().split(" ")[-1])

859. 亲密字符串

class Solution:
    def buddyStrings(self, A: str, B: str) -> bool:
        a = list(A)
        b = list(B)
        if set(a) != set(b):
            return False
        if a == b:
            if len(a) > len(set(a)):
                return True            
        res = []
        for k, v in enumerate(a):
            if v != b[k]:
                res.append(k)
        if len(res) != 2: 
            return False 
        a[res[0]], a[res[1]] = a[res[1]], a[res[0]]         
        return a == b

905. 按奇偶排序数组

class Solution:
    def sortArrayByParity(self, A: List[int]) -> List[int]:      
        return sorted(A, key = lambda x:x%2 == 1)

561. 数组拆分 I

class Solution:
    def arrayPairSum(self, nums: List[int]) -> int:
        nums.sort()
        return sum(nums[::2])

509. 斐波那契数

class Solution:
    def fib(self, N: int) -> int:
        res = [0 for i in range(N + 1)]
        if N == 0:
            return 0
        if N == 1:
            return 1
        res[0], res[1] = 0, 1
        for i in range(2, N + 1):
            res[i] = res[i - 1] + res[i - 2]
        return res[-1]

867. 转置矩阵

class Solution:
    def transpose(self, A: List[List[int]]) -> List[List[int]]:
        return zip(*A)