Included the Leetcode code

Author: abhijitmjj

data_structures/arrays/count_splits.py

@@ -0,0 +1,20 @@
+from typing import List
+
+def count_splits(nums: List[int]) -> int:
+    total_sum = sum(nums)
+    first_part_sum = 0
+    count = 0
+    
+    # Iterate through the array up to the second-to-last element
+    for i in range(len(nums) - 1):
+        first_part_sum += nums[i]
+        second_part_sum = total_sum - first_part_sum
+        
+        if first_part_sum >= second_part_sum:
+            count += 1
+
+    return count
+
+# Example usage
+nums = [10, 4, -8, 7]
+print(count_splits(nums))  # Output: 2

data_structures/arrays/findMaxAverage.py

@@ -0,0 +1,10 @@
+class Solution:
+    def findMaxAverage(self, nums: list[int], k: int) -> float:
+        
+        curr_sum = sum(nums[:k])
+        max_sum = curr_sum
+        for j in range(k, len(nums)):
+            curr_sum += nums[j] - nums[j-k]
+            max_sum = max(max_sum, curr_sum)
+        return max_sum/k
+        

data_structures/arrays/find_Winners.py

@@ -0,0 +1,27 @@
+# In this problem, we are given an array matches consisting of matches [winner, loser] where winner defeats loser.
+
+# We need to collect these 2 kinds of players into two lists separately:
+
+# players that have not lost any matches.
+# players that have lost exactly one match.
+# then return the two lists in increasing order.
+
+from collections import Counter
+
+def findWinners(matches: list[list[int]]) -> list[list[int]]:
+    losses_count = Counter()
+    for winner, loser in matches:
+        losses_count[loser] += 1
+        losses_count[winner] += 0
+    
+    winners = []
+    almost_winners = []
+    for player, losses in losses_count.items():
+        if losses == 0:
+            winners.append(player)
+        elif losses == 1:
+            almost_winners.append(player)
+    
+    return [sorted(winners), sorted(almost_winners)]
+
+

data_structures/arrays/is_subsequence.py

@@ -0,0 +1,21 @@
+
+def is_subsequence(s: str, t: str) -> bool:
+    """
+    Check if a string is a subsequence of another string. (skip characters in between - allowed)
+    :param s: string
+    :param t: string
+    :return: bool
+    """
+
+    i = j = 0
+
+    while i < len(s) and j < len(t):
+        if s[i] == t[j]:
+            # advance the pointer of the subsequence string
+            i += 1
+        # advance the pointer of the main string
+        j += 1
+    return i == len(s)
+
+if __name__ == '__main__':
+    print(is_subsequence("ace", "abcde"))  # Output: True

data_structures/arrays/longestOnes.py

@@ -0,0 +1,16 @@
+class Solution:
+    def longestOnes(self, nums: list[int], k: int) -> int:
+        left = 0
+        current_count = 0
+        max_count = 0
+        for right in range(len(nums)):
+            if nums[right] == 0:
+                current_count += 1
+            
+            while current_count > k:
+                if nums[left] == 0:
+                    current_count -= 1
+                left += 1
+        
+            max_count = max(max_count, right - left + 1)
+        return max_count

data_structures/arrays/max_subarray.py

@@ -0,0 +1,18 @@
+from typing import List
+
+class Solution:
+    def maxSubArray(self, nums: List[int]) -> int:
+        # Initialize with the first element
+        max_current = max_global = nums[0]
+
+        # Iterate through the array starting from the second element
+        for num in nums[1:]:
+            max_current = max(num, max_current + num)
+            max_global = max(max_global, max_current)
+
+        return max_global
+
+# Example usage
+solution = Solution()
+nums = [-2,1,-3,4,-1,2,1,-5,4]
+print(solution.maxSubArray(nums))  # Output: 6

data_structures/arrays/min_subarray.py

@@ -0,0 +1,18 @@
+from typing import List
+
+class Solution:
+    def minSubArray(self, nums: List[float]) -> float:
+        # Initialize with the first element
+        min_current = min_global = nums[0]
+
+        # Iterate through the array starting from the second element
+        for num in nums[1:]:
+            min_current = min(num, min_current + num)
+            min_global = min(min_global, min_current)
+
+        return min_global
+
+# Example usage
+solution = Solution()
+nums = [1.1, -2.3, 3.4, -4.5, 5.6, -6.7]
+print(solution.minSubArray(nums))  # Output: -6.7

