[20220830] solve the problems

Author: iamminji

common/leetcodeds.py

@@ -9,3 +9,9 @@ def __init__(self, x):
         self.val = x
         self.left = None
         self.right = None
+
+
+class Node:
+    def __init__(self, val=None, children=None):
+        self.val = val
+        self.children = children

study-plan/leetcode-75/day3-reverse-linked-list.py

@@ -2,16 +2,7 @@
 # 206. Reverse Linked List
 
 from typing import Optional
-
-
-# Definition for singly-linked list.
-class ListNode:
-    def __init__(self, val=0, next=None):
-        self.val = val
-        self.next = next
-
-    def __str__(self) -> str:
-        return str(self.val)
+from common.leetcodeds import ListNode
 
 
 class Solution:
@@ -34,8 +25,16 @@ def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
         return dummy.next
 
     def reverseList_2(self, head: Optional[ListNode]) -> Optional[ListNode]:
-        # TODO stack 사용 없이 풀어보기
-        pass
+        if head is None:
+            return None
+
+        prev, cur = None, head
+        while head is not None:
+            head = head.next
+            cur.next = prev
+            prev = cur
+            cur = head
+        return prev
 
 
 if __name__ == '__main__':

study-plan/leetcode-75/day5-best-time-to-buy-and-sell-stock.py

@@ -0,0 +1,19 @@
+# https://leetcode.com/problems/best-time-to-buy-and-sell-stock/
+# 121. Best Time to Buy and Sell Stock
+from typing import List
+
+
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+        cur = prices[0]
+        result = 0
+        for i in range(1, len(prices)):
+            result = max(prices[i] - cur, result)
+            cur = min(prices[i], cur)
+
+        return result
+
+
+if __name__ == '__main__':
+    sol = Solution()
+    print(sol.maxProfit([7, 1, 5, 3, 6, 4]))

study-plan/leetcode-75/day5-longest-palindrome.py

@@ -0,0 +1,30 @@
+# https://leetcode.com/problems/longest-palindrome/
+# 409. Longest Palindrome
+
+from collections import Counter
+
+
+class Solution:
+    def longestPalindrome(self, s: str) -> int:
+        counter = Counter(s)
+
+        result = 0
+        for k, v in counter.items():
+            if v % 2 == 0:
+                result += v
+                counter[k] = 0
+            elif v % 2 != 0 and v >= 2:
+                result += v - 1
+                counter[k] -= 1
+
+        for k, v in counter.items():
+            if v > 0:
+                result += 1
+                break
+        return result
+
+
+if __name__ == '__main__':
+    sol = Solution()
+    print(sol.longestPalindrome("abccccdd"))
+    print(sol.longestPalindrome("a"))

study-plan/leetcode-75/day6-binary-tree-level-order-traversal.py

@@ -0,0 +1,39 @@
+# https://leetcode.com/problems/binary-tree-level-order-traversal/
+# 102. Binary Tree Level Order Traversal
+from typing import Optional, List
+from common.leetcodeds import TreeNode
+
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+
+from collections import deque
+
+
+class Solution:
+    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
+        result = []
+        if root is None:
+            return result
+
+        queue = deque()
+        queue.append((0, root))
+        length = -1
+
+        while queue:
+            depth, node = queue.popleft()
+
+            if length != depth:
+                length += 1
+                result.append([])
+            result[depth].append(node.val)
+
+            if node.left is not None:
+                queue.append((depth + 1, node.left))
+            if node.right is not None:
+                queue.append((depth + 1, node.right))
+
+        return result

study-plan/leetcode-75/day6-n-ary-tree-preorder-traversal.py

@@ -0,0 +1,30 @@
+# https://leetcode.com/problems/n-ary-tree-preorder-traversal/
+# 589. N-ary Tree Preorder Traversal
+
+from typing import List
+from common.leetcodeds import Node
+
+
+class Solution:
+    def dfs(self, node, result):
+
+        if node is None:
+            return
+
+        result.append(node.val)
+
+        if node.children is None:
+            return
+
+        for child in node.children:
+            self.dfs(child, result)
+
+    # TODO iteration 으로도 풀기
+    def preorder(self, root: 'Node') -> List[int]:
+        if root is None:
+            return []
+
+        result = [root.val]
+        for node in root.children:
+            self.dfs(node, result)
+        return result

study-plan/leetcode-75/day7-binary-search.py

@@ -0,0 +1,27 @@
+# https://leetcode.com/problems/binary-search/
+# 704. Binary Search
+from typing import List
+
+
+class Solution:
+    def search(self, nums: List[int], target: int) -> int:
+        result = -1
+
+        left, right = 0, len(nums) - 1
+
+        while left <= right:
+            mid = (left + right) // 2
+            if nums[mid] < target:
+                left += 1
+            elif nums[mid] > target:
+                right -= 1
+            else:
+                return mid
+
+        return result
+
+
+if __name__ == '__main__':
+    sol = Solution()
+    print(sol.search([-1, 0, 3, 5, 9, 12], 9))
+    print(sol.search([-1, 0, 3, 5, 9, 12], 2))

study-plan/leetcode-75/day7-first-bad-version.py

@@ -0,0 +1,24 @@
+# https://leetcode.com/problems/first-bad-version/
+# 278. First Bad Version
+
+# The isBadVersion API is already defined for you.
+def isBadVersion(version: int) -> bool:
+    return version == 1702766719
+
+
+class Solution:
+    def firstBadVersion(self, n: int) -> int:
+        left, right = 1, n
+        while left <= right:
+            mid = (left + right) // 2
+            if not isBadVersion(mid):
+                left = mid + 1
+            else:
+                right = mid - 1
+
+        return left
+
+
+if __name__ == '__main__':
+    sol = Solution()
+    print(sol.firstBadVersion(2126753390))