Improved tasks 234-647

Author: javadev

src/main/python/g0201_0300/s0234_palindrome_linked_list/readme.md

@@ -40,32 +40,16 @@ Given the `head` of a singly linked list, return `true` if it is a palindrome.
 #         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/readme.md

@@ -59,28 +59,17 @@ Return _the max sliding window_.
 ## Solution
 
 ```python
-from collections import deque
-
 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/readme.md

@@ -41,25 +41,21 @@ The path does not need to start or end at the root or a leaf, but it must go dow
 #         self.left = left
 #         self.right = right
 class Solution:
-    def __init__(self):
-        self.count = 0
-
     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
+        def dfs(node: TreeNode, targetSum: int, curr_sum: int) -> None:
+            if not node:
+                return
+
+            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)
 
-    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.prefix_sum[curr_sum] -= 1
+
+        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/readme.md

@@ -32,16 +32,14 @@ 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
+        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)
 
-        for i in nums:
-            tempSum += i
-            if tempSum - k in sumCount:
-                ret += sumCount[tempSum - k]
-            sumCount[tempSum] += 1
-        
-        return ret
+        return count
 ```

src/main/python/g0601_0700/s0647_palindromic_substrings/readme.md

@@ -36,20 +36,20 @@ A **substring** is a contiguous sequence of characters within the string.
 
 ```python
 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
 ```