data_structures/arrays/num_subarray_with_product_less_than_k.py

@@ -0,0 +1,23 @@
+def num_subarrays_with_product_less_than_k(arr, k):
+    if k <= 1:
+        return 0
+
+    left = 0
+    product = 1
+    count = 0
+
+    for right in range(len(arr)):
+        product *= arr[right]
+
+        while product >= k and left <= right:
+            product /= arr[left]
+            left += 1
+
+        count += right - left + 1
+
+    return count
+
+# Example usage
+arr = [10, 5, 2, 6]
+k = 100
+print(num_subarrays_with_product_less_than_k(arr, k))  # Output: 8

data_structures/arrays/sortedSquares.py

@@ -0,0 +1,18 @@
+from typing import List
+class Solution:
+    def sortedSquares(self, nums: List[int]) -> List[int]:
+        n = len(nums)
+        l = 0
+        r = n - 1
+        result = [0]*len(nums)
+        
+        for i in range(n - 1, -1, -1):
+            
+            if abs(nums[l]) < abs(nums[r]):
+                res = nums[r] ** 2
+                r -= 1
+            else:
+                res = nums[l] ** 2
+                l += 1
+            result[i] = res
+        return result

data_structures/hashing/subsets_iterative.py

@@ -0,0 +1,78 @@
+from typing import Any, List
+
+
+# Base Case:
+
+# If k equals n, it means we have considered all elements, and we process the current subset.
+# Recursive Case:
+
+# The function search(k + 1) is called without including the current element k in the subset.
+# The element k is then added to the subset, and search(k + 1) is called again to include the current element in the subset.
+# After processing the subset including the current element, it is removed (subset.pop_back()) to backtrack.
+
+# void search(int k) {
+#     if (k == n) {
+#         // process subset
+#     } else {
+#         search(k + 1);
+#         subset.push_back(k);
+#         search(k + 1);
+#         subset.pop_back();
+#     }
+# }
+
+def search(k: int, n: int, subset: list[Any], all_subsets: list[list[Any]]):
+    """
+    :param k: current index
+    :param n: length of nums
+    :param subset: current subset
+    :param all_subsets: all subsets
+    
+    When the function search is called with parameter k, it decides whether to
+    include the element k in the subset or not, and in both cases, then calls itself
+    with parameter k + 1 However, if k = n, the function notices that all elements
+    have been processed and a subset has been generated.
+    The following tree illustrates the function calls when n = 3. We can always
+    choose either the left branch (k is not included in the subset) or the right branch
+    (k is included in the subset).
+    """
+    if k == n:
+        # process subset
+        all_subsets.append(subset[:])
+    else:
+        # The function search(k + 1) is called without including the current element k in the subset.
+        search(k + 1, n, subset, all_subsets)
+        # Include nums[k] in the subset
+        # The element k is then added to the subset, and search(k + 1) is called again to include the current element in the subset.
+        subset.append(k)
+        search(k + 1, n, subset, all_subsets)
+
+        subset.pop()
+
+def subsets_recursive(nums: List[int]) -> List[List[int]]:
+    all_subsets = []
+    search(0, len(nums), [], all_subsets)
+    return all_subsets
+
+
+print(subsets_recursive([1, 2, 3]))  # Output: [[], [2], [1], [1, 2], [3], [2, 3], [1, 3], [1, 2, 3]]   
+
+
+
+# def subsets(nums: List[int]) -> List[List[int]]:
+#     result: List[List[int]] = [[]]
+#     for num in nums:
+#         result += [curr + [num] for curr in result]
+#     return result
+
+
+# def subsets_bitmask(nums: List[int]) -> List[List[int]]:
+#     n = len(nums)
+#     result = []
+#     for i in range(1 << n):
+#         subset = []
+#         for j in range(n):
+#             if i & (1 << j):
+#                 subset.append(nums[j])
+#         result.append(subset)
+#    return result