24/12/2020

Author: jameszu

Daily-challenge/Dec/22/README.md

@@ -33,17 +33,20 @@ Just do while loop and convert to decimal
 
 ## Code
 ```python
+# 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 uniqueMorseRepresentations(self, words: List[str]) -> int:
-        lst = {"a":".-","b":"-...","c":"-.-.","d":"-..","e":".","f":"..-.","g":"--.","h":"....","i":"..","j":".---","k":"-.-","l":".-..","m":"--","n":"-.","o":"---","p":".--.","q":"--.-","r":".-.","s":"...","t":"-","u":"..-","v":"...-","w":".--","x":"-..-","y":"-.--","z":"--.."}
-        final_lst = []
-        for word in words:
-            temp = ""
-            for letter in word:
-                temp += lst[letter]
-            
-            final_lst += [temp]
-            
-        res = len(set(final_lst))
-        return res
+    def isBalanced(self, root: TreeNode) -> bool:
+        def dfs(root):
+            if not root:
+                return 0, True
+            lefth, leftb = dfs(root.left)
+            righth, rightb = dfs(root.right)
+            return max(lefth, righth) + 1, abs(lefth - righth) <= 1 and leftb and rightb
+        
+        return dfs(root)[1]
 ```

Daily-challenge/Dec/22/sol.py

@@ -1,13 +1,16 @@
+# 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 uniqueMorseRepresentations(self, words: List[str]) -> int:
-        lst = {"a":".-","b":"-...","c":"-.-.","d":"-..","e":".","f":"..-.","g":"--.","h":"....","i":"..","j":".---","k":"-.-","l":".-..","m":"--","n":"-.","o":"---","p":".--.","q":"--.-","r":".-.","s":"...","t":"-","u":"..-","v":"...-","w":".--","x":"-..-","y":"-.--","z":"--.."}
-        final_lst = []
-        for word in words:
-            temp = ""
-            for letter in word:
-                temp += lst[letter]
-            
-            final_lst += [temp]
-            
-        res = len(set(final_lst))
-        return res
+    def isBalanced(self, root: TreeNode) -> bool:
+        def dfs(root):
+            if not root:
+                return 0, True
+            lefth, leftb = dfs(root.left)
+            righth, rightb = dfs(root.right)
+            return max(lefth, righth) + 1, abs(lefth - righth) <= 1 and leftb and rightb
+        
+        return dfs(root)[1]

Daily-challenge/Dec/23/README.md

@@ -1,58 +1,47 @@
-# House Robber III
-The thief has found himself a new place for his thievery again. There is only one entrance to this area, called the "root." Besides the root, each house has one and only one parent house. After a tour, the smart thief realized that "all houses in this place forms a binary tree". It will automatically contact the police if two directly-linked houses were broken into on the same night.
+# Next Greater Element III
 
-Determine the maximum amount of money the thief can rob tonight without alerting the police.
+Solution
+Given a positive integer n, find the smallest integer which has exactly the same digits existing in the integer n and is greater in value than n. If no such positive integer exists, return -1.
 
-Example 1:
+Note that the returned integer should fit in 32-bit integer, if there is a valid answer but it does not fit in 32-bit integer, return -1.
 
-Input: [3,2,3,null,3,null,1]
+ 
 
-     3
-    / \
-   2   3
-    \   \ 
-     3   1
+Example 1:
 
-Output: 7 
-Explanation: Maximum amount of money the thief can rob = 3 + 3 + 1 = 7.
+Input: n = 12
+Output: 21
 Example 2:
 
-Input: [3,4,5,1,3,null,1]
+Input: n = 21
+Output: -1
+ 
 
-     3
-    / \
-   4   5
-  / \   \ 
- 1   3   1
+Constraints:
 
-Output: 9
-Explanation: Maximum amount of money the thief can rob = 4 + 5 = 9.<br>
+1 <= n <= 231 - 1<br>
 
 ## Idea
 Just do while loop and convert to decimal
 
 ## Code
 ```python
-# 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 rob(self, root: TreeNode) -> int:
-        if not root:
-            return 0
-        
-        def helper(node):
-            if not node: 
-                return (0, 0)
-            l1, l2 = helper(node.left)
-            r1, r2 = helper(node.right)
-            
-            return (node.val + l2 + r2, max(l1, l2) + max(r1, r2))
+    def nextGreaterElement(self, n: int) -> int:
+        digits = list(str(n))
+        i = len(digits) - 1
+        while i-1 >= 0 and digits[i] <= digits[i-1]:
+            i -= 1
 
-            
-        return max(helper(root))
+        if i == 0: return -1
+        
+        j = i
+        while j+1 < len(digits) and digits[j+1] > digits[i-1]:
+            j += 1
+        
+        digits[i-1], digits[j] = digits[j], digits[i-1]
+        digits[i:] = digits[i:][::-1]
+        ret = int(''.join(digits))
 
+        return ret if ret < 1<<31 else -1
 ```

Daily-challenge/Dec/23/sol.py

@@ -1,22 +1,18 @@
-# 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 rob(self, root: TreeNode) -> int:
-        if not root:
-            return 0
-        
-        def helper(node):
-            if not node: 
-                return (0, 0)
-            l1, l2 = helper(node.left)
-            r1, r2 = helper(node.right)
-            
-            return (node.val + l2 + r2, max(l1, l2) + max(r1, r2))
-            
+    def nextGreaterElement(self, n: int) -> int:
+        digits = list(str(n))
+        i = len(digits) - 1
+        while i-1 >= 0 and digits[i] <= digits[i-1]:
+            i -= 1
 
-        return max(helper(root))
-        
+        if i == 0: return -1
+        
+        j = i
+        while j+1 < len(digits) and digits[j+1] > digits[i-1]:
+            j += 1
+        
+        digits[i-1], digits[j] = digits[j], digits[i-1]
+        digits[i:] = digits[i:][::-1]
+        ret = int(''.join(digits))
+        
+        return ret if ret < 1<<31 else -1

Daily-challenge/Dec/24/README.md

@@ -1,24 +1,29 @@
-# Basic Calculator II
-Implement a basic calculator to evaluate a simple expression string.
+# Swap Nodes in Pairs
+Given a linked list, swap every two adjacent nodes and return its head.
 
-The expression string contains only non-negative integers, +, -, *, / operators and empty spaces . The integer division should truncate toward zero.
+You may not modify the values in the list's nodes. Only nodes itself may be changed.
+
+ 
 
 Example 1:
 
-Input: "3+2*2"
-Output: 7
+
+Input: head = [1,2,3,4]
+Output: [2,1,4,3]
 Example 2:
 
-Input: " 3/2 "
-Output: 1
+Input: head = []
+Output: []
 Example 3:
 
-Input: " 3+5 / 2 "
-Output: 5
-Note:
+Input: head = [1]
+Output: [1]
+ 
+
+Constraints:
 
-You may assume that the given expression is always valid.
-Do not use the eval built-in library function.<br>
+The number of nodes in the list is in the range [0, 100].
+0 <= Node.val <= 100.<br>
 
 ## Idea
 Just do while loop and convert to decimal