no message

Author: Partho Biswas

leetcode.com/python/283_Move_Zeroes.py

@@ -9,3 +9,30 @@ def moveZeroes(self, nums):
             if nums[fastPtr] != 0:
                 nums[fastPtr], nums[slowPtr] = nums[slowPtr], nums[fastPtr]
                 slowPtr += 1
+
+
+
+# My solution duriing mock
+class Solution(object):
+    def moveZeroes(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: None Do not return anything, modify nums in-place instead.
+        """
+        if len(nums) <= 1:
+            return nums
+        read, write = 0, 0
+        while read < len(nums):
+            if nums[read] != 0:
+                nums[read], nums[write] = nums[write], nums[read]
+                read += 1
+                write += 1
+            else:
+                read += 1
+
+
+"""
+[0,1,0,3,12]
+ r
+ w
+"""

leetcode.com/python/314_Binary_Tree_Vertical_Order_Traversal.py

@@ -32,3 +32,29 @@ def verticalOrder(self, root):
             result.append(verticalNodeMap[key])
         return result
 
+
+# My solution during mock, getting TLE, don't know why
+from collections import defaultdict
+from collections import deque
+class Solution(object):
+    def verticalOrder(self, root):
+        """
+        :type root: TreeNode
+        :rtype: List[List[int]]
+        """
+        if not root:
+            return []
+        orderMap = defaultdict(list)
+        queue = deque([(root, 0)])
+
+        while queue:
+            currentNode, vLine = queue.popleft()
+            if currentNode:
+                orderMap[vLine].append(root.val)
+                queue.append((root.left, vLine - 1))
+                queue.append((root.right, vLine + 1))
+
+        result = []
+        for i in range(min(orderMap.keys()), max(orderMap.keys()) + 1):
+            result.append(orderMap[i])
+        return result

leetcode.com/python/560_Subarray_Sum_Equals_K.py

@@ -1,36 +1,81 @@
+# from collections import Counter
+
+# class Solution(object):
+#     def subarraySum(self, nums, k):
+#         """
+#         :type nums: List[int]
+#         :type k: int
+#         :rtype: int
+#         """
+
+#         # Edge case
+#         if not nums:
+#             return 0
+
+#         # Sliding Window -- No, because the array contains negative number
+#         # Dictionary + prefixSum technique
+#         subArrayCount, currentSum = 0, 0
+#         prefixSumCounter = Counter()
+#         prefixSumCounter[0] = 1
+#         for num in nums:
+#             currentSum += num
+#             prefixSum = currentSum - k
+#             if prefixSum in prefixSumCounter:
+#                 subArrayCount += prefixSumCounter[prefixSum]
+#             prefixSumCounter[currentSum] += 1
+#         return subArrayCount
+
+
+# # My solution duriing mock
+# # The following solution is basically a slidinng window type solutio which won't work for egative numbers
+# class Solution(object):
+#     def subarraySum(self, nums, k):
+#         """
+#         :type nums: List[int]
+#         :type k: int
+#         :rtype: int
+#         """
+#         if len(nums) <= 0:
+#             return 0
+#         prefixSum = [0] + nums
+#         for i in range(1, len(prefixSum)):
+#             prefixSum[i] = prefixSum[i - 1] + prefixSum[i]
+
+#         left, right, subArrayCount = 0, 1, 0
+#         while right < len(prefixSum) and left < right:
+#             currentSum = prefixSum[right] - prefixSum[left]
+#             if currentSum == k:
+#                 subArrayCount += 1
+#                 right += 1
+#             elif currentSum < k:
+#                 right += 1
+#             else:
+#                 left += 1
+#         return subArrayCount
+
+
 from collections import Counter
 
+
 class Solution(object):
     def subarraySum(self, nums, k):
         """
         :type nums: List[int]
         :type k: int
         :rtype: int
         """
-
-        # Edge case
-        if not nums:
+        if len(nums) <= 0:
             return 0
 
-        # Sliding Window -- No, because the array contains negative number
-        # Dictionary + prefixSum technique
-        subArrayCount, currentSum = 0, 0
+        prefixSum, currentSum, subArrayCount = 0, 0, 0
         prefixSumCounter = Counter()
         prefixSumCounter[0] = 1
-        for num in nums:
-            currentSum += num #  increment current sum
-            prefixSum = currentSum - k
-            if prefixSum in prefixSumCounter: # check if there is a prefix subarray we can take out to reach k
-                subArrayCount += prefixSumCounter[prefixSum]
-            prefixSumCounter[currentSum] += 1  # add current sum to sum count
-        return subArrayCount
-
-
-
 
+        for num in nums:
+            currentSum += num
+            requiredPrefixSum = currentSum - k
+            if requiredPrefixSum in prefixSumCounter:
+                subArrayCount += prefixSumCounter[requiredPrefixSum]
+            prefixSumCounter[currentSum] += 1
 
-sol = Solution()
-nums = [1,1,1]
-k = 2
-out = sol.subarraySum(nums, k)
-print("Res: ", out)
+        return subArrayCount