我的 Leetcode 挑戰

def twoSum(self, nums, target):
    """
    :type nums: List[int]
    :type target: int
    :rtype: List[int]
    """
    for i, v in enumerate(nums):
        # get the remainder
        rem = target - v
        # mark the chosen number
        nums[i] = 'x'
        # get the index of the remainder
        if rem in nums:
            return [i, nums.index(rem)]

def numJewelsInStones(self, J: str, S: str):
    count = 0
    # count jewels
    for i in J:
        count += S.count(i)
    return count

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
def rangeSumBST(self, root: TreeNode, L: int, R: int):
    if not root:
        return 0
    elif root.val >= L and root.val <= R:
        return root.val + self.rangeSumBST(root.left, L, R) + self.rangeSumBST(root.right, L, R)
    elif root.val < L:
        return self.rangeSumBST(root.right, L, R)
    else:
        return self.rangeSumBST(root.left, L, R)

def removeOuterParentheses(self, S: str):
    count = shift = 0
    res = ''

    # calculate the range which will be saved
    for i, p in enumerate(S):
        if p == '(':
            count += 1
        else:
            count -= 1
        if count == 0:
            res += S[shift + 1: i]
            shift = i + 1
    return res

def toLowerCase(self, str: str):
    return str.lower()

def uniqueMorseRepresentations(self, words: List[str]):
    morse_code = [".-", "-...", "-.-.", "-..", ".", "..-.", "--.",
                  "....", "..", ".---", "-.-", ".-..", "--", "-.",
                  "---", ".--.", "--.-", ".-.", "...", "-", "..-",
                  "...-", ".--", "-..-", "-.--", "--.."]

    # make it unique
    res = {''.join([morse_code[ord(c) - ord('a')] for c in word]) for word in words}
    # print(res)
    return len(res)

def sortArrayByParity(self, A: List[int]):
    return sorted(A, key=lambda i: i % 2 == 0, reverse=True)

def repeatedNTimes(self, A: List[int]):
    d = {i: 0 for i in set(A)}
    for i in A:
        d[i] += 1

    d = sorted(d.items(), key=lambda kv: kv[1], reverse=True)

    reutur d[0][0]

def repeatedNTimes(self, A: List[int]) -> int:
    return collections.Counter(A).most_common(1)[0][0]

def repeatedNTimes(self, A: List[int]):
    for i in range(1, len(A)):
        for j in range(len(A) - i):
            if A[j] == A[j+i]:
                return A[j]

