new year ayyy

Author: jameszu

Daily-challenge/Dec/01/README.md renamed to Daily-challenge/2020/Dec/01/README.md

@@ -0,0 +1,12 @@
+# 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 maxDepth(self, root: TreeNode) -> int:
+        if not root:
+            return 0
+        
+        return 1 + max(self.maxDepth(root.left), self.maxDepth(root.right))

Daily-challenge/Dec/01/sol.py renamed to Daily-challenge/2020/Dec/01/sol.py

@@ -0,0 +1,30 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution:
+
+    def __init__(self, head: ListNode):
+        """
+        @param head The linked list's head.
+        Note that the head is guaranteed to be not null, so it contains at least one node.
+        """
+        self.range = []
+        while head:
+            self.range.append(head.val)
+            head = head.next
+            
+
+    def getRandom(self) -> int:
+        """
+        Returns a random node's value.
+        """
+        num = int(random.random() * len(self.range))
+        return self.range[num]
+        
+
+
+# Your Solution object will be instantiated and called as such:
+# obj = Solution(head)
+# param_1 = obj.getRandom()

Daily-challenge/Dec/02/README.md renamed to Daily-challenge/2020/Dec/02/README.md

@@ -0,0 +1,19 @@
+# if this null node was a left child, tail is its parent
+        # if this null node was a right child, tail is its parent's parent
+        if not root: return tail
+
+        # recursive call, traversing left while passing in the current node as tail
+        res = self.increasingBST(root.left, root)
+
+        # we don't want the current node to have a left child, only a single right child
+        root.left = None
+
+        # we set the current node's right child to be tail
+        # what is tail? this part is important
+        # if the current node is a left child, tail will be its parent
+        # else if the current node is a right child, tail will be its parent's parent
+        root.right = self.increasingBST(root.right, tail)
+
+        # throughout the whole algorithm, res is the leaf of the leftmost path in the original tree
+        # its the smallest node and thus will be the root of the modified tree
+        return res

Daily-challenge/Dec/02/sol.py renamed to Daily-challenge/2020/Dec/02/sol.py

@@ -0,0 +1,10 @@
+class Solution:
+    def kthFactor(self, n: int, k: int) -> int:
+        lst = []
+        
+        for i in range(1, n+1):
+            if n % i == 0:
+                lst += [i]
+        if len(lst) < k:
+            return -1
+        return lst[k-1]

Daily-challenge/Dec/03/README.md renamed to Daily-challenge/2020/Dec/03/README.md

@@ -0,0 +1,21 @@
+class Solution:
+    def canPlaceFlowers(self, flowerbed: List[int], n: int) -> bool:
+        i = 0
+        lenz = len(flowerbed)
+        count = 0
+        
+        while i < lenz and count < n:
+            if flowerbed[i] == 0:
+                if i == lenz - 1: 
+                    nex = 0 
+                else: nex = flowerbed[i+1]
+                if i == 0: 
+                    prev = 0 
+                else: 
+                    prev = flowerbed[i-1]
+                if nex == 0 and prev == 0:
+                    flowerbed[i] = 1
+                    count += 1
+                    
+            i += 1
+        return count == n