Did some questions from the Uber most frequent and another hard Trie question

Author: Zanger67

.Readme Updater

@@ -0,0 +1,31 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public List<Integer> inorderTraversal(TreeNode root) {
+        ArrayList<Integer> output = new ArrayList<>();
+        helper(root, output);
+        return output;
+    }
+
+    private void helper(TreeNode curr, ArrayList<Integer> output) {
+        if (curr == null) {
+            return;
+        }
+        helper(curr.left, output);
+        output.add(curr.val);
+        helper(curr.right, output);
+    }
+}

README.md

@@ -0,0 +1,19 @@
+# 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 inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
+        self.output = []
+        def helper(curr: Optional[TreeNode]) -> None :
+            if not curr :
+                return
+            
+            helper(curr.left)
+            self.output.append(curr.val)
+            helper(curr.right)
+
+        helper(root)
+        return self.output

my-submissions/e94.java

@@ -0,0 +1,57 @@
+class Solution:
+    def countPrefixSuffixPairs(self, words: List[str]) -> int:
+        # Bidirectional as in from both sides of the string
+        # key = (x, y) --> x = ith char from front
+        #              --> y = ith char from end
+        # Goes full length of string so the chars cross
+        bidirectionalTrie = {}
+        for i, word in enumerate(words) :
+            curr = bidirectionalTrie
+            for j in range(len(word)) :
+                key = (word[j], word[len(word) - j - 1])
+                if key not in curr :
+                    curr[key] = {}
+                curr = curr[key]
+
+            if False not in curr :
+                curr[False] = []
+            curr[False].append(i)
+
+
+        # Finding if the current word works as a prefix/suffix
+        # of any word
+        counter = 0
+        for i, word in enumerate(words) :
+            curr = bidirectionalTrie
+
+            for j in range(len(word)) :
+                key = (word[j], word[len(word) - j - 1])
+                if key not in curr :
+                    continue
+                curr = curr[key]
+
+            counter += self.validWords(curr, i)
+
+        return counter
+
+
+    def validWords(self, trie: dict, lowerBoundIndx: int) -> int :
+        if not trie :
+            return 0
+
+        # lowerBoundIndx + 1 cause we don't want to match a
+        # word with itself. Plus, if it was equal, bisect_left/right
+        # would give us the leftmost or rightmost of its own value if
+        # it exists. We want the indx of the first greater than it
+        # so +1 bisect left will make it the next bigger no matter what
+        output = 0
+        if False in trie :
+            indxSplit = bisect_left(trie[False], lowerBoundIndx + 1)
+            if indxSplit < len(trie[False]) :
+                output += len(trie[False]) - indxSplit
+
+        for k, v in trie.items() :
+            if k :
+                output += self.validWords(v, lowerBoundIndx)
+
+        return output

my-submissions/e94.py

@@ -0,0 +1,48 @@
+class Solution:
+    def suggestedProducts(self, products: List[str], searchWord: str) -> List[List[str]]:
+        trie = {}
+
+        products.sort()
+
+        for product in products :
+            curr = trie
+            for c in product :
+                if c not in curr :
+                    curr[c] = {}
+                curr = curr[c]
+            
+            curr[False] = True
+
+        output = []
+        word = []
+        for c in searchWord :
+            temp = []
+            if c not in trie :
+                break
+            trie = trie[c]
+            word.append(c)
+            self.counter = 3
+            self.collectWordsFromPoint(trie, word, temp)
+            output.append(temp)
+
+        while len(output) < len(searchWord) :
+            output.append([])
+
+
+        return output
+
+    def collectWordsFromPoint(self, trie: dict, current: List[str], output: List[str]) -> None :
+        if not self.counter :
+            return
+        if not trie :
+            return
+        
+        if False in trie :
+            output.append(''.join(current))
+            self.counter -= 1
+        
+        for letter, branch in trie.items() :
+            if letter :
+                current.append(letter)
+                self.collectWordsFromPoint(branch, current, output)
+                current.pop()

my-submissions/h3045.py

@@ -0,0 +1,28 @@
+# In order traversal
+
+# 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 kthSmallest(self, root: Optional[TreeNode], k: int) -> int:
+        self.output = -1
+        self.counter = 0
+        return self.helper(root, k)
+
+    def helper(self, curr: Optional[TreeNode], k: int) -> int : 
+        if not curr :
+            return 0
+
+        temp = self.helper(curr.left, k)
+        if temp :
+            return temp
+
+        self.counter += 1
+        if self.counter == k :
+            return curr.val
+
+        return self.helper(curr.right, k)
+

my-submissions/m1268.py

@@ -0,0 +1,30 @@
+class Solution:
+    def minCost(self, n: int, roads: List[List[int]], appleCost: List[int], k: int) -> List[int]:
+        travelCostMultiplier = k + 1
+        output = []
+
+        roadChoices = defaultdict(list)
+
+        for road in roads :
+            roadChoices[road[0]].append((road[1], road[2]))
+            roadChoices[road[1]].append((road[0], road[2]))
+
+        for i in range(1, n + 1) :
+            toVisit = []            # (totalRoadCost, targetIndx)
+            toVisit.append((0, i))
+            distances = [inf] * n
+
+            while toVisit :
+                cost, node = heapq.heappop(toVisit)
+                if distances[node - 1] != inf :
+                    continue
+
+                distances[node - 1] = cost
+
+                for nextNode, additionalCost in roadChoices[node] :
+                    heapq.heappush(toVisit, (cost + additionalCost, nextNode))
+            
+            output.append(min([distances[x] * travelCostMultiplier + appleCost[x] for x in range(n)]))
+        
+        return output
+

my-submissions/m230.py

@@ -0,0 +1,27 @@
+class Solution:
+
+    def __init__(self, nums: List[int]):
+        self.nums = nums.copy()
+        self.shuffled = nums.copy()
+
+    def reset(self) -> List[int]:
+        self.shuffled = self.nums.copy()
+        return self.nums
+
+    def shuffle(self) -> List[int]:
+        indices = set(range(len(self.nums)))
+        self.shuffled = []
+        
+        while indices :
+            temp = random.choice(list(indices))
+            self.shuffled.append(self.nums[temp])
+            indices.remove(temp)
+        return self.shuffled
+
+        
+
+
+# Your Solution object will be instantiated and called as such:
+# obj = Solution(nums)
+# param_1 = obj.reset()
+# param_2 = obj.shuffle()