




def  lowerCAmelCase_ (							UpperCamelCase_  )     ->		None:
       UpperCamelCase_          =  generate_pascal_triangle(UpperCamelCase_  )
       for row_idx in range(UpperCamelCase_  ):
              # 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_ (							UpperCamelCase_  )     ->		list[list[int]]:

       if not isinstance(UpperCamelCase_					,		UpperCamelCase_  ):
              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"  )

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




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




def  lowerCAmelCase_ (							UpperCamelCase_					,		UpperCamelCase_					,		UpperCamelCase_					,		UpperCamelCase_					,		)     ->		None:
       UpperCamelCase_          =  triangle[current_row_idx - 1][current_col_idx - 1]
       UpperCamelCase_          =  triangle[current_row_idx - 1][current_col_idx]
       UpperCamelCase_          =  above_to_left_elt + above_to_right_elt




def  lowerCAmelCase_ (							UpperCamelCase_  )     ->		list[list[int]]:

       if not isinstance(UpperCamelCase_					,		UpperCamelCase_  ):
              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"  )

       UpperCamelCase_          =  [[1]]

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

       return result




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

       def benchmark_a_function(UpperCamelCase_					,		UpperCamelCase_  ) -> None:
              UpperCamelCase_          =  F'''{func.__name__}({value})'''
              UpperCamelCase_          =  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(UpperCamelCase_					,		UpperCamelCase_  )
              print()


if __name__ == "__main__":
     import doctest

     doctest.testmod()
     benchmark()








import random
from typing import Any




def  lowerCAmelCase_ (							UpperCamelCase_  )     ->		list[Any]:
       for _ in range(len(UpperCamelCase_  )  ):
              UpperCamelCase_          =  random.randint(0					,		len(UpperCamelCase_  ) - 1  )
              UpperCamelCase_          =  random.randint(0					,		len(UpperCamelCase_  ) - 1  )
              UpperCamelCase_       , UpperCamelCase_          =  data[b], data[a]
       return data


if __name__ == "__main__":
     _UpperCAmelCase        =				[0, 1, 2, 3, 4, 5, 6, 7]
     _UpperCAmelCase        =				['python', 'says', 'hello', '!']
     print('Fisher-Yates Shuffle:')
     print('List', integers, strings)
     print('FY Shuffle', fisher_yates_shuffle(integers), fisher_yates_shuffle(strings))

