Updated tasks 208-1143

Author: javadev

src/main/python/g0201_0300/s0208_implement_trie_prefix_tree/Trie.py

@@ -1,51 +1,40 @@
 # #Medium #Top_100_Liked_Questions #Top_Interview_Questions #String #Hash_Table #Design #Trie
 # #LeetCode_75_Trie #Level_2_Day_16_Design #Udemy_Trie_and_Heap #Top_Interview_150_Trie
 # #Big_O_Time_O(word.length())_or_O(prefix.length())_Space_O(N)
-# #2025_07_25_Time_59_ms_(32.46%)_Space_35.26_MB_(14.23%)
+# #2025_07_25_Time_44_ms_(68.94%)_Space_32.08_MB_(76.05%)
 
 class TrieNode:
-    # Initialize your data structure here.
     def __init__(self):
-        self.children = [None] * 26
-        self.isWord = False
+        self.children = dict()
+        self.isWordEnd = False
 
 class Trie:
     def __init__(self):
         self.root = TrieNode()
-        self.startWith = False
 
-    # Inserts a word into the trie.
-    def insert(self, word):
-        self._insert(word, self.root, 0)
-
-    def _insert(self, word, root, idx):
-        if idx == len(word):
-            root.isWord = True
-            return
-        index = ord(word[idx]) - ord('a')
-        if root.children[index] is None:
-            root.children[index] = TrieNode()
-        self._insert(word, root.children[index], idx + 1)
-
-    # Returns if the word is in the trie.
-    def search(self, word):
-        return self._search(word, self.root, 0)
-
-    def _search(self, word, root, idx):
-        if idx == len(word):
-            self.startWith = True
-            return root.isWord
-        index = ord(word[idx]) - ord('a')
-        if root.children[index] is None:
-            self.startWith = False
-            return False
-        return self._search(word, root.children[index], idx + 1)
-
-    # Returns if there is any word in the trie
-    # that starts with the given prefix.
-    def startsWith(self, prefix):
-        self.search(prefix)
-        return self.startWith
+    def insert(self, word: str) -> None:
+        curr = self.root
+        for c in word:
+            if c not in curr.children:
+                curr.children[c] = TrieNode()
+            curr = curr.children[c]
+        curr.isWordEnd = True
+
+    def search(self, word: str) -> bool:
+        curr = self.root
+        for c in word:
+            if c not in curr.children:
+                return False
+            curr = curr.children[c]
+        return curr.isWordEnd 
+
+    def startsWith(self, prefix: str) -> bool:
+        curr = self.root
+        for c in prefix:
+            if c not in curr.children:
+                return False
+            curr = curr.children[c]
+        return True
 
 # Your Trie object will be instantiated and called as such:
 # obj = Trie()

src/main/python/g0201_0300/s0234_palindrome_linked_list/Solution.py

@@ -1,6 +1,6 @@
 # #Easy #Top_100_Liked_Questions #Two_Pointers #Stack #Linked_List #Recursion
 # #Level_2_Day_3_Linked_List #Udemy_Linked_List #Big_O_Time_O(n)_Space_O(1)
-# #2025_07_25_Time_36_ms_(47.14%)_Space_34.79_MB_(83.78%)
+# #2025_07_25_Time_23_ms_(81.92%)_Space_39.40_MB_(37.99%)
 
 # Definition for singly-linked list.
 # class ListNode:
@@ -9,31 +9,15 @@
 #         self.next = next
 class Solution:
     def isPalindrome(self, head: Optional[ListNode]) -> bool:
-        # Calculate the length of the linked list
-        length = 0
-        right = head
-        while right:
-            right = right.next
-            length += 1
-        
-        # Reverse the right half of the list
-        length //= 2
-        right = head
-        for _ in range(length):
-            right = right.next
-        
-        prev = None
-        while right:
-            next_node = right.next
-            right.next = prev
-            prev = right
-            right = next_node
-        
-        # Compare the left half and the right half
-        for _ in range(length):
-            if head and prev and head.val == prev.val:
-                head = head.next
-                prev = prev.next
-            else:
+        arr = []
+        while head:
+            arr.append(head.val)
+            head = head.next
+        l = 0
+        r = len(arr) -1 
+        while l <= r:
+            if arr[l] != arr[r]:
                 return False
