python leetcode 151-160

# 151
class Solution:
    def reverseWords(self, s: str) -> str:
        return ' '.join(s.split()[::-1])

# 152
class Solution:
    def maxProduct(self, nums: List[int]) -> int:
        reverse_nums = nums[::-1]
        for i in range(1 , len(nums)):
            nums[i] *= nums[i - 1] or 1
            reverse_nums[i] *= reverse_nums[i - 1] or 1
        return max(nums + reverse_nums)

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

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

# 155
class MinStack:
    def __init__(self):
        self.stack = []
        self.min_stack = [math.inf]

    def push(self, x: int) -> None:
        self.stack.append(x)
        self.min_stack.append(min(x, self.min_stack[-1]))

    def pop(self) -> None:
        self.stack.pop()
        self.min_stack.pop()

    def top(self) -> int:
        return self.stack[-1]

    def getMin(self) -> int:
        return self.min_stack[-1]

# 156
class Solution:
    def upsideDownBinaryTree(self, root: TreeNode) -> TreeNode:
        parent = parent_right = None
        while root:
            root_left = root.left
            root.left = parent_right
            parent_right = root.right
            root.right = parent
            parent = root
            root = root_left
        return parent

# 159
class Solution:
    def lengthOfLongestSubstringTwoDistinct(self, s: str) -> int:
        from collections import defaultdict
        l , r = 0 , 0
        n = len(s)
        max_len = 0
        hashmap = defaultdict()
        while r < n:
            if len(hashmap) < 3:
                hashmap[s[r]] = r
                r += 1
            if len(hashmap) == 3:
                del_idx = min(hashmap.values())
                del hashmap[s[del_idx]]
                l = del_idx + 1
            max_len = max(max_len, r - l)
        return max_len

# 160
class Solution:
    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
            if not headA or not headB: return
            pa, pb =headA, headB
            while pa!=pb:
                if pa:
                    pa = pa.next
                else:
                    pa = headB
                if pb:
                    pb = pb.next
                else:
                    pb = headA
            return pa