Grinded some Tries and Neetcode

Author: Zanger67

README.md

@@ -0,0 +1,24 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode reverseList(ListNode head) {
+        head = helper(null, head);
+        return head;
+    }
+    private ListNode helper(ListNode prev, ListNode curr) {
+        if (curr == null) {
+            return prev;
+        }
+        ListNode output = helper(curr, curr.next);
+        curr.next = prev;
+        return output; 
+    }
+}

my-submissions/e206.java

@@ -0,0 +1,81 @@
+class Solution:
+    def findWords(self, board: List[List[str]], words: List[str]) -> List[str]:
+        # Recursive propogation to search for words stemming from a specific index
+        def propogate(board: List[List[str]], row: int, col: int, currentTrie) -> None :
+            if not (0 <= row < len(board)) or not (0 <= col < len(board[0])) :
+                return
+            if board[row][col] not in currentTrie :
+                return
+
+            currentTrie = currentTrie[board[row][col]]
+
+            if False in currentTrie :
+                self.found.add(currentTrie[False])
+
+            newIndices = [(row + 1, col), (row - 1, col), (row, col + 1), (row, col - 1)]
+            for r, c in newIndices :
+                if (r, c) not in self.visited and (0 <= r < len(board)) and (0 <= c < len(board[0])):
+                    self.visited.add((r, c))
+                    propogate(board, r, c, currentTrie)
+                    self.visited.remove((r, c))
+
+
+
+        # Parsing through each possible origin index
+        self.trie = self.constructTrie(words)
+        output  = set()
+
+        for row in range(len(board)) :
+            for col in range(len(board[0])) :
+                self.visited = set()
+                self.found   = set()
+                self.visited.add((row, col))
+                propogate(board, row, col, self.trie)
+
+                # Compiling the words we found and removing from
+                # our search trie
+                for fnd in self.found :
+                    self.trie = self.removeWordFromTrie(fnd, self.trie)
+                output |= self.found
+
+        return list(output)
+    
+    # Helper method to remove a word from our trie
+    def removeWordFromTrie(self, word: str, trie: dict) -> dict : 
+        curr = trie
+        curr['Counter'] = curr.get('Counter', 0) - 1
+
+        if curr['Counter'] <= 0 :
+            return {}
+
+        for c in word :
+            if c not in curr :
+                break
+
+            curr[c]['Counter'] = curr[c].get('Counter', 0) - 1
+            if curr[c]['Counter'] <= 0 :
+                curr.pop(c)
+                break
+            curr = curr[c]
+        
+        if False in curr :
+            curr.pop(False)
+        
+        return trie
+
+
+    # Helper method to create our initial trie of words that we're searching for
+    def constructTrie(self, words: List[str]) -> dict :
+        trie = {}
+
+        for word in words :
+            curr = trie
+            trie['Counter'] = trie.get('Counter', 0) + 1
+            for c in word :
+                if c not in curr :
+                    curr[c] = {}
+                curr = curr[c]
+                curr['Counter'] = curr.get('Counter', 0) + 1
+            curr[False] = word
+        
+        return trie

my-submissions/h2112 v2 Trie with removal of words once found once.py

@@ -0,0 +1,44 @@
+class Solution:
+    def findWords(self, board: List[List[str]], words: List[str]) -> List[str]:
+        trie = self.constructTrie(words)
+        output = set()
+        visited = set()
+        def propogate(board: List[List[str]], row: int, col: int, currentTrie: dict) -> None :
+            if not (0 <= row < len(board)) or not (0 <= col < len(board[0])) :
+                return
+            if board[row][col] not in currentTrie :
+                return
+
+            currentTrie = currentTrie[board[row][col]]
+
+            if False in currentTrie :
+                output.add(currentTrie[False])
+            
+            newIndices = [(row + 1, col), (row - 1, col), (row, col + 1), (row, col - 1)]
+
+            for r, c in newIndices :
+                if (r, c) not in visited and (0 <= r < len(board)) and (0 <= c < len(board[0])):
+                    visited.add((r, c))
+                    propogate(board, r, c, currentTrie)
+                    visited.remove((r, c))
+
+        for row in range(len(board)) :
+            for col in range(len(board[0])) :
+                visited = set()
+                visited.add((row, col))
+                propogate(board, row, col, trie)
+            
+        return list(output)
+    
+    def constructTrie(self, words: List[str]) -> dict :
+        trie = {}
+
+        for word in words :
+            curr = trie
+            for c in word :
+                if c not in curr :
+                    curr[c] = {}
+                curr = curr[c]
+            curr[False] = word
+        
+        return trie

my-submissions/h212 v1 Brute Force Trie.py

