mathdatech/Python
1
0
Fork 0
mirror of https://github.com/TheAlgorithms/Python.git synced 2025-02-17 14:58:10 +00:00
Code Issues Packages Projects Releases Wiki Activity

psf/black changes to next_greater_element.py (#1817)

Browse Source 
* 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>
This commit is contained in:
Christian Clauss 2020-03-28 07:24:59 +01:00 committed by GitHub
parent 96df906e7a
commit f17e9822b0
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
2 changed files with 51 additions and 37 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

62
data_structures/stacks/next_greater_element.py
View File

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

16
maths/allocation_number.py
View File

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