Merge pull request #2306 from 8804who/main

[8804who] WEEK 12 solutions

Author: 8804who

non-overlapping-intervals/8804who.py

@@ -0,0 +1,13 @@
+class Solution:
+    def eraseOverlapIntervals(self, intervals: List[List[int]]) -> int:
+        answer, end = 0, -inf
+        intervals.sort(key = lambda x:x[1])
+
+        for i_s, i_e in intervals:
+            if end <= i_s:
+                end = i_e
+            else:
+                answer += 1
+            
+        return answer
+    

remove-nth-node-from-end-of-list/8804who.py

@@ -0,0 +1,32 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution:
+    def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]:
+        if not head:
+            return None
+
+        temp = head
+        length = 0
+
+        while temp:
+            length += 1
+            temp = temp.next
+        
+        return self.removeNth(head, length-n+1)
+
+    def removeNth(self, head, n):
+        if n == 1:
+            if not head.next:
+                return None
+            else:
+                return head.next
+        else:
+            if not head.next:
+                return head
+            head.next = self.removeNth(head.next, n-1)
+            return head
+        
+    

same-tree/8804who.py

@@ -0,0 +1,33 @@
+# 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
+class Solution:
+    def isSameTree(self, p: Optional[TreeNode], q: Optional[TreeNode]) -> bool:
+        return self.searchTree(p, q)
+
+    def searchTree(self, node1, node2):
+        if (not node1 and node2) or (node1 and not node2):
+            return False
+        elif not node1 and not node2:
+            return True
+        elif node1.val != node2.val:
+            return False
+        
+        if node1.left and node2.left:
+            left = self.searchTree(node1.left, node2.left)
+        elif not node1.left and not node2.left:
+            left = True
+        else:
+            return False
+
+        if node1.right and node2.right:
+            right = self.searchTree(node1.right, node2.right)
+        elif not node1.right and not node2.right:
+            right = True
+        else:
+            return False
+        return left and right
+    

serialize-and-deserialize-binary-tree/8804who.py

@@ -0,0 +1,68 @@
+from collections import deque
+
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Codec:
+
+    def serialize(self, root):
+        """Encodes a tree to a single string.
+        
+        :type root: TreeNode
+        :rtype: str
+        """
+        if not root:
+            return ''
+        nodes = []
+        
+        q = deque([[root, 1]])
+
+        while q:
+            node, idx = q.popleft()
+            if not node:
+                continue
+            nodes.append(str(idx)+":"+str(node.val))
+            q.append([node.left, idx*2])
+            q.append([node.right, idx*2+1])
+        
+        return '/'.join(nodes)
+
+
+
+    def deserialize(self, data):
+        """Decodes your encoded data to tree.
+        
+        :type data: str
+        :rtype: TreeNode
+        """
+        if data == '':
+            return None
+
+        data = data.split('/')
+
+        node_dict = {}
+
+        for chunk in data:
+            idx, val = chunk.split(':')
+            node_dict[int(idx)] = val
+
+        def dfs(idx):
+            if idx in node_dict:
+                node = TreeNode(int(node_dict[idx]))
+                node.left = dfs(idx*2)
+                node.right = dfs(idx*2+1)
+                return node
+            else:
+                return None
+
+        return dfs(1)
+
+
+# Your Codec object will be instantiated and called as such:
+# ser = Codec()
+# deser = Codec()
+# ans = deser.deserialize(ser.serialize(root))