Completed Daily + Weekly Premium + Similar Questions

Author: Zanger67

README.md

@@ -0,0 +1,36 @@
+# We can basically do levelorder traversals starting at 0, 1, 2,...
+# with compensating recursive calls
+
+class Solution:
+    def getAncestors(self, n: int, edges: List[List[int]]) -> List[List[int]]:
+        directAncestors = [set() for _ in range(n)]
+        visited = [False] * n
+
+        # Add immediate predecessors
+        for source, target in edges :
+            directAncestors[target].add(source)
+
+
+        # Helper method that merges a node's ancestor set with 
+        # any ancestor's ancestor set
+        def helper(currentIndx: int) -> None :
+            if visited[currentIndx] :
+                return
+
+            visited[currentIndx] = True
+            if not directAncestors[currentIndx] : # is oldest ancestor
+                return
+            
+            mergeSet = set()
+            for item in directAncestors[currentIndx] :
+                helper(item) # make sure it's been initialized first
+                mergeSet |= directAncestors[item]
+            
+            directAncestors[currentIndx] |= mergeSet
+
+        for i in range(n) :
+            if not visited[i] :
+                helper(i)
+            
+
+        return [sorted(list(x)) for x in directAncestors]

my-submissions/e1791 v1 Inefficient Counter.py renamed to my-submissions/e1791 v1 Daily Inefficient Counter.py

@@ -0,0 +1,50 @@
+class Solution {
+    public List<List<Integer>> getAncestors(int n, int[][] edges) {
+        ArrayList<HashSet<Integer>> parents = new ArrayList<>();
+        
+        for (int i = 0; i < n; i++) {
+            parents.add(new HashSet<Integer>());
+        }
+
+        boolean[] visited = new boolean[n];
+
+        for (int[] edge : edges) {
+            parents.get(edge[1]).add(edge[0]);
+        }
+
+        for (int i = 0; i < n; i++) {
+            if (!visited[i]) {
+                helper(i, visited, parents);
+            }
+        }
+
+        List<List<Integer>> output = new ArrayList<>();
+        for (int i = 0; i < n; i++) {
+            output.add(new ArrayList<Integer>());
+            output.get(i).addAll(parents.get(i));
+            Collections.sort(output.get(i));
+        }
+
+        return output;
+
+    }
+    
+    private void helper(int currentIndx, boolean[] visited, ArrayList<HashSet<Integer>> parents) {
+        if (visited[currentIndx]) {
+            return;
+        }
+
+        visited[currentIndx] = true;
+        if (parents.get(currentIndx).size() == 0) {
+            return;
+        }
+
+        HashSet<Integer> mergeValues = new HashSet<>();
+        for (Integer i : parents.get(currentIndx)) {
+            helper(i, visited, parents);
+            mergeValues.addAll(parents.get(i));
+        }
+        parents.get(currentIndx).addAll(mergeValues);
+     }
+
+}

my-submissions/m1382 AVL Method.py renamed to my-submissions/m1382 Daily AVL Method.py

@@ -0,0 +1,36 @@
+# 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 deleteNode(self, root: Optional[TreeNode], key: int) -> Optional[TreeNode]:
+        def helper(curr: Optional[TreeNode], key: int) -> Optional[TreeNode] :
+            if not curr :
+                return None
+            if curr.val == key :
+                if not curr.left :
+                    return curr.right
+                if not curr.left.right :
+                    curr.left.right = curr.right
+                    return curr.left
+
+                predecessor = curr.left
+                
+                while predecessor.right and predecessor.right.right :
+                    predecessor = predecessor.right
+                
+                curr.val = predecessor.right.val
+                predecessor.right = predecessor.right.left
+                
+                return curr
+
+            if curr.val < key :
+                curr.right = helper(curr.right, key)
+                return curr
+            
+            curr.left = helper(curr.left, key)
+            return curr
+
+        return helper(root, key)

my-submissions/m2192 Daily.py

@@ -0,0 +1,30 @@
+# If greater than root, root is part of output (indx 0) and we need to find first 
+# value greater than that for other node
+
+# If less than root, root is part of output (indx 1) and we have to find
+# smaller values go left
+
+# 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 splitBST(self, root: Optional[TreeNode], target: int) -> List[Optional[TreeNode]]:
+        if not root :
+            return [None, None]
+
+        if root.val == target :
+            temp = root.right
+            root.right = None
+            return [root, temp]
+
+        if root.val > target :
+            temp = self.splitBST(root.left, target)
+            root.left = temp[1]
+            return [temp[0], root]
+
+        temp = self.splitBST(root.right, target)
+        root.right = temp[0]
+        return [root, temp[1]]