




import functools
from math import sqrt
from time import time


def 							__SCREAMING_SNAKE_CASE  (      snake_case_     ,   *snake_case_     ,   **snake_case_						):

						'''simple docstring'''


						_UpperCAmelCase													=					time()
						_UpperCAmelCase													=					func(*snake_case_     ,   **snake_case_						)
						_UpperCAmelCase													=					time()
						if int(end - start						) > 0:
												print(f"""{func.__name__} runtime: {(end - start):0.4f} s"""						)
						else:
												print(f"""{func.__name__} runtime: {(end - start) * 1000:0.4f} ms"""						)
						return output


def 							__SCREAMING_SNAKE_CASE  (      snake_case_						):

						'''simple docstring'''


						if n < 0:
												raise Exception("n is negative"						)
						if n == 0:
												return [0]
						_UpperCAmelCase													=					[0, 1]
						for _ in range(n - 1						):
												fib.append(fib[-1] + fib[-2]						)
						return fib


def 							__SCREAMING_SNAKE_CASE  (      snake_case_						):

						'''simple docstring'''


						def fib_recursive_term(snake_case_						) -> int:
												if i < 0:
																		raise Exception("n is negative"						)
												if i < 2:
																		return i
												return fib_recursive_term(i - 1						) + fib_recursive_term(i - 2						)

						if n < 0:
												raise Exception("n is negative"						)
						return [fib_recursive_term(snake_case_						) for i in range(n + 1						)]


def 							__SCREAMING_SNAKE_CASE  (      snake_case_						):

						'''simple docstring'''


						@functools.cache
						def fib_recursive_term(snake_case_						) -> int:
												if i < 0:
																		raise Exception("n is negative"						)
												if i < 2:
																		return i
												return fib_recursive_term(i - 1						) + fib_recursive_term(i - 2						)

						if n < 0:
												raise Exception("n is negative"						)
						return [fib_recursive_term(snake_case_						) for i in range(n + 1						)]


def 							__SCREAMING_SNAKE_CASE  (      snake_case_						):

						'''simple docstring'''


						if n < 0:
												raise Exception("n is negative"						)
						# Cache must be outside recursuive function
						# other it will reset every time it calls itself.
						_UpperCAmelCase													=					{0: 0, 1: 1, 2: 1}  # Prefilled cache

						def rec_fn_memoized(snake_case_						) -> int:
												if num in cache:
																		return cache[num]

												_UpperCAmelCase													=					rec_fn_memoized(num - 1						) + rec_fn_memoized(num - 2						)
												_UpperCAmelCase													=					value
												return value

						return [rec_fn_memoized(snake_case_						) for i in range(n + 1						)]


def 							__SCREAMING_SNAKE_CASE  (      snake_case_						):

						'''simple docstring'''


						if n < 0:
												raise Exception("n is negative"						)
						if n >= 1475:
												raise Exception("n is too large"						)
						_UpperCAmelCase													=					sqrt(5						)
						_UpperCAmelCase													=					(1 + sqrt_a) / 2
						return [round(phi**i / sqrt_a						) for i in range(n + 1						)]


if __name__ == "__main__":
				lowercase_     :    List[Any]      =			30
				time_func(fib_iterative, num)
				time_func(fib_recursive, num)  # Around 3s runtime
				time_func(fib_recursive_cached, num)  # Around 0ms runtime
				time_func(fib_memoization, num)
				time_func(fib_binet, num)










class    __lowerCAmelCase			:







			def __init__(	self   :      Dict   ,   snake_case__   :      List[str]=None				):




									"""simple docstring"""


									_UpperCAmelCase													=					data
									_UpperCAmelCase													=					None







			def __repr__(	self   :      Union[str, Any]				):




									"""simple docstring"""


									_UpperCAmelCase													=					""
									_UpperCAmelCase													=					self
									while temp:
															string_rep += F"""<{temp.data}> ---> """
															_UpperCAmelCase													=					temp.next
									string_rep += "<END>"
									return string_rep




def 							__SCREAMING_SNAKE_CASE  (      snake_case_						):

						'''simple docstring'''


						if not elements_list:
												raise Exception("The Elements List is empty"						)

						# Set first element as Head
						_UpperCAmelCase													=					Node(elements_list[0]						)
						_UpperCAmelCase													=					head
						# Loop through elements from position 1
						for data in elements_list[1:]:
												_UpperCAmelCase													=					Node(snake_case_						)
												_UpperCAmelCase													=					current.next
						return head


lowercase_     :    str      =			[1, 3, 5, 32, 44, 12, 43]
print(f"""List: {list_data}""")
print('Creating Linked List from List.')
lowercase_     :    Dict      =			make_linked_list(list_data)
print('Linked List:')





print(linked_list)




