From f17e9822b08a0b1d811d1a638f3de1ac26c511d8 Mon Sep 17 00:00:00 2001 From: Christian Clauss Date: Sat, 28 Mar 2020 07:24:59 +0100 Subject: [PATCH] psf/black changes to next_greater_element.py (#1817) * psf/black changes to next_greater_element.py * fixup! Format Python code with psf/black push Co-authored-by: github-actions <${GITHUB_ACTOR}@users.noreply.github.com> --- .../stacks/next_greater_element.py | 72 +++++++++++-------- maths/allocation_number.py | 16 +++-- 2 files changed, 51 insertions(+), 37 deletions(-) diff --git a/data_structures/stacks/next_greater_element.py b/data_structures/stacks/next_greater_element.py index 4b400334e..d8c7ed173 100644 --- a/data_structures/stacks/next_greater_element.py +++ b/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,18 +21,18 @@ 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 @@ -37,20 +40,21 @@ def next_greatest_element_fast(arr): 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 @@ if __name__ == "__main__": 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), + ) diff --git a/maths/allocation_number.py b/maths/allocation_number.py index 04a8f1dac..fd002b0c4 100644 --- a/maths/allocation_number.py +++ b/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()