upload on 3/25

Author: gyb1325

201. Bitwise AND of Numbers Range.py

@@ -0,0 +1,9 @@
+class Solution:
+
+    def rangeBitwiseAnd(self, m: int, n: int) -> int:
+        step = 0
+        while m != n:
+            m >>= 1
+            n >>= 1
+            step += 1
+        return m << step

202. Happy Number.py

@@ -0,0 +1,12 @@
+class Solution:
+
+    def isHappy(self, n: int) -> bool:
+        if n == 1:
+            return True
+        mem = set()
+        while n != 1:
+            n = sum(int(i)**2 for i in str(n))
+            if n in mem:
+                return False
+            mem.add(n)
+        return True

203. Remove Linked List Elements.py

@@ -0,0 +1,23 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+
+class Solution:
+
+    def removeElements(self, head: ListNode, val: int) -> ListNode:
+        if not head:
+            return None
+        dummy = prev = ListNode(0)
+        dummy.next = head
+        cur = head
+        while cur:
+            if cur.val == val:
+                cur = cur.next
+                prev.next = cur
+            else:
+                cur = cur.next
+                prev = prev.next
+        return dummy.next

204. Count Primes.py

@@ -0,0 +1,13 @@
+class Solution:
+
+    def countPrimes(self, n: int) -> int:
+        notPrime = [False] * n
+        cnt = 0
+        for i in range(2, n):
+            if not notPrime[i]:
+                cnt += 1
+                j = 2
+                while j * i < n:
+                    notPrime[i * j] = True
+                    j += 1
+        return cnt

205. Isomorphic Strings.py

@@ -0,0 +1,23 @@
+class Solution:
+
+    def isIsomorphic(self, s: str, t: str) -> bool:
+        m = len(s)
+        n = len(t)
+        if m != n:
+            return False
+        dic1 = {}
+        dic2 = {}
+        for i in range(m):
+            if s[i] in dic1:
+                dic1[s[i]].append(i)
+            else:
+                dic1[s[i]] = [i]
+        for i in range(m):
+            if t[i] in dic2:
+                dic2[t[i]].append(i)
+            else:
+                dic2[t[i]] = [i]
+        for i in range(m):
+            if dic1[s[i]] != dic2[t[i]]:
+                return False
+        return True

206. Reverse Linked List.py

@@ -0,0 +1,15 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+
+class Solution:
+
+    def reverseList(self, head: ListNode) -> ListNode:
+        cur = head
+        prev = None
+        while cur:
+            cur.next, cur, prev = prev, cur.next, cur
+        return prev

76. Minimum Window Substring.py

@@ -0,0 +1,26 @@
+class Solution:
+
+    def minWindow(self, s: str, t: str) -> str:
+        dic = {}
+        for c in t:
+            dic[c] = dic.get(c, 0) + 1
+        start, end, head = 0, 0, 0
+        min_len = len(s) + 1
+        cnt = len(t)
+        while end < len(s):
+            if s[end] in dic:
+                if dic[s[end]] > 0:
+                    cnt -= 1
+                dic[s[end]] -= 1
+            end += 1
+
+            while cnt == 0:
+                if end - start < min_len:
+                    head = start
+                    min_len = end - start
+                if s[start] in dic:
+                    dic[s[start]] += 1
+                    if dic[s[start]] > 0:
+                        cnt += 1
+                start += 1
+        return s[head: head + min_len] if min_len < len(s) + 1 else ""

77. Combinations.py

@@ -0,0 +1,14 @@
+class Solution:
+
+    def combine(self, n: int, k: int) -> List[List[int]]:
+        res = []
+        lst = [i for i in range(1, n + 1)]
+        self.helper(lst, k, [], res)
+        return res
+
+    def helper(self, lst, k, path, res):
+        if k == 0:
+            res.append(path)
+        if lst:
+            for i in range(len(lst)):
+                self.helper(lst[i + 1:], k - 1, path + [lst[i]], res)

78. Subsets.py

@@ -0,0 +1,12 @@
+class Solution:
+
+    def subsets(self, nums: List[int]) -> List[List[int]]:
+        res = []
+        nums.sort()
+        self.helper(nums, 0, [], res)
+        return res
+
+    def helper(self, nums, index, path, res):
+        res.append(path)
+        for i in range(index, len(nums)):
+            self.helper(nums, i + 1, path + [nums[i]], res)

79. Word Search.py

@@ -0,0 +1,24 @@
+class Solution:
+
+    def exist(self, board: List[List[str]], word: str) -> bool:
+        m = len(board)
+        n = len(board[0])
+        for i in range(m):
+            for j in range(n):
+                if self.helper(board, i, j, word):
+                    return True
+        return False
+
+    def helper(self, board, i, j, word):
+        if not word:
+            return True
+
+        if i < 0 or j < 0 or i >= len(board) or j >= len(board[0]) or board[i][j] != word[0]:
+            return False
+        temp = board[i][j]
+        board[i][j] = "#"
+        flag = self.helper(board, i + 1, j, word[1:]) or self.helper(board, i - 1, j, word[1:]
+                                                                     ) or self.helper(board, i, j + 1, word[1:]) or self.helper(board, i, j - 1, word[1:])
+
+        board[i][j] = temp
+        return flag

80. Remove Duplicates from Sorted Array II.py

@@ -0,0 +1,13 @@
+class Solution:
+
+    def removeDuplicates(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: int
+        """
+        i = 0
+        for n in nums:
+            if i < 2 or n > nums[i - 2]:
+                nums[i] = n
+                i += 1
+        return i