





'''simple docstring'''


def    _lowerCamelCase  (__lowerCamelCase  :     int     )   ->    None:
			a__     = generate_pascal_triangle(__lowerCamelCase     )
			for row_idx in range(__lowerCamelCase     ):
						# Print left spaces
						for _ in range(num_rows - row_idx - 1     ):
									print(end=" "     )
						# Print row values
						for col_idx in range(row_idx + 1     ):
									if col_idx != row_idx:
												print(triangle[row_idx][col_idx]					,  end=" "     )
									else:
												print(triangle[row_idx][col_idx]					,  end=""     )
						print()







def    _lowerCamelCase  (__lowerCamelCase  :     int     )   ->    list[list[int]]:

			if not isinstance(__lowerCamelCase					,  __lowerCamelCase     ):
						raise TypeError("The input value of 'num_rows' should be 'int'"     )

			if num_rows == 0:
						return []
			elif num_rows < 0:
						raise ValueError(
						    "The input value of 'num_rows' should be greater than or equal to 0"     )

			a__     = []
			for current_row_idx in range(__lowerCamelCase     ):
						a__     = populate_current_row(__lowerCamelCase					,  __lowerCamelCase     )
						triangle.append(__lowerCamelCase     )
			return triangle







def    _lowerCamelCase  (__lowerCamelCase  :     list[list[int]]					,  __lowerCamelCase  :     int     )   ->    list[int]:
			a__     = [-1] * (current_row_idx + 1)
			# first and last elements of current row are equal to 1
			a__   ,				a__     = 1, 1
			for current_col_idx in range(1					,  __lowerCamelCase     ):
						calculate_current_element(
						    __lowerCamelCase					,  __lowerCamelCase					,  __lowerCamelCase					,  __lowerCamelCase     )
			return current_row







def    _lowerCamelCase  (__lowerCamelCase  :     list[list[int]]					,  __lowerCamelCase  :     list[int]					,  __lowerCamelCase  :     int					,  __lowerCamelCase  :     int					,  )   ->    None:
			a__     = triangle[current_row_idx - 1][current_col_idx - 1]
			a__     = triangle[current_row_idx - 1][current_col_idx]
			a__     = above_to_left_elt + above_to_right_elt







