diff --git a/other/binary_exponentiation_2.py b/maths/binary_exponentiation_2.py
similarity index 100%
rename from other/binary_exponentiation_2.py
rename to maths/binary_exponentiation_2.py
diff --git a/other/binary_exponentiation.py b/maths/binary_exponentiation_3.py
similarity index 100%
rename from other/binary_exponentiation.py
rename to maths/binary_exponentiation_3.py
diff --git a/other/euclidean_gcd.py b/maths/euclidean_gcd.py
similarity index 100%
rename from other/euclidean_gcd.py
rename to maths/euclidean_gcd.py
diff --git a/other/integeration_by_simpson_approx.py b/maths/integration_by_simpson_approx.py
similarity index 100%
rename from other/integeration_by_simpson_approx.py
rename to maths/integration_by_simpson_approx.py
diff --git a/other/largest_subarray_sum.py b/maths/largest_subarray_sum.py
similarity index 100%
rename from other/largest_subarray_sum.py
rename to maths/largest_subarray_sum.py
diff --git a/other/max_sum_sliding_window.py b/maths/max_sum_sliding_window.py
similarity index 96%
rename from other/max_sum_sliding_window.py
rename to maths/max_sum_sliding_window.py
index 4be7d786f..593cb5c8b 100644
--- a/other/max_sum_sliding_window.py
+++ b/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
-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
-called 'Window sliding technique' where the nested loops can be converted to a single
-loop to reduce time complexity.
-"""
-from typing import List
-
-
-def max_sum_in_array(array: List[int], k: int) -> int:
-    """
-    Returns the maximum sum of k consecutive elements
-    >>> arr = [1, 4, 2, 10, 2, 3, 1, 0, 20]
-    >>> k = 4
-    >>> max_sum_in_array(arr, k)
-    24
-    >>> k = 10
-    >>> max_sum_in_array(arr,k)
-    Traceback (most recent call last):
-        ...
-    ValueError: Invalid Input
-    >>> arr = [1, 4, 2, 10, 2, 13, 1, 0, 2]
-    >>> k = 4
-    >>> max_sum_in_array(arr, k)
-    27
-    """
-    if len(array) < k or k < 0:
-        raise ValueError("Invalid Input")
-    max_sum = current_sum = sum(array[:k])
-    for i in range(len(array) - k):
-        current_sum = current_sum - array[i] + array[i + k]
-        max_sum = max(max_sum, current_sum)
-    return max_sum
-
-
-if __name__ == "__main__":
-    from doctest import testmod
-    from random import randint
-
-    testmod()
-    array = [randint(-1000, 1000) for i in range(100)]
-    k = randint(0, 110)
-    print(f"The maximum sum of {k} consecutive elements is {max_sum_in_array(array,k)}")
+"""
+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.
+
+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
+loop to reduce time complexity.
+"""
+from typing import List
+
+
+def max_sum_in_array(array: List[int], k: int) -> int:
+    """
+    Returns the maximum sum of k consecutive elements
+    >>> arr = [1, 4, 2, 10, 2, 3, 1, 0, 20]
+    >>> k = 4
+    >>> max_sum_in_array(arr, k)
+    24
+    >>> k = 10
+    >>> max_sum_in_array(arr,k)
+    Traceback (most recent call last):
+        ...
+    ValueError: Invalid Input
+    >>> arr = [1, 4, 2, 10, 2, 13, 1, 0, 2]
+    >>> k = 4
+    >>> max_sum_in_array(arr, k)
+    27
+    """
+    if len(array) < k or k < 0:
+        raise ValueError("Invalid Input")
+    max_sum = current_sum = sum(array[:k])
+    for i in range(len(array) - k):
+        current_sum = current_sum - array[i] + array[i + k]
+        max_sum = max(max_sum, current_sum)
+    return max_sum
+
+
+if __name__ == "__main__":
+    from doctest import testmod
+    from random import randint
+
+    testmod()
+    array = [randint(-1000, 1000) for i in range(100)]
+    k = randint(0, 110)
+    print(f"The maximum sum of {k} consecutive elements is {max_sum_in_array(array,k)}")
diff --git a/other/median_of_two_arrays.py b/maths/median_of_two_arrays.py
similarity index 100%
rename from other/median_of_two_arrays.py
rename to maths/median_of_two_arrays.py
diff --git a/other/primelib.py b/maths/primelib.py
similarity index 100%
rename from other/primelib.py
rename to maths/primelib.py
diff --git a/other/triplet_sum.py b/maths/triplet_sum.py
similarity index 96%
rename from other/triplet_sum.py
rename to maths/triplet_sum.py
index 0e78bb52b..22fab17d3 100644
--- a/other/triplet_sum.py
+++ b/maths/triplet_sum.py
@@ -1,89 +1,89 @@
-"""
-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
-the target.
-"""
-from __future__ import annotations
-
-from itertools import permutations
-from random import randint
-from timeit import repeat
-
-
-def make_dataset() -> tuple[list[int], int]:
-    arr = [randint(-1000, 1000) for i in range(10)]
-    r = randint(-5000, 5000)
-    return (arr, r)
-
-
-dataset = make_dataset()
-
-
-def triplet_sum1(arr: list[int], target: int) -> tuple[int, int, int]:
-    """
-    Returns a triplet in the array with sum equal to target,
-    else (0, 0, 0).
-    >>> triplet_sum1([13, 29, 7, 23, 5], 35)
-    (5, 7, 23)
-    >>> triplet_sum1([37, 9, 19, 50, 44], 65)
-    (9, 19, 37)
-    >>> arr = [6, 47, 27, 1, 15]
-    >>> target = 11
-    >>> triplet_sum1(arr, target)
-    (0, 0, 0)
-    """
-    for triplet in permutations(arr, 3):
-        if sum(triplet) == target:
-            return tuple(sorted(triplet))
-    return (0, 0, 0)
-
-
-def triplet_sum2(arr: list[int], target: int) -> tuple[int, int, int]:
-    """
-    Returns a triplet in the array with sum equal to target,
-    else (0, 0, 0).
-    >>> triplet_sum2([13, 29, 7, 23, 5], 35)
-    (5, 7, 23)
-    >>> triplet_sum2([37, 9, 19, 50, 44], 65)
-    (9, 19, 37)
-    >>> arr = [6, 47, 27, 1, 15]
-    >>> target = 11
-    >>> triplet_sum2(arr, target)
-    (0, 0, 0)
-    """
-    arr.sort()
-    n = len(arr)
-    for i in range(n - 1):
-        left, right = i + 1, n - 1
-        while left < right:
-            if arr[i] + arr[left] + arr[right] == target:
-                return (arr[i], arr[left], arr[right])
-            elif arr[i] + arr[left] + arr[right] < target:
-                left += 1
-            elif arr[i] + arr[left] + arr[right] > target:
-                right -= 1
-    return (0, 0, 0)
-
-
-def solution_times() -> tuple[float, float]:
-    setup_code = """
-from __main__ import dataset, triplet_sum1, triplet_sum2
-"""
-    test_code1 = """
-triplet_sum1(*dataset)
-"""
-    test_code2 = """
-triplet_sum2(*dataset)
-"""
-    times1 = repeat(setup=setup_code, stmt=test_code1, repeat=5, number=10000)
-    times2 = repeat(setup=setup_code, stmt=test_code2, repeat=5, number=10000)
-    return (min(times1), min(times2))
-
-
-if __name__ == "__main__":
-    from doctest import testmod
-
-    testmod()
-    times = solution_times()
-    print(f"The time for naive implementation is {times[0]}.")
-    print(f"The time for optimized implementation is {times[1]}.")
+"""
+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
+the target.
+"""
+from __future__ import annotations
+
+from itertools import permutations
+from random import randint
+from timeit import repeat
+
+
+def make_dataset() -> tuple[list[int], int]:
+    arr = [randint(-1000, 1000) for i in range(10)]
+    r = randint(-5000, 5000)
+    return (arr, r)
+
+
+dataset = make_dataset()
+
+
+def triplet_sum1(arr: list[int], target: int) -> tuple[int, int, int]:
+    """
+    Returns a triplet in the array with sum equal to target,
+    else (0, 0, 0).
+    >>> triplet_sum1([13, 29, 7, 23, 5], 35)
+    (5, 7, 23)
+    >>> triplet_sum1([37, 9, 19, 50, 44], 65)
+    (9, 19, 37)
+    >>> arr = [6, 47, 27, 1, 15]
+    >>> target = 11
+    >>> triplet_sum1(arr, target)
+    (0, 0, 0)
+    """
+    for triplet in permutations(arr, 3):
+        if sum(triplet) == target:
+            return tuple(sorted(triplet))
+    return (0, 0, 0)
+
+
+def triplet_sum2(arr: list[int], target: int) -> tuple[int, int, int]:
+    """
+    Returns a triplet in the array with sum equal to target,
+    else (0, 0, 0).
+    >>> triplet_sum2([13, 29, 7, 23, 5], 35)
+    (5, 7, 23)
+    >>> triplet_sum2([37, 9, 19, 50, 44], 65)
+    (9, 19, 37)
+    >>> arr = [6, 47, 27, 1, 15]
+    >>> target = 11
+    >>> triplet_sum2(arr, target)
+    (0, 0, 0)
+    """
+    arr.sort()
+    n = len(arr)
+    for i in range(n - 1):
+        left, right = i + 1, n - 1
+        while left < right:
+            if arr[i] + arr[left] + arr[right] == target:
+                return (arr[i], arr[left], arr[right])
+            elif arr[i] + arr[left] + arr[right] < target:
+                left += 1
+            elif arr[i] + arr[left] + arr[right] > target:
+                right -= 1
+    return (0, 0, 0)
+
+
+def solution_times() -> tuple[float, float]:
+    setup_code = """
+from __main__ import dataset, triplet_sum1, triplet_sum2
+"""
+    test_code1 = """
+triplet_sum1(*dataset)
+"""
+    test_code2 = """
+triplet_sum2(*dataset)
+"""
+    times1 = repeat(setup=setup_code, stmt=test_code1, repeat=5, number=10000)
+    times2 = repeat(setup=setup_code, stmt=test_code2, repeat=5, number=10000)
+    return (min(times1), min(times2))
+
+
+if __name__ == "__main__":
+    from doctest import testmod
+
+    testmod()
+    times = solution_times()
+    print(f"The time for naive implementation is {times[0]}.")
+    print(f"The time for optimized implementation is {times[1]}.")
diff --git a/other/two_pointer.py b/maths/two_pointer.py
similarity index 100%
rename from other/two_pointer.py
rename to maths/two_pointer.py
diff --git a/other/two_sum.py b/maths/two_sum.py
similarity index 100%
rename from other/two_sum.py
rename to maths/two_sum.py