10/12/2020

Author: jameszu

Daily-challenge/Dec/09/README.md

@@ -47,18 +47,35 @@ Could you implement next() and hasNext() to run in average O(1) time and use O(h
 
 ## Code
 ```python
-class Solution(object):
-    def flipAndInvertImage(self, A):
-        result = []
-        for row in A:
-            result.append(list(map(lambda x: 0 if x == 1 else 1, row[::-1])))
-        return result
-```
-<!-- 
-var seq1 = new [] { "jumps", "over", "the", "lazy", "dog" };
-		var seq2 = new [] { "the", "quick", "brown", "fox" };
-		var res = seq1.SelectMany(n1 =>
-								 	seq2.Where (n2 => n1.Length == n2.Length)
-								  	.DefaultIfEmpty ()
-								  	.Select (n2 => (n1, n2)))
-									.Count (); -->
+# 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 BSTIterator:
+
+    def __init__(self, root):
+        self.stack = []
+        while root:
+            self.stack.append(root)
+            root = root.left
+
+    def hasNext(self):
+        return len(self.stack) > 0
+
+    def next(self):
+        node = self.stack.pop()
+        x = node.right
+        while x:
+            self.stack.append(x)
+            x = x.left
+        return node.val
+        
+
+
+# Your BSTIterator object will be instantiated and called as such:
+# obj = BSTIterator(root)
+# param_1 = obj.next()
+# param_2 = obj.hasNext()
+```

Daily-challenge/Dec/09/sol.py

@@ -1,6 +1,31 @@
-class Solution(object):
-    def flipAndInvertImage(self, A):
-        result = []
-        for row in A:
-            result.append(list(map(lambda x: 0 if x == 1 else 1, row[::-1])))
-        return result
+# 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 BSTIterator:
+
+    def __init__(self, root):
+        self.stack = []
+        while root:
+            self.stack.append(root)
+            root = root.left
+
+    def hasNext(self):
+        return len(self.stack) > 0
+
+    def next(self):
+        node = self.stack.pop()
+        x = node.right
+        while x:
+            self.stack.append(x)
+            x = x.left
+        return node.val
+        
+
+
+# Your BSTIterator object will be instantiated and called as such:
+# obj = BSTIterator(root)
+# param_1 = obj.next()
+# param_2 = obj.hasNext()

Daily-challenge/Dec/10/README.md

@@ -1,28 +1,33 @@
-# Flipping an Image
+# Valid Mountain Array
+Given an array of integers arr, return true if and only if it is a valid mountain array.
 
-Solution
-Given a binary matrix A, we want to flip the image horizontally, then invert it, and return the resulting image.
+Recall that arr is a mountain array if and only if:
 
-To flip an image horizontally means that each row of the image is reversed.  For example, flipping [1, 1, 0] horizontally results in [0, 1, 1].
+arr.length >= 3
+There exists some i with 0 < i < arr.length - 1 such that:
+arr[0] < arr[1] < ... < arr[i - 1] < A[i]
+arr[i] > arr[i + 1] > ... > arr[arr.length - 1]
 
-To invert an image means that each 0 is replaced by 1, and each 1 is replaced by 0. For example, inverting [0, 1, 1] results in [1, 0, 0].
+ 
 
 Example 1:
 
-Input: [[1,1,0],[1,0,1],[0,0,0]]
-Output: [[1,0,0],[0,1,0],[1,1,1]]
-Explanation: First reverse each row: [[0,1,1],[1,0,1],[0,0,0]].
-Then, invert the image: [[1,0,0],[0,1,0],[1,1,1]]
+Input: arr = [2,1]
+Output: false
 Example 2:
 
-Input: [[1,1,0,0],[1,0,0,1],[0,1,1,1],[1,0,1,0]]
-Output: [[1,1,0,0],[0,1,1,0],[0,0,0,1],[1,0,1,0]]
-Explanation: First reverse each row: [[0,0,1,1],[1,0,0,1],[1,1,1,0],[0,1,0,1]].
-Then invert the image: [[1,1,0,0],[0,1,1,0],[0,0,0,1],[1,0,1,0]]
-Notes:
+Input: arr = [3,5,5]
+Output: false
+Example 3:
 
-1 <= A.length = A[0].length <= 20
-0 <= A[i][j] <= 1<br>
+Input: arr = [0,3,2,1]
+Output: true
+ 
+
+Constraints:
+
+1 <= arr.length <= 104
+0 <= arr[i] <= 104<br>
 
 ## Idea