python leetcode 11 - 20

# 11 双指针 (暴力n^2会超时 我就知道事情不会这么简单)
class Solution:
    def maxArea(self, height: List[int]) -> int:
        l , r = 0 , len(height) - 1
        res = 0
        while l < r:
            res = max(res , min(height[l] , height[r]) * (r - l))
            if height[l] < height[r]:
                l += 1
            else:
                r -= 1
        return res

# 12
class Solution:
    def intToRoman(self, num: int) -> str:
        l = [("M",1000), ("CM",900), ("D",500), ("CD",400),
         ("C",100), ("XC",90), ("L",50), ("XL",40), ("X",10),
             ("IX",9), ("V",5), ("IV",4), ("I",1)]
        res = ''
        while num:
            for i , j in l:
                if num >= j:
                    res += i
                    num -= j
                    break     
        return res

# 13
class Solution:
    def romanToInt(self, s: str) -> int:
        a = {'I':1, 'V':5, 'X':10, 'L':50, 'C':100, 'D':500, 'M':1000}
        res = 0
        for i in range(len(s)):
            if i < len(s) - 1 and a[s[i]] < a[s[i + 1]]:
                res -= a[s[i]]
            else:
                res += a[s[i]]
        return res

# 14 (就这破玩意还整个空集当测试集你在搞笑吗)
class Solution:
    def longestCommonPrefix(self, strs: List[str]) -> str:
        if not strs:
            return ''
        res = ''
        strs = sorted(strs)
        l = min(len(strs[0]) , len(strs[-1]))
        for i in range(l):
            if strs[0][i] == strs[-1][i]:
                res += strs[0][i]
            else:
                break
        return res

# 15 (又是5%....)
class Solution:
    def threeSum(self, nums: List[int]) -> List[List[int]]:
        if len(nums) < 3:
            return []
        res = []
        nums = sorted(nums)
        for i in range(len(nums) - 2):
            l , r = i + 1 , len(nums) - 1
            while l < r:
                if nums[i] + nums[l] + nums[r] == 0:
                    if [nums[i] , nums[l] , nums[r]] not in res:
                        res.append([nums[i] , nums[l] , nums[r]])
                    l += 1
                elif nums[i] + nums[l] + nums[r] < 0:
                    l += 1
                else:
                    r -= 1
        return res

class Solution:
    def threeSum(self, nums: List[int]) -> List[List[int]]:
        res = []
        nums.sort()
        n = len(nums)
        if n < 3:
            return []
        for i in range(n):
            if nums[i] > 0:
                break
            if i > 0 and i < n and nums[i] == nums[i-1]:
                continue
            j = i + 1
            k = n - 1
            while j < k:
                s = nums[i] + nums[j] + nums[k]
                if s == 0:
                    res.append([nums[i], nums[j], nums[k]])
                    while j < k and (nums[j] == nums[j + 1]):
                        j += 1
                    while j < k and (nums[k] == nums[k - 1]):
                        k -= 1
                    j += 1
                elif s < 0:
                    j += 1
                elif s > 0:
                    k -= 1
        return res

# 16 (跟上面一样双指针就行)
class Solution:
    def threeSumClosest(self, nums: List[int], target: int) -> int:
        nums = sorted(nums)
        print(nums)
        res = float('inf')
        for i in range(len(nums) - 2):
            l , r = i + 1 , len(nums) - 1
            while l < r:
                if abs(nums[i] + nums[l] + nums[r] - target) < abs(target - res):
                    res = nums[i] + nums[l] + nums[r]
                if nums[i] + nums[l] + nums[r] == target:
                    return target
                elif nums[i] + nums[l] + nums[r] < target:
                    l += 1    
                else:
                    r -= 1
        return res

# 17
class Solution:
    def letterCombinations(self, digits: str) -> List[str]:
        mapping = {2:"abc", 3:"def", 4:"ghi", 5:"jkl", 6:"mno", 7:"pqrs", 8:"tuv", 9:"wxyz"}
        res = []
        for digit in digits:
            tmp = []
            n = int(digit)
            for i in mapping[n]:
                if not res:
                    tmp.append(i)
                else:
                    for j in res:
                        tmp.append(j + i)
            res = tmp 
        return res

# 18 类似15题
class Solution:
    def fourSum(self, nums: List[int], target: int) -> List[List[int]]:
        res = []
        if not nums or len(nums) < 4:
            return res
        nums.sort()
        length = len(nums)
        for i in range(length - 3):
            if i > 0 and nums[i] == nums[i-1]:
                continue
            if nums[i] + nums[i+1] + nums[i + 2] + nums[i + 3] > target:
                break
            if nums[i] + nums[length - 3] + nums[length - 2] + nums[length - 1] < target:
                continue
            for j in range(i + 1,length - 2):
                if j > i + 1 and nums[j] == nums[j-1]:
                    continue
                if nums[i] + nums[j] + nums[j + 1]+nums[j + 2] > target:
                    break
                if nums[i] + nums[j] + nums[length - 2]+nums[length - 1] < target:
                    continue
                l , r = j + 1,length - 1
                while l < r:
                    total = nums[i] + nums[j] + nums[l] + nums[r]
                    if total == target:
                        res.append([nums[i],nums[j],nums[l] ,nums[r]])
                        while l < r and nums[l]==nums[l+1]:
                            l +=1
                        l +=1
                        while l < r and nums[r] == nums[r - 1]:
                            r -=1
                        r -=1
                    elif total < target:
                        l +=1
                    else:
                        r -=1
        return res

# 19
class Solution:
    def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
        def getLength(head: ListNode) -> int:
            length = 0
            while head:
                length += 1
                head = head.next
            return length
        
        dummy = ListNode(0, head)
        length = getLength(head)
        cur = dummy
        for i in range(1, length - n + 1):
            cur = cur.next
        cur.next = cur.next.next
        return dummy.next

# 20
class Solution:
    def isValid(self, s: str) -> bool:
        mapping = {')':'(','}':'{',']':'['}
        stack = []
        for i in s:
            if i not in mapping:
                stack.append(i)
            else:
                if stack and stack[-1] == mapping[i]:
                    stack.pop()
                else:
                    return False
        if len(stack) == 0:
            return True
        else:
            return False

# 咸鱼皓出版 转载请注明