@@ -0,0 +1,47 @@
+"""
+# Definition for a Node.
+class Node:
+    def __init__(self, x: int, next: 'Node' = None, random: 'Node' = None):
+        self.val = int(x)
+        self.next = next
+        self.random = random
+"""
+
+class Solution:
+    def copyRandomList(self, head: 'Optional[Node]') -> 'Optional[Node]':
+        if not head :
+            return None
+
+        origNodes = {}
+        newNodes  = []
+
+        newHead = Node(head.val)
+
+        origCurr = head
+        curr = newHead
+
+        indx = 0
+        origNodes[origCurr] = indx
+        newNodes.append(curr)
+
+
+        while origCurr.next :
+            indx += 1
+            origCurr = origCurr.next
+            origNodes[origCurr] = indx
+            curr.next = Node(origCurr.val)
+            curr = curr.next
+            newNodes.append(curr)
+        
+        curr = newHead
+        origCurr = head
+
+        while origCurr :
+            if origCurr.random :
+                curr.random = newNodes[origNodes.get(origCurr.random)]
+            
+            origCurr = origCurr.next
+            curr = curr.next
+        
+        return newHead
+

my-submissions/m138.py

@@ -0,0 +1,53 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public void reorderList(ListNode head) {
+        ListNode slow = head;
+        ListNode fast = head;
+
+        while (fast.next != null && fast.next.next != null) {
+            fast = fast.next.next;
+            slow = slow.next;
+        }
+
+        ListNode prev = slow;
+        slow = slow.next;
+        prev.next = null;
+        while (slow != null) {
+            ListNode temp = slow.next;
+            slow.next = prev;
+            prev = slow;
+            slow = temp;
+        }
+
+        ListNode front = head.next;
+        ListNode back = prev;
+        ListNode newHead = head;
+
+        while (front != null && back != null) {
+            if (back != null) {
+                newHead.next = back;
+                back = back.next;
+                newHead = newHead.next;
+            }
+
+            if (front != null) {
+                newHead.next = front;
+                front = front.next;
+                newHead = newHead.next;
+            }
+        }
+        if (back != null) {
+            newHead.next = back;
+            back.next = null;
+        }
+    }
+}

my-submissions/m143 v2 reverse.java

@@ -0,0 +1,59 @@
+class Trie:
+
+    def __init__(self):
+        self.trie = {}
+
+    def insert(self, word: str) -> None:
+        curr = self.trie
+        for c in word :
+            if c not in curr :
+                curr[c] = {}
+            curr = curr[c]
+        
+        if False in curr :
+            curr[False] += 1
+        else :
+            curr[False] = 1
+
+    def countWordsEqualTo(self, word: str) -> int:
+        curr = self.trie
+        for c in word :
+            if c not in curr :
+                return 0
+            curr = curr[c]
+        
+        return curr.get(False, 0)
+
+    def countWordsStartingWith(self, prefix: str) -> int:
+        curr = self.trie
+        for c in prefix :
+            if c not in curr :
+                return 0
+            curr = curr[c]
+        return self.countAllFromHere(curr)
+    
+    def countAllFromHere(self, trie: dict) -> int :
+        output = trie.get(False, 0)
+        
+        for k in trie :
+            if k :
+                output += self.countAllFromHere(trie[k])
+        
+        return output
+
+    def erase(self, word: str) -> None:
+        curr = self.trie
+        for c in word :
+            if c not in curr :
+                return
+            curr = curr[c]
+        
+        curr[False] = curr.get(False, 1) - 1
+
+
+# Your Trie object will be instantiated and called as such:
+# obj = Trie()
+# obj.insert(word)
+# param_2 = obj.countWordsEqualTo(word)
+# param_3 = obj.countWordsStartingWith(prefix)
+# obj.erase(word)

my-submissions/m1804.py

@@ -0,0 +1,43 @@
+class Trie:
+
+    def __init__(self):
+        self.trie = {}
+
+    def insert(self, word: str) -> None:
+        curr = self.trie
+
+        for c in word :
+            if c in curr :
+                curr = curr[c]
+            else :
+                curr[c] = {}
+                curr = curr[c]
+
+        curr['#'] = True
+
+    def search(self, word: str) -> bool:
+        curr = self.trie
+        for c in word :
+            if c not in curr :
+                return False
+            curr = curr[c]
+
+        if '#' in curr :
+            return True
+        
+        return False
+
+    def startsWith(self, prefix: str) -> bool:
+        curr = self.trie
+        for c in prefix :
+            if c not in curr :
+                return False
+            curr = curr[c]
+        return True
+
+
+# Your Trie object will be instantiated and called as such:
+# obj = Trie()
+# obj.insert(word)
+# param_2 = obj.search(word)
+# param_3 = obj.startsWith(prefix)