updated

Author: abhijitmjj

.gitattributes

@@ -1 +1,2 @@
 * text=auto
+.vscode

.vscode/settings.json

@@ -1,5 +1,9 @@
 {
     "githubPullRequests.ignoredPullRequestBranches": [
         "master"
-    ]
+    ],
+    "python.terminal.activateEnvInCurrentTerminal": true,
+    "python.terminal.activateEnvironment": true,
+    "python.defaultInterpreterPath": "${workspaceFolder}\\.venv\\Scripts\\python.exe",
+    "python.analysis.typeCheckingMode": "strict",
 }

data_structures/arrays/highest_altitude.py

@@ -0,0 +1,37 @@
+"""1732. Find the Highest Altitude
+
+
+There is a biker going on a road trip. The road trip consists of n + 1 points at different altitudes. The biker starts his trip on point 0 with altitude equal 0.
+You are given an integer array gain of length n where gain[i] is the net gain in altitude between points i and i + 1 for all (0 <= i < n). Return the highest altitude of a point.
+
+ 
+
+Example 1:
+
+Input: gain = [-5,1,5,0,-7]
+Output: 1
+Explanation: The altitudes are [0,-5,-4,1,1,-6]. The highest is 1.
+Example 2:
+
+Input: gain = [-4,-3,-2,-1,4,3,2]
+Output: 0
+Explanation: The altitudes are [0,-4,-7,-9,-10,-6,-3,-1]. The highest is 0.
+ 
+
+Constraints:
+
+n == gain.length
+1 <= n <= 100
+-100 <= gain[i] <= 100"""
+
+from typing import List
+def largestAltitude(gain: List[int]) -> int:
+    current_altitude = 0
+    highest_altitude = 0
+    
+    for g in gain:
+        current_altitude += g
+        if current_altitude > highest_altitude:
+            highest_altitude = current_altitude
+    
+    return highest_altitude

data_structures/arrays/k_radius_subarray_avg.py

@@ -0,0 +1,19 @@
+def getAverages(nums: list[int], k: int) -> list[int]:
+    n = len(nums)
+    avgs = [-1] * n
+    if 2 * k + 1 > n:
+        return avgs
+
+    # Calculate prefix sums
+    # Why n + 1? To simplify the sum of elements from the start of the array up to any given point without having to handle special cases.
+    prefix_sum = [0] * (n + 1)
+    for i in range(n):
+        prefix_sum[i + 1] = prefix_sum[i] + nums[i]
+
+    # Calculate k-radius averages
+    for i in range(k, n - k):
+        # The sum of elements from the start of the array up to i + k + 1 minus the sum of elements from the start of the array up to i - k
+        total_sum = prefix_sum[i + k + 1] - prefix_sum[i - k]
+        avgs[i] = total_sum // (2 * k + 1)
+
+    return avgs

data_structures/arrays/num_subarray_with_product_less_than_k.py

@@ -1,4 +1,4 @@
-def num_subarrays_with_product_less_than_k(arr, k):
+def num_subarrays_with_product_less_than_k(arr: list[int], k: int) -> int:
     if k <= 1:
         return 0
 

data_structures/arrays/permutations.py

@@ -40,9 +40,25 @@ def backtrack(start: int) -> None:
     return output
 
 
+def permute_interleave(nums: list[int]) -> list[list[int]]:
+    """
+    Return all permutations of the given list.
+
+    Logic: For each number in the list, we can insert it at any position in the permutations of the remaining numbers
+
+    >>> permute_interleave([1, 2, 3])
+    [[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]]
+    """
+    if not nums:
+        return [[]]
+    return [
+        [n] + p for i, n in enumerate(nums) for p in permute_interleave(nums[:i] + nums[i + 1 :])
+    ]
+
 if __name__ == "__main__":
     import doctest
 
     result = permute_backtrack([1, 2, 3])
     print(result)
+    print(permute_interleave([1, 2, 3]))
     doctest.testmod()

data_structures/hashing/subsets_iterative.py

@@ -20,6 +20,54 @@
 #         subset.pop_back();
 #     }
 # }
