


def    snake_case_     (  snake_case     )  ->				None:
       lowercase__:   List[str]  			=   generate_pascal_triangle(snake_case     )
       for row_idx in range(snake_case     ):
              # 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    snake_case_     (  snake_case     )  ->				list[list[int]]:

       if not isinstance(snake_case			,							snake_case     ):
              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(snake_case     ):
              lowercase__:   Tuple  			=   populate_current_row(snake_case			,							snake_case     )
              triangle.append(snake_case     )
       return triangle




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




def    snake_case_     (  snake_case			,							snake_case			,							snake_case			,							snake_case			,							)  ->				None:
       lowercase__:   List[str]  			=   triangle[current_row_idx - 1][current_col_idx - 1]
       lowercase__:   List[Any]  			=   triangle[current_row_idx - 1][current_col_idx]
       lowercase__:   List[Any]  			=   above_to_left_elt + above_to_right_elt




def    snake_case_     (  snake_case     )  ->				list[list[int]]:

       if not isinstance(snake_case			,							snake_case     ):
              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			,							snake_case     ):
              lowercase__:   Any  			=   [0] + result[-1] + [0]
              lowercase__:   Union[str, Any]  			=   row_index + 1
              # Calculate the number of distinct elements in a row
              lowercase__:   str  			=   sum(divmod(snake_case			,							2     )     )
              lowercase__:   str  			=   [
                  temp_row[i - 1] + temp_row[i] for i in range(1			,							distinct_elements + 1     )
              ]
              lowercase__:   Optional[Any]  			=   row_first_half[: (row_index + 1) // 2]
              row_second_half.reverse()
              lowercase__:   Union[str, Any]  			=   row_first_half + row_second_half
              result.append(snake_case     )

       return result




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

       def benchmark_a_function(snake_case			,							snake_case     ) -> None:
              lowercase__:   str  			=   f'{func.__name__}({value})'
              lowercase__:   List[Any]  			=   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(snake_case			,							snake_case     )
              print()


if __name__ == "__main__":
 import doctest

 doctest.testmod()
 benchmark()






import unittest

from knapsack import knapsack as k





class   __a			(    unittest.TestCase      ):
 def 		SCREAMING_SNAKE_CASE__   (   self )					->				Tuple:




        '''simple docstring'''
        lowercase__:   List[Any]  			=   0
        lowercase__:   List[Any]  			=   [0]
        lowercase__:   str  			=   [0]
        lowercase__:   Tuple  			=   len(lowerCAmelCase__ )
        self.assertEqual(k.knapsack(lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__ )				, 0 )

        lowercase__:   Optional[Any]  			=   [60]
        lowercase__:   Dict  			=   [10]
        lowercase__:   str  			=   len(lowerCAmelCase__ )
        self.assertEqual(k.knapsack(lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__ )				, 0 )
 def 		SCREAMING_SNAKE_CASE__   (   self )					->				Union[str, Any]:




        '''simple docstring'''
        lowercase__:   Union[str, Any]  			=   3
        lowercase__:   List[str]  			=   [1, 2, 3]
        lowercase__:   Union[str, Any]  			=   [3, 2, 1]
        lowercase__:   Union[str, Any]  			=   len(lowerCAmelCase__ )
        self.assertEqual(k.knapsack(lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__ )				, 5 )
 def 		SCREAMING_SNAKE_CASE__   (   self )					->				List[Any]:




        '''simple docstring'''
        lowercase__:   Optional[Any]  			=   50
        lowercase__:   str  			=   [60, 100, 120]
        lowercase__:   Any  			=   [10, 20, 30]
        lowercase__:   List[Any]  			=   len(lowerCAmelCase__ )
        self.assertEqual(k.knapsack(lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__ )				, 220 )


if __name__ == "__main__":
 unittest.main()


