python leetcode 1 - 10

# 1 哈希表(好像是这个名字吧 没学过数据结构的咸鱼)
class Solution:
     def twoSum(self,s,t):    
        dict1=dict()
        for i in range(len(s)):
            temp=t-s[i]
            if temp in dict1:
                return (dict1[temp],i)
            dict1[s[i]]=i
# 2
class Solution:
    def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
        dummy = p = ListNode(None)
        s = 0
        while l1 or l2 or s:
            s += (l1.val if l1 else 0) + (l2.val if l2 else 0)
            p.next = ListNode(s % 10)
            p = p.next
            s //= 10
            l1 = l1.next if l1 else None
            l2 = l2.next if l2 else None
        return dummy.next
# 3
class Solution:
    def lengthOfLongestSubstring(self, s: str) -> int:
        l = 0
        res = 0
        dic = {}
        for i in range(len(s)):
            if s[i] not in s[l : i]:
                dic[s[i]] = i
                res = max(i - l + 1 , res)
            else:
                l = dic[s[i]] + 1
                dic[s[i]] = i
        return res
# 4 不会用二分 = = 
nums1.extend(nums2)
        allnum = nums1
        allnum = sorted(allnum)
        n = len(allnum)
        if n % 2 == 0:
            result = (allnum[n//2-1]+allnum[n//2])/2
        else:
            result = allnum[n//2]
        return result
# 5 分别讨论i , i + 1的回文情况
class Solution:
    def longestPalindrome(self, s: str) -> str:
        if not s: 
            return ''
        if len(s) == 1 or s == s[::-1]:
            return s
        res_len = 0
        for i in range(len(s)):
            l , r = i , i
            while l >= 0 and r <= len(s) - 1 and s[l] == s[r]:
                if res_len < r - l + 1:
                    res_len = r - l + 1
                    res = s[l : r + 1]
                l -= 1
                r += 1
            l , r = i , i + 1
            while l >= 0 and r <= len(s) - 1 and s[l] == s[r]:
                if res_len < r - l + 1:
                    res_len = r - l + 1
                    res = s[l : r + 1]
                l -= 1
                r += 1
        return res
# 6 硬着来
class Solution:
    def convert(self, s: str, numRows: int) -> str:
        if numRows <= 1:
            return s
        record = [[0] * len(s) for _ in range(numRows)]
        state = 'down'
        x , y = 0 , 0
        res = ''
        for i , j in enumerate(s):
            record[x][y] = j
            if state == 'down':
                if x != numRows - 1:
                    x += 1
                else:
                    state = 'up'
                    x -= 1
                    y += 1
            else:
                if x != 0:
                    x -= 1
                    y += 1
                else:
                    state = 'down'
                    x += 1
        for i in range(len(record)):
            for j in range(len(record[0])):
                if record[i][j] != 0:
                    res += record[i][j]
        return res
#不过居然才超过5% 还是重新写一种把...
class Solution:
    def convert(self, s: str, numRows: int) -> str:
        if numRows <= 1:
            return s
        j , flag = 0 , -1 
        res = [''] * numRows
        for i in s:
            if j == numRows - 1 or j == 0:
                flag = -flag
            res[j] += i
            j += flag
        return ''.join(res)

# 7 (也可以转成str然后str[::-1]在转成int)
class Solution:
    def reverse(self, x: int) -> int:
        flag = False
        if x < 0:
            flag = True
        res = 0
        x = abs(x)
        while x:
            x , y = divmod(x , 10)
            res =  (res * 10 + y)
        if res > 2 ** 31:
            return 0
        if flag:
            res = res * (-1)
        return res

# 8 正则表达式赛高！！！虽然不可能想到
class Solution:
    def myAtoi(self, s: str) -> int:
        return max(min(int(*re.findall('^[\+\-]?\d+', s.lstrip())), 2**31 - 1), -2**31)


# 9
class Solution:
    def isPalindrome(self, x: int) -> bool:
        if x < 0:
            return False
        str1 = str(x)
        if str1[::-1] == str1:
            return True
        else:
            return False

# 10 动态规划 永远的神 (抄的官方)
def isMatch(self, s: str, p: str) -> bool:
        m, n = len(s), len(p)

        def matches(i: int, j: int) -> bool:
            if i == 0:
                return False
            if p[j - 1] == '.':
                return True
            return s[i - 1] == p[j - 1]

        f = [[False] * (n + 1) for _ in range(m + 1)]
        f[0][0] = True
        for i in range(m + 1):
            for j in range(1, n + 1):
                if p[j - 1] == '*':
                    f[i][j] |= f[i][j - 2]
                    if matches(i, j - 1):
                        f[i][j] |= f[i - 1][j]
                else:
                    if matches(i, j):
                        f[i][j] |= f[i - 1][j - 1]
        return f[m][n]

# 咸鱼皓出版 转载请注明