03/12/2020

Author: jameszu

Daily-challenge/Dec/01/README.md

@@ -34,17 +34,16 @@ Just do while loop and convert to decimal
 
 ## Code
 ```python
-# Definition for singly-linked list.
-# class ListNode:
-#     def __init__(self, val=0, next=None):
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
 #         self.val = val
-#         self.next = next
+#         self.left = left
+#         self.right = right
 class Solution:
-    def getDecimalValue(self, head: ListNode) -> int:
-        string = ""
-        while head:
-            string += str(head.val)
-            head = head.next
-        # print(string)
-        return int(string, 2)
+    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

@@ -1,12 +1,12 @@
-# Definition for singly-linked list.
-# class ListNode:
-#     def __init__(self, val=0, next=None):
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
 #         self.val = val
-#         self.next = next
+#         self.left = left
+#         self.right = right
 class Solution:
-    def getDecimalValue(self, head: ListNode) -> int:
-        ans = ''
-        while head:
-            ans += str(head.val)
-            head = head.next
-        return int(ans, 2)
+    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/02/README.md

@@ -25,20 +25,29 @@ two ways, one is to use a list and cheat, or we can use standard while loop and
 #         self.val = val
 #         self.next = next
 class Solution:
-    def insertionSortList(self, head: ListNode) -> ListNode:
-        dum = ListNode(0)
-        prev = dum
-        
+
+    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:
-            temp = head.next
-            if prev.val >= head.val:
-                prev = dum
-            while prev.next and prev.next.val < head.val:
-                prev = prev.next
-                
-            head.next = prev.next
-            prev.next = head
-            head = temp
-        return dum.next
+            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/sol.py

@@ -4,41 +4,27 @@
 #         self.val = val
 #         self.next = next
 class Solution:
-    def insertionSortList(self, head: ListNode) -> ListNode:
-        mylist=[]
-        ptr=head
-        while ptr:
-            mylist.append(ptr.val)
-            ptr=ptr.next
-            
-        mylist.sort()
-        
-        ptr=head
-        for val in mylist:
-            ptr.val=val
-            ptr=ptr.next
+
+    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
 
-        return head
 
-# Definition for singly-linked list.
-class ListNode:
-    def __init__(self, val=0, next=None):
-        self.val = val
-        self.next = next
-class Solution:
-    def insertionSortList(self, head: ListNode) -> ListNode:
-        dum = ListNode(0)
-        prev = dum
+    def getRandom(self) -> int:
+        """
+        Returns a random node's value.
+        """
+        num = int(random.random() * len(self.range))
+        return self.range[num]
 
-        while head:
-            temp = head.next
-            if prev.val >= head.val:
-                prev = dum
-            while prev.next and prev.next.val < head.val:
-                prev = prev.next
-                
-            head.next = prev.next
-            prev.next = head
-            head = temp
-        return dum.next
-        
+
+
+# Your Solution object will be instantiated and called as such:
+# obj = Solution(head)
+# param_1 = obj.getRandom()

Daily-challenge/Dec/03/README.md

@@ -1,60 +1,48 @@
-# Consecutive Characters
-
-Solution
-Given a string s, the power of the string is the maximum length of a non-empty substring that contains only one unique character.
-
-Return the power of the string.
+# Increasing Order Search Tree
+Given the root of a binary search tree, rearrange the tree in in-order so that the leftmost node in the tree is now the root of the tree, and every node has no left child and only one right child.
 
 
 
 Example 1:
 
-Input: s = "leetcode"
-Output: 2
-Explanation: The substring "ee" is of length 2 with the character 'e' only.
-Example 2:
 
-Input: s = "abbcccddddeeeeedcba"
-Output: 5
-Explanation: The substring "eeeee" is of length 5 with the character 'e' only.
-Example 3:
-
-Input: s = "triplepillooooow"
-Output: 5
-Example 4:
+Input: root = [5,3,6,2,4,null,8,1,null,null,null,7,9]
+Output: [1,null,2,null,3,null,4,null,5,null,6,null,7,null,8,null,9]
+Example 2:
 
-Input: s = "hooraaaaaaaaaaay"
-Output: 11
-Example 5:
 
-Input: s = "tourist"
-Output: 1
+Input: root = [5,1,7]
+Output: [1,null,5,null,7]
 
 
 Constraints:
 
-1 <= s.length <= 500
-s contains only lowercase English letters. <br>
+The number of nodes in the given tree will be in the range [1, 100].
+0 <= Node.val <= 1000 <br>
 
 ## Idea
 Just a while loop or for loop is fine
 
 ## Code
 
 ```python
-class Solution:
-    def maxPower(self, s: str) -> int:
-        i = 1
-        n = len(s)
-        count = 1
-        res = 1
-        while i < n:
-            if s[i] == s[i-1]:
-                count += 1
-                res = max(res, count)
-            else:
-                # res = max(res, count)
-                count = 1
-            i += 1
+# 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/03/sol.py

@@ -1,15 +1,19 @@
-class Solution:
-    def maxPower(self, s: str) -> int:
-        i = 1
-        n = len(s)
-        count = 1
-        res = 1
-        while i < n:
-            if s[i] == s[i-1]:
-                count += 1
-                res = max(res, count)
-            else:
-                # res = max(res, count)
-                count = 1
-            i += 1
+# 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