+            l+=1
+            r-=1
         return True

src/main/python/g0201_0300/s0239_sliding_window_maximum/Solution.py

@@ -1,28 +1,17 @@
 # #Hard #Top_100_Liked_Questions #Array #Heap_Priority_Queue #Sliding_Window #Queue
 # #Monotonic_Queue #Udemy_Arrays #Big_O_Time_O(n*k)_Space_O(n+k)
-# #2025_07_25_Time_184_ms_(37.84%)_Space_31.28_MB_(63.38%)
-
-from collections import deque
+# #2025_07_25_Time_152_ms_(81.96%)_Space_30.79_MB_(96.65%)
 
 class Solution:
     def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:
-        n = len(nums)
-        res = [0] * (n - k + 1)
-        dq = deque()
-        i, j = 0, 0
-        x = 0
-        
-        while j < len(nums):
-            while dq and dq[-1] < nums[j]:
-                dq.pop()
-            dq.append(nums[j])
-            
-            if j - i + 1 == k:
-                res[x] = dq[0]
-                x += 1
-                if dq[0] == nums[i]:
-                    dq.popleft()
-                i += 1
-            j += 1
-        
-        return res
+        q = deque()
+        result = []
+        for right in range(len(nums)):
+            while q and nums[right] > nums[q[-1]]:
+                q.pop()
+            q.append(right)
+            if q[0] <= right - k:
+                q.popleft()
+            if right >= k - 1:
+                result.append(nums[q[0]])
+        return result

src/main/python/g0401_0500/s0437_path_sum_iii/Solution.py

@@ -1,6 +1,6 @@
 # #Medium #Top_100_Liked_Questions #Depth_First_Search #Tree #Binary_Tree
 # #LeetCode_75_Binary_Tree/DFS #Level_2_Day_7_Tree #Big_O_Time_O(n)_Space_O(n)
-# #2025_07_25_Time_310_ms_(27.21%)_Space_18.22_MB_(71.08%)
+# #2025_07_25_Time_6_ms_(68.63%)_Space_18.23_MB_(71.08%)
 
 # Definition for a binary tree node.
 # class TreeNode:
@@ -9,24 +9,20 @@
 #         self.left = left
 #         self.right = right
 class Solution:
-    def __init__(self):
-        self.count = 0
+    def pathSum(self, root: TreeNode, targetSum: int) -> int:
+        def dfs(node: TreeNode, targetSum: int, curr_sum: int) -> None:
+            if not node:
+                return
 
-    def pathSum(self, root: Optional[TreeNode], targetSum: int) -> int:
-        if root is None:
-            return 0
-        self.helper(root, targetSum, 0)
-        self.pathSum(root.left, targetSum)
-        self.pathSum(root.right, targetSum)
-        return self.count
+            curr_sum += node.val
+            self.count += self.prefix_sum.get(curr_sum - targetSum, 0)
+            self.prefix_sum[curr_sum] = self.prefix_sum.get(curr_sum, 0) + 1
+            dfs(node.left, targetSum, curr_sum)
+            dfs(node.right, targetSum, curr_sum)
+
+            self.prefix_sum[curr_sum] -= 1
 
-    def helper(self, node: TreeNode, targetSum: int, currSum: int) -> None:
-        if node is None:
-            return
-        currSum += node.val
-        if targetSum == currSum:
-            self.count += 1
-        if node.left is not None:
-            self.helper(node.left, targetSum, currSum)
-        if node.right is not None:
-            self.helper(node.right, targetSum, currSum)
+        self.count = 0
+        self.prefix_sum = {0: 1}
+        dfs(root, targetSum, 0)
+        return self.count

src/main/python/g0501_0600/s0560_subarray_sum_equals_k/Solution.py

@@ -1,19 +1,17 @@
 # #Medium #Top_100_Liked_Questions #Array #Hash_Table #Prefix_Sum #Data_Structure_II_Day_5_Array
