submissions until 2019/12/22

Author: IdeoG

ok_binary_tree_vertical_order_traversal.py

@@ -0,0 +1,83 @@
+"""
+987. Vertical Order Traversal of a Binary Tree
+Medium
+
+Given a binary tree, return the vertical order traversal of its nodes values.
+For each node at position (X, Y), its left and right children respectively will be at positions
+(X-1, Y-1) and (X+1, Y-1).
+Running a vertical line from X = -infinity to X = +infinity, whenever the vertical line touches some nodes,
+we report the values of the nodes in order from top to bottom (decreasing Y coordinates).
+If two nodes have the same position, then the value of the node that is reported first is the value that is smaller.
+Return an list of non-empty reports in order of X coordinate.  Every report will have a list of values of nodes.
+
+Example 1:
+Input: [3,9,20,null,null,15,7]
+Output: [[9],[3,15],[20],[7]]
+Explanation:
+Without loss of generality, we can assume the root node is at position (0, 0):
+Then, the node with value 9 occurs at position (-1, -1);
+The nodes with values 3 and 15 occur at positions (0, 0) and (0, -2);
+The node with value 20 occurs at position (1, -1);
+The node with value 7 occurs at position (2, -2).
+
+Example 2:
+Input: [1,2,3,4,5,6,7]
+Output: [[4],[2],[1,5,6],[3],[7]]
+Explanation:
+The node with value 5 and the node with value 6 have the same position according to the given scheme.
+However, in the report "[1,5,6]", the node value of 5 comes first since 5 is smaller than 6.
+
+Note:
+The tree will have between 1 and 1000 nodes.
+Each node's value will be between 0 and 1000.
+
+Details
+Runtime: 28 ms, faster than 94.75% of Python3 online submissions for Vertical Order Traversal of a Binary Tree.
+Memory Usage: 12.7 MB, less than 100.00% of Python3 online submissions for Vertical Order Traversal of a Binary Tree.
+
+T ~ O(N + h*log(h) * v*log(v) * k*log(k)), where k is max number of nodes with the same vertical level
+"""
+
+from collections import defaultdict
+from typing import List
+
+
+class TreeNode:
+    def __init__(self, x):
+        self.val = x
+        self.left = None
+        self.right = None
+
+
+class Solution:
+    def verticalTraversal(self, root: TreeNode) -> List[List[int]]:
+        vl_hl_dict = defaultdict(lambda: defaultdict(list))
+
+        hl = 0
+        q, p_item = [(root, 0), None], None
+        while True:
+            item = q.pop(0)
+
+            if item is None:
+                if p_item is None:
+                    break
+                hl += 1
+                q.append(None)
+            else:
+                node, vl = item
+                vl_hl_dict[vl][hl].append(node.val)
+
+                if node.left:
+                    q.append((node.left, vl - 1))
+                if node.right:
+                    q.append((node.right, vl + 1))
+            p_item = item
+
+        result = []
+        for vl, hl_dict in sorted(vl_hl_dict.items(), key=lambda x: x[0]):
+            vl_values = []
+            for hl, values in sorted(hl_dict.items(), key=lambda x: x[0]):
+                vl_values.extend(sorted(values))
+            result.append(vl_values)
+
+        return result

ok_binary_tree_zigzag_order_traversal.py

@@ -0,0 +1,71 @@
+"""
+103. Binary Tree Zigzag Level Order Traversal
+Medium
+
+Given a binary tree, return the zigzag level order traversal of its nodes' values.
+(ie, from left to right, then right to left for the next level and alternate between).
+
+For example:
+Given binary tree [3,9,20,null,null,15,7],
+    3
+   / \
+  9  20
+    /  \
+   15   7
+return its zigzag level order traversal as:
+[
+  [3],
+  [20,9],
+  [15,7]
+]
+
+Details
+Runtime: 24 ms, faster than 98.09% of Python3 online submissions for Binary Tree Zigzag Level Order Traversal.
+Memory Usage: 12.7 MB, less than 100.00% of Python3 online submissions for Binary Tree Zigzag Level Order Traversal.
+"""
+
+# Definition for a binary tree node.
+from typing import List
+
+
+class TreeNode:
+    def __init__(self, x):
+        self.val = x
+        self.left = None
+        self.right = None
+
+
+class Solution:
+    def zigzagLevelOrder(self, root: TreeNode) -> List[List[int]]:
+        if not root:
+            return []
+
+        q = [root, None]
+        paths, path = [], []
+        is_left_to_right_order = True
+        p_node = None
+
+        while True:
+            node = q.pop(0)
+
+            if node is None:
+                if p_node is None:
+                    break
+
+                if is_left_to_right_order:
+                    paths.append(path)
+                else:
+                    paths.append(path[::-1])
+
+                path = []
+                is_left_to_right_order = not is_left_to_right_order
+                q.append(None)
+            else:
+                path.append(node.val)
+                if node.left:
+                    q.append(node.left)
+                if node.right:
+                    q.append(node.right)
+
+            p_node = node
+        return paths

ok_find_all_anagrams_in_a_string.py

@@ -25,8 +25,8 @@
 The substring with start index = 1 is "ba", which is an anagram of "ab".
 The substring with start index = 2 is "ab", which is an anagram of "ab".
 
