'''simple docstring'''





def       lowerCAmelCase_							(   snake_case_			:					int     )       -> None:


     '''simple docstring'''




     UpperCAmelCase_			       =  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       lowerCAmelCase_							(   snake_case_			:					int     )       -> list[list[int]]:


     '''simple docstring'''




     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"     )

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





def       lowerCAmelCase_							(   snake_case_			:					list[list[int]]   ,       snake_case_			:					int     )       -> list[int]:


     '''simple docstring'''




     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   ,       snake_case_     ):
          calculate_current_element(
              snake_case_   ,       snake_case_   ,       snake_case_   ,       snake_case_     )
     return current_row





def       lowerCAmelCase_							(   snake_case_			:					list[list[int]]   ,       snake_case_			:					list[int]   ,       snake_case_			:					int   ,       snake_case_			:					int   ,       )       -> None:


     '''simple docstring'''




     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_							(   snake_case_			:					int     )       -> list[list[int]]:


     '''simple docstring'''




     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"     )

     UpperCAmelCase_			       =  [[1]]

     for row_index in range(1   ,       snake_case_     ):
          UpperCAmelCase_			       =  [0] + result[-1] + [0]
          UpperCAmelCase_			       =  row_index + 1
          # Calculate the number of distinct elements in a row
          UpperCAmelCase_			       =  sum(divmod(snake_case_   ,       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(snake_case_     )

     return result





def       lowerCAmelCase_							(   )       -> None:


     '''simple docstring'''




     from collections.abc import Callable
     from timeit import timeit

     def benchmark_a_function(snake_case_			:					Callable   ,       snake_case_			:					int     ) -> 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(snake_case_   ,       snake_case_     )
          print()


if __name__ == "__main__":
    import doctest

    doctest.testmod()
    benchmark()






from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


lowerCamelCase  ={
    "configuration_luke": ["LUKE_PRETRAINED_CONFIG_ARCHIVE_MAP", "LukeConfig"],
    "tokenization_luke": ["LukeTokenizer"],
}

try:
    if not is_torch_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    lowerCamelCase  =[
        "LUKE_PRETRAINED_MODEL_ARCHIVE_LIST",
        "LukeForEntityClassification",
        "LukeForEntityPairClassification",
        "LukeForEntitySpanClassification",
        "LukeForMultipleChoice",
        "LukeForQuestionAnswering",
        "LukeForSequenceClassification",
        "LukeForTokenClassification",
        "LukeForMaskedLM",
        "LukeModel",
        "LukePreTrainedModel",
    ]


if TYPE_CHECKING:
    from .configuration_luke import LUKE_PRETRAINED_CONFIG_ARCHIVE_MAP, LukeConfig
    from .tokenization_luke import LukeTokenizer

    try:
        if not is_torch_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_luke import (
            LUKE_PRETRAINED_MODEL_ARCHIVE_LIST,
            LukeForEntityClassification,
            LukeForEntityPairClassification,
            LukeForEntitySpanClassification,
            LukeForMaskedLM,
            LukeForMultipleChoice,
            LukeForQuestionAnswering,
            LukeForSequenceClassification,
            LukeForTokenClassification,
            LukeModel,
            LukePreTrainedModel,
        )

else:
    import sys

    lowerCamelCase  =_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)