-# #Big_O_Time_O(n)_Space_O(n) #2025_07_25_Time_39_ms_(36.13%)_Space_20.37_MB_(71.80%)
+# #Big_O_Time_O(n)_Space_O(n) #2025_07_25_Time_27_ms_(84.54%)_Space_20.34_MB_(71.80%)
 
 from collections import defaultdict
 
 class Solution:
     def subarraySum(self, nums: List[int], k: int) -> int:
-        tempSum = 0
-        ret = 0
-        sumCount = defaultdict(int)
-        sumCount[0] = 1
-        
-        for i in nums:
-            tempSum += i
-            if tempSum - k in sumCount:
-                ret += sumCount[tempSum - k]
-            sumCount[tempSum] += 1
+        sub_num = {0:1}
+        total, count = 0, 0
+
+        for n in nums:
+            total += n
+            if total - k in sub_num:
+                count += sub_num[total-k]
+            sub_num[total] = 1 + sub_num.get(total, 0)
 
-        return ret
+        return count

src/main/python/g0601_0700/s0647_palindromic_substrings/Solution.py

@@ -1,20 +1,20 @@
 # #Medium #String #Dynamic_Programming #Big_O_Time_O(n^2)_Space_O(n)
-# #2025_07_25_Time_141_ms_(40.24%)_Space_17.93_MB_(34.39%)
+# #2025_07_25_Time_4_ms_(99.42%)_Space_17.67_MB_(87.53%)
 
 class Solution:
-    def expand(self, a: List[str], l: int, r: int, res: List[int]) -> None:
-        while l >= 0 and r < len(a):
-            if a[l] != a[r]:
-                return
-            else:
-                res[0] += 1
-                l -= 1
-                r += 1
-
     def countSubstrings(self, s: str) -> int:
-        a = list(s)
-        res = [0]
-        for i in range(len(a)):
-            self.expand(a, i, i, res)
-            self.expand(a, i, i + 1, res)
-        return res[0]
+        result = 0
+        i = 0
+        while i < len(s):
+            l = i
+            while i < len(s) and s[i] == s[l]:
+                i+=1
+            r = i - 1
+            for j in range(r-l+1):
+                result += j+1
+            while l-1>=0 and r+1 < len(s) and s[l-1] == s[r+1]:
+                result+=1
+
+                l-=1
+                r+=1
+        return result

src/main/racket/g0001_0100/s0006_zigzag_conversion/Solution.rkt

@@ -1,4 +1,4 @@
-; #Medium #String #Top_Interview_150_Array/String
+; #Medium #String #Top_Interview_150_Array/String #Big_O_Time_O(n)_Space_O(n)
 ; #2025_02_03_Time_57_ms_(100.00%)_Space_130.82_MB_(60.00%)
 
 (define/contract (convert s numRows)

src/main/racket/g0001_0100/s0007_reverse_integer/Solution.rkt

@@ -1,4 +1,4 @@
-; #Medium #Top_Interview_Questions #Math #Udemy_Integers
+; #Medium #Top_Interview_Questions #Math #Udemy_Integers #Big_O_Time_O(log10(x))_Space_O(1)
 ; #2025_02_03_Time_204_ms_(100.00%)_Space_101.45_MB_(100.00%)
 
 (define/contract (reverse x)

src/main/racket/g0001_0100/s0008_string_to_integer_atoi/Solution.rkt

@@ -1,4 +1,4 @@
-; #Medium #Top_Interview_Questions #String
+; #Medium #Top_Interview_Questions #String #Big_O_Time_O(n)_Space_O(n)
 ; #2025_02_03_Time_3_ms_(100.00%)_Space_101.64_MB_(100.00%)
 
 (define/contract (my-atoi s)

src/main/racket/g0001_0100/s0009_palindrome_number/Solution.rkt

@@ -1,4 +1,4 @@
-; #Easy #Math #Udemy_Integers #Top_Interview_150_Math
+; #Easy #Math #Udemy_Integers #Top_Interview_150_Math #Big_O_Time_O(log10(x))_Space_O(1)
 ; #2025_02_03_Time_8_ms_(100.00%)_Space_129.01_MB_(88.24%)
 
 (define/contract (is-palindrome x)