+def generate_subsets(nums: list[int]) -> list[list[int]]:
+    """
+    Explanation of the Code
+    Initialization:
+
+    generate_subsets(nums): Initializes an empty list result to store all subsets and calls the backtrack function starting from the first index.
+    Backtracking Function:
+
+    backtrack(start, current): A recursive function that generates all subsets starting from index start and using the current subset current.
+    Base Case: The base case is implicitly handled by the loop termination. When start equals the length of nums, there are no more elements to consider.
+    Recursive Step:
+
+    For each element starting from start to the end of the list nums, the function explores two possibilities:
+    Include: Add nums[i] to the current subset current and call backtrack recursively with the next index (i + 1).
+    Exclude: Remove nums[i] from current (backtrack) and proceed to the next iteration.
+    Adding Subsets:
+
+    Every time backtrack is called, the current subset current is added to the result list result. This ensures that all subsets are captured.
+    Example Usage
+    For nums = [1, 2, 3], the function generates the following subsets:
+
+    Start with an empty subset: []
+    Include 1: [1]
+    Include 2: [1, 2]
+    Include 3: [1, 2, 3]
+    Backtrack to exclude 3: [1, 2]
+    Backtrack to exclude 2 and include 3: [1, 3]
+    Backtrack to exclude 1 and include 2: [2]
+    Include 3: [2, 3]
+    Backtrack to exclude 3: [2]
+    Backtrack to exclude 2 and include 3: [3]
+    Backtrack to exclude 3: []"""
+    def backtrack(start: int, current: list[int]) -> None:
+        # Add the current subset to the result list
+        result.append(current[:])
+        
+        for i in range(start, len(nums)):
+            # Include nums[i] in the current subset
+            current.append(nums[i])
+            # Move to the next element
+            backtrack(i + 1, current)
+            # Exclude nums[i] from the current subset (backtrack)
+            current.pop()
+
+    result: list[list[int]] = []
+    backtrack(0, [])
+    return result
+
 
 def search(k: int, n: int, subset: list[Any], all_subsets: list[list[Any]]):
     """
@@ -45,12 +93,14 @@ def search(k: int, n: int, subset: list[Any], all_subsets: list[list[Any]]):
         # 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)
+        print(f"included {k} index in subset: {subset}")
         search(k + 1, n, subset, all_subsets)
 
         subset.pop()
+        print(f"removed {k} index from subset: {subset}")
 
 def subsets_recursive(nums: List[int]) -> List[List[int]]:
-    all_subsets = []
+    all_subsets: list[list[int]] = []
     search(0, len(nums), [], all_subsets)
     return all_subsets
 
@@ -66,13 +116,67 @@ def subsets_recursive(nums: List[int]) -> List[List[int]]:
 #     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
+def generate_subsets(n: int) -> list[list[int]]:
+    """
+    Explanation of the Python Code
+    Outer Loop (for b in range(1 << n)):
+
+    The variable b ranges from 0 to 2^n - 1.
+    1 << n is equivalent to 2^n, so this loop iterates 2^n
+    times, generating all possible subsets.
+
+    Inner Loop (for i in range(n)):
+
+    For each value of b, this loop checks each bit position i from 0 to n-1.
+    Bit Check (if b & (1 << i)):
+
+    1 << i creates a number with only the  i-th bit set.
+    b & (1 << i) checks if the  i-th bit in b is set.
+    If the i-th bit is set, it means the i-th element is included in the current subset.
+    Subset Construction (subset.append(i)):
+
+    If the bit check is true, the i-th element is added to the current subset.
+    Collecting All Subsets (all_subsets.append(subset)):
+
+    Each generated subset is added to the list all_subsets."""
+    all_subsets: list[list[int]] = []
+    for b in range(1 << n):  # Iterate over all possible subsets
+        subset: list[int] = []
+        for i in range(n):  # Check each bit position
+            if b & (1 << i):  # If the ith bit is set, include i in the subset
+                subset.append(i)
+        all_subsets.append(subset)
+    return all_subsets
+
+# Example usage
+n = 3
+subsets = generate_subsets(n)
+print(subsets)  # Output: [[], [0], [1], [0, 1], [2], [0, 2], [1, 2], [0, 1, 2]]
+
+def generate_subsets(nums: list[Any]) -> list[list[Any]]:
+    n = len(nums)
+    all_subsets: list[list[Any]] = []
+    
+    for b in range(1 << n):  # Iterate over all possible subsets (2^n subsets)
+        subset = [nums[i] for i in range(n) if b & (1 << i)]  # Use list comprehension to build the subset
+        all_subsets.append(subset)
+    
+    return all_subsets
+
+# Example usage
+nums = [1, 2, 3]
+subsets = generate_subsets(nums)
+print(subsets)
+
+def binary_and(str1: str, str2: str) -> str:
+    # Remove '0b' prefix and ensure equal lengths
+    str1 = str1[2:].zfill(max(len(str1), len(str2)) - 2) 
+    str2 = str2[2:].zfill(max(len(str1), len(str2)) - 2)
+
+    result = ""
+    for i in range(len(str1)):
+        result += '1' if str1[i] == '1' and str2[i] == '1' else '0'
+    return '0b' + result
+
+combined_binary = binary_and(bin(1), bin(1 << 2))
+print(combined_binary)  # Output: 0b0

mypy.ini

@@ -0,0 +1,3 @@
+[mypy]
+plugins =
+  returns.contrib.mypy.returns_plugin