



"""simple docstring"""







def      __UpperCAmelCase      (    __lowerCamelCase	)							->      None:
		lowercase__   :    Optional[Any]				=			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      __UpperCAmelCase      (    __lowerCamelCase	)							->      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'''	)

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



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



def      __UpperCAmelCase      (    __lowerCamelCase						,     __lowerCamelCase						,     __lowerCamelCase						,     __lowerCamelCase						,     )							->      None:
		lowercase__   :    Optional[Any]				=			triangle[current_row_idx - 1][current_col_idx - 1]
		lowercase__   :    Dict				=			triangle[current_row_idx - 1][current_col_idx]
		lowercase__   :    Dict				=			above_to_left_elt + above_to_right_elt



def      __UpperCAmelCase      (    __lowerCamelCase	)							->      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'''	)

		lowercase__   :    list[list[int]]				=			[[1]]

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

		return result



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

		def benchmark_a_function(__lowerCamelCase						,     __lowerCamelCase	) -> None:
				lowercase__   :    str				=			f"""{func.__name__}({value})"""
				lowercase__   :    Optional[int]				=			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()






def SCREAMING_SNAKE_CASE				(       lowercase_ ,				lowercase_						)   ->       int:



       """simple docstring"""

       return int(input_a == input_a == 0						)







def SCREAMING_SNAKE_CASE				(       )   ->       None:



       """simple docstring"""

       print('''Truth Table of NOR Gate:'''						)
       print('''|   Input 1   |  Input 2  | Output |'''						)
       print(f"""|      0      |    0      |  {nor_gate(0 ,				0						)}     |"""						)
       print(f"""|      0      |    1      |  {nor_gate(0 ,				1						)}     |"""						)
       print(f"""|      1      |    0      |  {nor_gate(1 ,				0						)}     |"""						)
       print(f"""|      1      |    1      |  {nor_gate(1 ,				1						)}     |"""						)


if __name__ == "__main__":
  import doctest

  doctest.testmod()
  main()