-Runtime: 108 ms, faster than 82.22% of Python3 online submissions for Find All Anagrams in a String.
-Memory Usage: 13.7 MB, less than 100.00% of Python3 online submissions for Find All Anagrams in a String.
+Runtime: 96 ms, faster than 93.15% of Python3 online submissions for Find All Anagrams in a String.
+Memory Usage: 13.6 MB, less than 100.00% of Python3 online submissions for Find All Anagrams in a String.
 """
 
 from collections import defaultdict
@@ -40,7 +40,7 @@ def findAnagrams(self, s: str, p: str) -> List[int]:
             1.  Iterate over m - len(p) characters in s and count unique characters
                 1.2.    If unique characters == unique characters in p, then save index
 
-            Note: T~O(m*N)
+            Note: T~O(N+M)
         """
         p_unique_chs_count = defaultdict(int)
         for ch in p:
@@ -49,6 +49,9 @@ def findAnagrams(self, s: str, p: str) -> List[int]:
         m, n = len(p), len(s)
         indexs = []
 
+        if n - m < 0:
+            return indexs
+
         subset = s[:m]
         subset_unique_chs_count = defaultdict(int)
         for ch in subset:

ok_jewels_and_stones.py

@@ -0,0 +1,39 @@
+"""
+771. Jewels and Stones
+Easy
+
+You're given strings J representing the types of stones that are jewels, and S representing the stones you have.
+Each character in S is a type of stone you have.  You want to know how many of the stones you have are also jewels.
+The letters in J are guaranteed distinct, and all characters in J and S are letters.
+Letters are case sensitive, so "a" is considered a different type of stone from "A".
+
+Example 1:
+Input: J = "aA", S = "aAAbbbb"
+Output: 3
+
+Example 2:
+Input: J = "z", S = "ZZ"
+Output: 0
+Note:
+
+S and J will consist of letters and have length at most 50.
+The characters in J are distinct.
+
+Details
+Runtime: 20 ms, faster than 99.02% of Python3 online submissions for Jewels and Stones.
+Memory Usage: 12.9 MB, less than 100.00% of Python3 online submissions for Jewels and Stones.
+"""
+
+from collections import defaultdict
+
+
+class Solution:
+    def numJewelsInStones(self, J: str, S: str) -> int:
+        unique_jewels = set(J)
+        unique_stone_counts = defaultdict(int)
+
+        for stone in S:
+            unique_stone_counts[stone] += 1
+
+        return sum([unique_stone_counts[key] for key in unique_stone_counts.keys()
+                    if key in unique_jewels])

ok_reverse_linked_list_2.py renamed to ok_linked_list_reverse_2.py

@@ -0,0 +1,92 @@
+"""
+84. Largest Rectangle in Histogram
+Hard
+
+Given n non-negative integers representing the histogram's bar height where the width of each bar is 1,
+find the area of largest rectangle in the histogram.
+
+Example:
+
+Input: [2,1,5,6,2,3]
+Output: 10
+"""
+from typing import List
+
+
+class Solution:
+    def largestRectangleArea(self, heights: List[int]) -> int:
+
+        # This function calulates maximum
+        # rectangular area under given
+        # histogram with n bars
+
+        # Create an empty stack. The stack
+        # holds indexes of histogram[] list.
+        # The bars stored in the stack are
+        # always in increasing order of
+        # their heights.
+        stack = list()
+
+        max_area = 0  # Initialize max area
+
+        # Run through all bars of
+        # given histogram
+        index = 0
+        histogram = heights
+        while index < len(histogram):
+
+            # If this bar is higher
+            # than the bar on top
+            # stack, push it to stack
+
+            if (not stack) or (histogram[stack[-1]] <= histogram[index]):
+                stack.append(index)
+                index += 1
+
+            # If this bar is lower than top of stack,
+            # then calculate area of rectangle with
+            # stack top as the smallest (or minimum
+            # height) bar.'i' is 'right index' for
+            # the top and element before top in stack
+            # is 'left index'
+            else:
+                # pop the top
+                top_of_stack = stack.pop()
+
+                # Calculate the area with
+                # histogram[top_of_stack] stack
+                # as smallest bar
+                area = (histogram[top_of_stack] *
+                        ((index - stack[-1] - 1)
+                         if stack else index))
+
+                # update max area, if needed
+                max_area = max(max_area, area)
+
+                # Now pop the remaining bars from
+        # stack and calculate area with
+        # every popped bar as the smallest bar
+        while stack:
+            # pop the top
+            top_of_stack = stack.pop()
+
+            # Calculate the area with
+            # histogram[top_of_stack]
+            # stack as smallest bar
+            area = (histogram[top_of_stack] *
+                    ((index - stack[-1] - 1)
+                     if stack else index))
+
+            # update max area, if needed
+            max_area = max(max_area, area)
+
+            # Return maximum area under
+        # the given histogram
+        return max_area
+
+
+if __name__ == '__main__':
+    heights = [2, 1, 5, 6, 2, 3]
+    target = 10
+    output = Solution().largestRectangleArea(heights)
+    assert target == output, f'Expected: {target}, but got {output}'