move-files-and-2-renames (#4285)

maths/max_sum_sliding_window.py

@@ -1,45 +1,45 @@
-"""
+"""
-Given an array of integer elements and an integer 'k', we are required to find the
+Given an array of integer elements and an integer 'k', we are required to find the
-maximum sum of 'k' consecutive elements in the array.
+maximum sum of 'k' consecutive elements in the array.
-
+
-Instead of using a nested for loop, in a Brute force approach we will use a technique
+Instead of using a nested for loop, in a Brute force approach we will use a technique
-called 'Window sliding technique' where the nested loops can be converted to a single
+called 'Window sliding technique' where the nested loops can be converted to a single
-loop to reduce time complexity.
+loop to reduce time complexity.
-"""
+"""
-from typing import List
+from typing import List
-
+
-
+
-def max_sum_in_array(array: List[int], k: int) -> int:
+def max_sum_in_array(array: List[int], k: int) -> int:
-    """
+    """
-    Returns the maximum sum of k consecutive elements
+    Returns the maximum sum of k consecutive elements
-    >>> arr = [1, 4, 2, 10, 2, 3, 1, 0, 20]
+    >>> arr = [1, 4, 2, 10, 2, 3, 1, 0, 20]
-    >>> k = 4
+    >>> k = 4
-    >>> max_sum_in_array(arr, k)
+    >>> max_sum_in_array(arr, k)
-    24
+    24
-    >>> k = 10
+    >>> k = 10
-    >>> max_sum_in_array(arr,k)
+    >>> max_sum_in_array(arr,k)
-    Traceback (most recent call last):
+    Traceback (most recent call last):
-        ...
+        ...
-    ValueError: Invalid Input
+    ValueError: Invalid Input
-    >>> arr = [1, 4, 2, 10, 2, 13, 1, 0, 2]
+    >>> arr = [1, 4, 2, 10, 2, 13, 1, 0, 2]
-    >>> k = 4
+    >>> k = 4
-    >>> max_sum_in_array(arr, k)
+    >>> max_sum_in_array(arr, k)
-    27
+    27
-    """
+    """
-    if len(array) < k or k < 0:
+    if len(array) < k or k < 0:
-        raise ValueError("Invalid Input")
+        raise ValueError("Invalid Input")
-    max_sum = current_sum = sum(array[:k])
+    max_sum = current_sum = sum(array[:k])
-    for i in range(len(array) - k):
+    for i in range(len(array) - k):
-        current_sum = current_sum - array[i] + array[i + k]
+        current_sum = current_sum - array[i] + array[i + k]
-        max_sum = max(max_sum, current_sum)
+        max_sum = max(max_sum, current_sum)
-    return max_sum
+    return max_sum
-
+
-
+
-if __name__ == "__main__":
+if __name__ == "__main__":
-    from doctest import testmod
+    from doctest import testmod
-    from random import randint
+    from random import randint
-
+
-    testmod()
+    testmod()
-    array = [randint(-1000, 1000) for i in range(100)]
+    array = [randint(-1000, 1000) for i in range(100)]
-    k = randint(0, 110)
+    k = randint(0, 110)
-    print(f"The maximum sum of {k} consecutive elements is {max_sum_in_array(array,k)}")
+    print(f"The maximum sum of {k} consecutive elements is {max_sum_in_array(array,k)}")

maths/triplet_sum.py

@@ -1,89 +1,89 @@
-"""
+"""
-Given an array of integers and another integer target,
+Given an array of integers and another integer target,
-we are required to find a triplet from the array such that it's sum is equal to
+we are required to find a triplet from the array such that it's sum is equal to
-the target.
+the target.
-"""
+"""
-from __future__ import annotations
+from __future__ import annotations
-
+
-from itertools import permutations
+from itertools import permutations
-from random import randint
+from random import randint
-from timeit import repeat
+from timeit import repeat
-
+
-
+
-def make_dataset() -> tuple[list[int], int]:
+def make_dataset() -> tuple[list[int], int]:
-    arr = [randint(-1000, 1000) for i in range(10)]
+    arr = [randint(-1000, 1000) for i in range(10)]
-    r = randint(-5000, 5000)
+    r = randint(-5000, 5000)
-    return (arr, r)
+    return (arr, r)
-
+
-
+
-dataset = make_dataset()
+dataset = make_dataset()
-
+
-
+
-def triplet_sum1(arr: list[int], target: int) -> tuple[int, int, int]:
+def triplet_sum1(arr: list[int], target: int) -> tuple[int, int, int]:
-    """
+    """
-    Returns a triplet in the array with sum equal to target,
+    Returns a triplet in the array with sum equal to target,
-    else (0, 0, 0).
+    else (0, 0, 0).
-    >>> triplet_sum1([13, 29, 7, 23, 5], 35)
+    >>> triplet_sum1([13, 29, 7, 23, 5], 35)
-    (5, 7, 23)
+    (5, 7, 23)
-    >>> triplet_sum1([37, 9, 19, 50, 44], 65)
+    >>> triplet_sum1([37, 9, 19, 50, 44], 65)
-    (9, 19, 37)
+    (9, 19, 37)
-    >>> arr = [6, 47, 27, 1, 15]
+    >>> arr = [6, 47, 27, 1, 15]
-    >>> target = 11
+    >>> target = 11
-    >>> triplet_sum1(arr, target)
+    >>> triplet_sum1(arr, target)
-    (0, 0, 0)
+    (0, 0, 0)
-    """
+    """
-    for triplet in permutations(arr, 3):
+    for triplet in permutations(arr, 3):
-        if sum(triplet) == target:
+        if sum(triplet) == target:
-            return tuple(sorted(triplet))
+            return tuple(sorted(triplet))
-    return (0, 0, 0)
+    return (0, 0, 0)
-
+
-
+
-def triplet_sum2(arr: list[int], target: int) -> tuple[int, int, int]:
+def triplet_sum2(arr: list[int], target: int) -> tuple[int, int, int]:
-    """
+    """
-    Returns a triplet in the array with sum equal to target,
+    Returns a triplet in the array with sum equal to target,
-    else (0, 0, 0).
+    else (0, 0, 0).
-    >>> triplet_sum2([13, 29, 7, 23, 5], 35)
+    >>> triplet_sum2([13, 29, 7, 23, 5], 35)
-    (5, 7, 23)
+    (5, 7, 23)
-    >>> triplet_sum2([37, 9, 19, 50, 44], 65)
+    >>> triplet_sum2([37, 9, 19, 50, 44], 65)
-    (9, 19, 37)
+    (9, 19, 37)
-    >>> arr = [6, 47, 27, 1, 15]
+    >>> arr = [6, 47, 27, 1, 15]
-    >>> target = 11
+    >>> target = 11
-    >>> triplet_sum2(arr, target)
+    >>> triplet_sum2(arr, target)
-    (0, 0, 0)
+    (0, 0, 0)
-    """
+    """
-    arr.sort()
+    arr.sort()
-    n = len(arr)
+    n = len(arr)
-    for i in range(n - 1):
+    for i in range(n - 1):
-        left, right = i + 1, n - 1
+        left, right = i + 1, n - 1
-        while left < right:
+        while left < right:
-            if arr[i] + arr[left] + arr[right] == target:
+            if arr[i] + arr[left] + arr[right] == target:
-                return (arr[i], arr[left], arr[right])
+                return (arr[i], arr[left], arr[right])
-            elif arr[i] + arr[left] + arr[right] < target:
+            elif arr[i] + arr[left] + arr[right] < target:
-                left += 1
+                left += 1
-            elif arr[i] + arr[left] + arr[right] > target:
+            elif arr[i] + arr[left] + arr[right] > target:
-                right -= 1
+                right -= 1
-    return (0, 0, 0)
+    return (0, 0, 0)
-
+
-
+
-def solution_times() -> tuple[float, float]:
+def solution_times() -> tuple[float, float]:
-    setup_code = """
+    setup_code = """
-from __main__ import dataset, triplet_sum1, triplet_sum2
+from __main__ import dataset, triplet_sum1, triplet_sum2
-"""
+"""
-    test_code1 = """
+    test_code1 = """
-triplet_sum1(*dataset)
+triplet_sum1(*dataset)
-"""
+"""
-    test_code2 = """
+    test_code2 = """
-triplet_sum2(*dataset)
+triplet_sum2(*dataset)
-"""
+"""
-    times1 = repeat(setup=setup_code, stmt=test_code1, repeat=5, number=10000)
+    times1 = repeat(setup=setup_code, stmt=test_code1, repeat=5, number=10000)
-    times2 = repeat(setup=setup_code, stmt=test_code2, repeat=5, number=10000)
+    times2 = repeat(setup=setup_code, stmt=test_code2, repeat=5, number=10000)
-    return (min(times1), min(times2))
+    return (min(times1), min(times2))
-
+
-
+
-if __name__ == "__main__":
+if __name__ == "__main__":
-    from doctest import testmod
+    from doctest import testmod
-
+
-    testmod()
+    testmod()
-    times = solution_times()
+    times = solution_times()
-    print(f"The time for naive implementation is {times[0]}.")
+    print(f"The time for naive implementation is {times[0]}.")
-    print(f"The time for optimized implementation is {times[1]}.")
+    print(f"The time for optimized implementation is {times[1]}.")