def    _lowerCamelCase  (__lowerCamelCase  :     int     )   ->    list[list[int]]:

			if not isinstance(__lowerCamelCase					,  __lowerCamelCase     ):
						raise TypeError("The input value of 'num_rows' should be 'int'"     )

			if num_rows == 0:
						return []
			elif num_rows < 0:
						raise ValueError(
						    "The input value of 'num_rows' should be greater than or equal to 0"     )

			a__     = [[1]]

			for row_index in range(1					,  __lowerCamelCase     ):
						a__     = [0] + result[-1] + [0]
						a__     = row_index + 1
						# Calculate the number of distinct elements in a row
						a__     = sum(divmod(__lowerCamelCase					,  2     )     )
						a__     = [
						    temp_row[i - 1] + temp_row[i] for i in range(1					,  distinct_elements + 1     )
						]
						a__     = row_first_half[: (row_index + 1) // 2]
						row_second_half.reverse()
						a__     = row_first_half + row_second_half
						result.append(__lowerCamelCase     )

			return result







def    _lowerCamelCase  ()   ->    None:
			from collections.abc import Callable
			from timeit import timeit

			def benchmark_a_function(__lowerCamelCase  :     Callable					,  __lowerCamelCase  :     int     ) -> None:
						a__     = f'''{func.__name__}({value})'''
						a__     = timeit(f'''__main__.{call}'''					,  setup="import __main__"     )
						# print(f"{call:38} = {func(value)} -- {timing:.4f} seconds")
						print(f'''{call:38} -- {timing:.4f} seconds'''     )

			for value in range(15     ):  # (1, 7, 14):
						for func in (generate_pascal_triangle, generate_pascal_triangle_optimized):
									benchmark_a_function(__lowerCamelCase					,  __lowerCamelCase     )
						print()


if __name__ == "__main__":
		import doctest

		doctest.testmod()
		benchmark()










'''simple docstring'''


class       UpperCamelCase__  :







	def __init__(				self			:   str , lowerCamelCase			:   int , lowerCamelCase			:   List[str]=None , lowerCamelCase			:   int=None		):




				'''simple docstring'''
				a__     = data
				a__     = previous
				a__     = next_node







	def __str__(				self			:   List[Any]		):




				'''simple docstring'''
				return F'''{self.data}'''







	def 						__a   (				self			:   List[Any]		):




				'''simple docstring'''
				return self.data







	def 						__a   (				self			:   Tuple		):




				'''simple docstring'''
				return self.next







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




				'''simple docstring'''
				return self.previous






class       UpperCamelCase__  :







	def __init__(				self			:   int , lowerCamelCase			:   Tuple		):




				'''simple docstring'''
				a__     = head







	def __iter__(				self			:   Any		):




				'''simple docstring'''
				return self







	def 						__a   (				self			:   List[Any]		):




				'''simple docstring'''
				if not self.current:
							raise StopIteration
				else:
							a__     = self.current.get_data()
							a__     = self.current.get_next()
							return value






class       UpperCamelCase__  :







	def __init__(				self			:   Tuple		):




				'''simple docstring'''
				a__     = None  # First node in list
				a__     = None  # Last node in list







	def __str__(				self			:   Any		):




				'''simple docstring'''
				a__     = self.head
				a__     = []
				while current is not None:
							nodes.append(current.get_data()		)
							a__     = current.get_next()
				return " ".join(str(lowerCamelCase		) for node in nodes		)







	def __contains__(				self			:   Optional[int] , lowerCamelCase			:   int		):




				'''simple docstring'''
				a__     = self.head
				while current:
							if current.get_data() == value:
										return True
							a__     = current.get_next()
				return False







	def __iter__(				self			:   int		):




				'''simple docstring'''
				return LinkedListIterator(self.head		)







	def 						__a   (				self			:   str		):




				'''simple docstring'''
				if self.head:
							return self.head.get_data()
				return None







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




				'''simple docstring'''
				if self.tail:
							return self.tail.get_data()
				return None







	def 						__a   (				self			:   List[Any] , lowerCamelCase			:   Node		):




				'''simple docstring'''
				if self.head is None:
							a__     = node
							a__     = node
				else:
							self.insert_before_node(self.head , lowerCamelCase		)







	def 						__a   (				self			:   List[str] , lowerCamelCase			:   Node		):




				'''simple docstring'''
				if self.head is None:
							self.set_head(lowerCamelCase		)
				else:
							self.insert_after_node(self.tail , lowerCamelCase		)







	def 						__a   (				self			:   List[str] , lowerCamelCase			:   int		):




				'''simple docstring'''
				a__     = Node(lowerCamelCase		)
				if self.head is None:
							self.set_head(lowerCamelCase		)
				else:
							self.set_tail(lowerCamelCase		)







	def 						__a   (				self			:   Any , lowerCamelCase			:   Node , lowerCamelCase			:   Node		):




				'''simple docstring'''
				a__     = node
				a__     = node.previous

				if node.get_previous() is None:
							a__     = node_to_insert
				else:
							a__     = node_to_insert

				a__     = node_to_insert







	def 						__a   (				self			:   Tuple , lowerCamelCase			:   Node , lowerCamelCase			:   Node		):




				'''simple docstring'''
				a__     = node
				a__     = node.next

				if node.get_next() is None:
							a__     = node_to_insert
				else:
							a__     = node_to_insert

				a__     = node_to_insert







	def 						__a   (				self			:   Union[str, Any] , lowerCamelCase			:   int , lowerCamelCase			:   int		):




				'''simple docstring'''
				a__     = 1
				a__     = Node(lowerCamelCase		)
				a__     = self.head
				while node:
							if current_position == position:
										self.insert_before_node(lowerCamelCase , lowerCamelCase		)
										return
							current_position += 1
							a__     = node.next
				self.insert_after_node(self.tail , lowerCamelCase		)







	def 						__a   (				self			:   List[Any] , lowerCamelCase			:   int		):




				'''simple docstring'''
				a__     = self.head
				while node:
							if node.get_data() == item:
										return node
							a__     = node.get_next()
				raise Exception("Node not found"		)







	def 						__a   (				self			:   List[Any] , lowerCamelCase			:   List[str]		):




				'''simple docstring'''
				if (node := self.get_node(lowerCamelCase		)) is not None:
							if node == self.head:
										a__     = self.head.get_next()

							if node == self.tail:
										a__     = self.tail.get_previous()

							self.remove_node_pointers(lowerCamelCase		)







	@staticmethod
	def 						__a   (				lowerCamelCase			:   Node		):




				'''simple docstring'''
				if node.get_next():
							a__     = node.previous

				if node.get_previous():
							a__     = node.next

				a__     = None
				a__     = None







	def 						__a   (				self			:   List[str]		):




				'''simple docstring'''
				return self.head is None







def    _lowerCamelCase  ()   ->    None:
			pass


if __name__ == "__main__":
		import doctest

		doctest.testmod()



