psf/black changes to next_greater_element.py

data_structures/stacks/next_greater_element.py

@@ -1,11 +1,14 @@
 arr = [-10, -5, 0, 5, 5.1, 11, 13, 21, 3, 4, -21, -10, -5, -1, 0]
+expect = [-5, 0, 5, 5.1, 11, 13, 21, -1, 4, -1, -10, -5, -1, 0, -1]
 
-def next_greatest_element_slow(arr):
+
+def next_greatest_element_slow(arr: list) -> list:
     """
-    Function to get Next Greatest Element (NGE) pair for all elements of list
-    Maximum element present afterwards the current one which is also greater than current one
-    >>> next_greatest_element_slow(arr)
-    [-5, 0, 5, 5.1, 11, 13, 21, -1, 4, -1, -10, -5, -1, 0, -1]
+    Get the Next Greatest Element (NGE) for all elements in a list.
+    Maximum element present after the current one which is also greater than the
+    current one.
+    >>> next_greatest_element_slow(arr) == expect
+    True
     """
     result = []
     for i in range(0, len(arr), 1):
@@ -18,39 +21,40 @@ def next_greatest_element_slow(arr):
     return result
 
 
-def next_greatest_element_fast(arr):
+def next_greatest_element_fast(arr: list) -> list:
     """
     Like next_greatest_element_slow() but changes the loops to use
     enumerate() instead of range(len()) for the outer loop and
     for in a slice of arr for the inner loop.
-    >>> next_greatest_element_fast(arr)
-    [-5, 0, 5, 5.1, 11, 13, 21, -1, 4, -1, -10, -5, -1, 0, -1]
+    >>> next_greatest_element_fast(arr) == expect
+    True
     """
     result = []
     for i, outer in enumerate(arr):
         next = -1
-        for inner in arr[i + 1:]:
+        for inner in arr[i + 1 :]:
             if outer < inner:
                 next = inner
                 break
         result.append(next)
     return result
 
 
-def next_greatest_element(arr):
+def next_greatest_element(arr: list) -> list:
     """
-    Function to get Next Greatest Element (NGE) pair for all elements of list
-    Maximum element present afterwards the current one which is also greater than current one
-
-    Naive way to solve this is to take two loops and check for the next bigger number but that will make the
-    time complexity as O(n^2). The better way to solve this would be to use a stack to keep track of maximum
-    number givig a linear time complex solution.
-
-    >>> next_greatest_element(arr)
-    [-5, 0, 5, 5.1, 11, 13, 21, -1, 4, -1, -10, -5, -1, 0, -1]
+    Get the Next Greatest Element (NGE) for all elements in a list.
+    Maximum element present after the current one which is also greater than the
+    current one.
+
+    A naive way to solve this is to take two loops and check for the next bigger
+    number but that will make the time complexity as O(n^2). The better way to solve
+    this would be to use a stack to keep track of maximum number giving a linear time
+    solution.
+    >>> next_greatest_element(arr) == expect
+    True
     """
-    stack = []              
-    result = [-1]*len(arr)
+    stack = []
+    result = [-1] * len(arr)
 
     for index in reversed(range(len(arr))):
         if len(stack):
@@ -63,7 +67,7 @@ def next_greatest_element(arr):
             result[index] = stack[-1]
 
         stack.append(arr[index])
-        
+
     return result
 
 
@@ -76,11 +80,19 @@ def next_greatest_element(arr):
     print(next_greatest_element_fast(arr))
     print(next_greatest_element(arr))
 
-    setup = ("from __main__ import arr, next_greatest_element_slow, "
-             "next_greatest_element_fast, next_greatest_element")
-    print("next_greatest_element_slow():",
-          timeit("next_greatest_element_slow(arr)", setup=setup))
-    print("next_greatest_element_fast():",
-          timeit("next_greatest_element_fast(arr)", setup=setup))
-    print("     next_greatest_element():",
-          timeit("next_greatest_element(arr)", setup=setup))
+    setup = (
+        "from __main__ import arr, next_greatest_element_slow, "
+        "next_greatest_element_fast, next_greatest_element"
+    )
+    print(
+        "next_greatest_element_slow():",
+        timeit("next_greatest_element_slow(arr)", setup=setup),
+    )
+    print(
+        "next_greatest_element_fast():",
+        timeit("next_greatest_element_fast(arr)", setup=setup),
+    )
+    print(
+        "     next_greatest_element():",
+        timeit("next_greatest_element(arr)", setup=setup),
+    )

maths/allocation_number.py

@@ -38,19 +38,21 @@ def allocation_num(number_of_bytes: int, partitions: int) -> List[str]:
     ValueError: partitions must be a positive number!
     """
     if partitions <= 0:
-        raise ValueError('partitions must be a positive number!')
+        raise ValueError("partitions must be a positive number!")
     if partitions >= number_of_bytes:
-        raise ValueError('partitions can not >= number_of_bytes!')
+        raise ValueError("partitions can not >= number_of_bytes!")
     bytes_per_partition = number_of_bytes // partitions
-    allocation_list = [f'0-{bytes_per_partition}']
+    allocation_list = [f"0-{bytes_per_partition}"]
     for i in range(1, partitions - 1):
-        length = f'{bytes_per_partition * i + 1}-{bytes_per_partition * (i + 1)}'
+        length = f"{bytes_per_partition * i + 1}-{bytes_per_partition * (i + 1)}"
         allocation_list.append(length)
-    allocation_list.append(f'{(bytes_per_partition * (partitions - 1)) + 1}-'
-                           f'{number_of_bytes}')
+    allocation_list.append(
+        f"{(bytes_per_partition * (partitions - 1)) + 1}-" f"{number_of_bytes}"
+    )
     return allocation_list
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     import doctest
+
     doctest.testmod()