def flipAndInvertImage(self, A: List[List[int]]):
    # reverse list
    for byte in A:
        for bit in range(len(byte) // 2):
            byte[bit], byte[-1 - bit] = byte[-1 - bit], byte[bit]

    # invert list
    for byte in A:
        for bit in range(len(byte)):
            if byte[bit] == 0:
                byte[bit] = 1
            else:
                byte[bit] = 0
    return A

def flipAndInvertImage(self, A):
    for row in A:
        for i in range((len(row) + 1) // 2):
            """
            In Python, the shortcut row[~i] = row[-i-1] = row[len(row) - 1 - i]
            helps us find the i-th value of the row, counting from the right.
            """
            row[i], row[~i] = row[~i] ^ 1, row[i] ^ 1
    return A

def sortedSquares(self, A: List[int]):
    for i, v in enumerate(A):
        A[i] = v * v

    return sorted(A)

def numUniqueEmails(self, emails: List[str]):
    for i, v in enumerate(emails):
        # split email to local and domain name
        email = v.split('@')
        # remove '.' char
        local_name = email[0].replace('.', '')
        # ignore string  after '+' char
        if '+' in local_name:
        local_name = local_name[:local_name.index('+')]
        # reconstruct the email
        emails[i] = local_name + '@' + email[1]

    # make email list be unique
    return len(set(emails))

def judgeCircle(self, moves: str):
    return moves.count('U') == moves.count('D') and moves.count('R') == moves.count('L')

def hammingDistance(self, x: int, y: int):
    x = '{0:032b}'.format(x)
    y = '{0:032b}'.format(y)

    counter = 0
    for i in range(len(x)):
        if x[i] != y[i]:
            counter += 1
    return counter

def hammingDistance(self, x: int, y: int) -> int:
    # convert to bin format
    x = format(x, 'b')
    y = format(y, 'b')

    # unify length
    if len(x) > len(y):
        y = (str(0) * (len(x) - len(y))) + y
    else:
        x = (str(0) * (len(y) - len(x))) + x

    counter = 0
    for i in range(len(x)):
        if x[i] != y[i]:
            counter += 1

    return counter

def mergeTrees(self, t1: TreeNode, t2: TreeNode):
    if not (t1 and t2):
        return t1 or t2
    t1.val = t1.val + t2.val
    t1.left = self.mergeTrees(t1.left, t2.left)
    t1.right = self.mergeTrees(t1.right, t2.right)
    return t1

def selfDividingNumbers(self, left: int, right: int):
    res = []
    for i in range(left, right + 1):
        i_to_str = str(i)
        for c in i_to_str:
            if c == '0' or i % int(c) > 0:
            break
        else:
            res.append(i)
    return res

def selfDividingNumbers(self, left: int, right: int):
    res = []
    for i in range(left, right + 1):
        curr = i
        while curr:
            mod = curr % 10
            if mod == 0 or i % mod > 0:
                break
            if curr == mod:
                res.append(i)
            curr = curr // 10
    return res

def diStringMatch(self, S: str) -> List[int]:
    left = len(S)
    right = 0
    res = []
    for s in S:
        if s == 'I':
            res.append(right)
            right += 1
        else:
            res.append(left)
            left -= 1
    return res + [left]

def minDeletionSize(self, A: List[str]):
    count = 0
    for col in zip(*A):
        if list(col) != sorted(col):
        count += 1
    return count

def heightChecker(self, heights: List[int]):
    count = 0
    sorted_heights = sorted(heights)

    for i in range(len(heights)):
        if sorted_heights[i] != heights[i]:
            count += 1
    return count

class RecentCounter:
    def __init__(self):
        self.q = collections.deque()

    def ping(self, t):
        self.q.append(t)
        while and self.q[0] < t-3000:
            self.q.popleft()
        return len(self.q)

def arrayPairSum(self, nums: List[int]):
    sorted_nums = sorted(nums)

    sum = 0
    for i in range(1, len(sorted_nums), 2):
        sum += min(sorted_nums[i - 1], sorted_nums[i])

    return sum

def arrayPairSum(self, nums: List[int]):
    return sum(sorted(nums)[::2])

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    res = None
    def searchBST(self, root: TreeNode, val: int):
        if root == None:
            return

        if root.val == val:
            return root
        elif val < root.val:
            return self.searchBST(root.left, val)
        else:
            return self.searchBST(root.right, val)

def reverseString(self, s: List[str]):
    """
    Do not return anything, modify s in-place instead.
    """
    s = s.reverse()

def reverseString(self, s: List[str]):
    """
    Do not return anything, modify s in-place instead.
    """
    for i in range(len(s) // 2):
        s[i], s[~i] = s[~i], s[i]

def maxDepth(self, root: TreeNode):
    if not root:
        return 0
    else:
        return 1 + max(self.maxDepth(root.left), self.maxDepth(root.right))

def singleNumber(self, nums: List[int]):
    res = nums[0]

    for i in range(1, len(nums)):
        res = res ^ nums[i]

    return res

def fizzBuzz(self, n: int):
    res = []
    for i in range(1, n + 1):
        if i % 3 == 0 and i % 5 == 0:
            res.append('FizzBuzz')
        elif i % 3 == 0:
            res.append('Fizz')
        elif i % 5 == 0:
            res.append('Buzz')
        else:
            res.append(str(i))
    return res

def reverseList(self, head: ListNode):
    if not head or not head.next:
        return head
    p = self.reverseList(head.next)
    head.next.next = head
    head.next = None
    return p

def reverseList(self, head: ListNode):
    prev, curr = None, head
    while curr:
        curr.next, prev, curr = prev, curr, curr.next
    return prev

def moveZeroes(self, nums: List[int]):
    """
    Do not return anything, modify nums in-place instead.
    """
    for i in range(len(nums)):
        for j in range(i, len(nums)):
            if nums[i] == 0:
                nums[i], nums[j] = nums[j], nums[i]

def moveZeroes(self, nums: List[int]):
    """
    Do not return anything, modify nums in-place instead.
    """
    for i in range(len(nums) - 1, -1, -1):
        if nums[i] == 0:
            nums.append(nums.pop(i))

def moveZeroes(self, nums: List[int]):
    """
    Do not return anything, modify nums in-place instead.
    """
    j = -1
    for i in range(len(nums)):
        if nums[i] != 0:
            j += 1
            nums[i], nums[j] = nums[j], nums[i]

def deleteNode(self, node):
    """
    :type node: ListNode
    :rtype: void Do not return anything, modify node in-place instead.
    """
    if node:
        node.val = node.next.val
        node.next = node.next.next

def romanToInt(self, s: str) -> int:
    roman = {
        'I':  1,
        'V':  5,
        'X':  10,
        'L':  50,
        'C':  100,
        'D':  500,
        'M':  1000
    }

    sum = prev_num = 0
    for c in s:
        if roman[c] > prev_num:
            sum -= 2 * prev_num
        sum += roman[c]
        prev_num = roman[c]
    return sum

def isAnagram(self, s: str, t: str):
    return ''.join(sorted(s)) == ''.join(sorted(t))

class Solution:
    def isAnagram(self, s: str, t: str):
        return collections.Counter(s) == collections.Counter(t)

def containsDuplicate(self, nums: List[int]):
    return len(nums) > len(set(nums))

class Solution:
    MAX_POSITIVE =  (2 ** 31 ) - 1
    MAX_NEGATIVE = - (2 ** 31)

    def reverse(self, x):
        if x == 0:
            return x
        # reversed string of the number
        s = (str(abs(x))[::-1]).lstrip('0')
        # integerize
        i = int(s) if x > 0 else -(int(s))
        # check overflow
        if self.MAX_NEGATIVE <= i <= self.MAX_POSITIVE:
            return i
        return 0

class Solution:
    def isPalindrome(self, x: int) -> bool:
        s = str(x)
        for i in range(len(s) // 2):
            if s[i] != s[~i]:
                return False
        return True

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        profit = 0
        for i in range(len(prices) - 1):
            if prices[i + 1] > prices[i]:
                profit += prices[i + 1] - prices[i]
        return profit

class Solution:
    def longestCommonPrefix(self, strs: List[str]) -> str:
        if not strs:
            return ''
        result = ''
        for i, v in enumerate(strs[0]):
            result += v
            for s in strs[1:]:
                if not s.startswith(result):
                    return result[:i]
        return result

class Solution:
    def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
        if not nums:
            return
        index = len(nums) // 2
        node = TreeNode(nums[index])

        left = nums[:index]
        right = nums[index+1:]

        node.left = self.sortedArrayToBST(left)
        node.right = self.sortedArrayToBST(right)

        return node

class Solution:
    def titleToNumber(self, s: str) -> int:
        result = 0
        x = {chr(65 + i): i + 1 for i in range(26)}
        for i, v in enumerate(list(s)):
            result += (26 ** (len(s) - i - 1)) * x[v.upper()]
        return result

from collections import OrderedDict

class Solution:
    def firstUniqChar(self, s: str) -> int:
        result = -1
        words = OrderedDict()
        for c in (list(s)):
            if c not in words:
                words[c] = 1
            else:
                words[c] += 1

        for i, v in enumerate(words.items()):
            print(i, v)
            if v[1] == 1:
                result = s.index(v[0])
                break
        return result

class Solution:
    def firstUniqChar(self, s: str) -> int:
        # build hash map : character and how often it appears
        count = collections.Counter(s)

        # find the index
        for idx, ch in enumerate(s):
            if count[ch] == 1:
                return idx
        return -1

class Solution:
    def getSum(self, a: int, b: int) -> int:
        return sum([a,b])

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
        pre_head = ListNode(-1)
        curr = pre_head

        while l1 and l2:
            if l1.val<l2.val:
                curr.next = l1
                l1 = l1.next
            else:
                curr.next = l2
                l2 = l2.next
            curr = curr.next

        if l1: curr.next = l1
        if l2: curr.next = l2

        return pre_head.next

class Solution:
    def findNumbers(self, nums: List[int]) -> int:
        count = 0
        limitValue = 10 ** 5

        if 1 <= len(nums) <= 500:
            for i in nums:
                if i <= limitValue and len(str(i)) % 2 == 0:
                    count = count + 1
            return count
        else:
            raise