mathdatech/Python
1
0
Fork 0
mirror of https://github.com/TheAlgorithms/Python.git synced 2024-11-23 21:11:08 +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

72
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]
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),
)

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!
"""
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()