


def 		__lowerCAmelCase   (							_UpperCamelCase		)    ->				None:






      '''simple docstring'''

      lowerCamelCase__:						Optional[int]							   = 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   (							_UpperCamelCase		)    ->				list[list[int]]:






      '''simple docstring'''

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

      lowerCamelCase__:						Any							   = []
      for current_row_idx in range(_lowerCAmelCase		):
            lowerCamelCase__:						Dict							   = populate_current_row(_lowerCAmelCase       ,			_lowerCAmelCase		)
            triangle.append(_lowerCAmelCase		)
      return triangle

def 		__lowerCAmelCase   (							_UpperCamelCase       ,			_UpperCamelCase		)    ->				list[int]:






      '''simple docstring'''

      lowerCamelCase__:						Tuple							   = [-1] * (current_row_idx + 1)
      # first and last elements of current row are equal to 1
      lowerCamelCase__   ,    lowerCamelCase__:						Union[str, Any]							   = 1, 1
      for current_col_idx in range(1       ,			_lowerCAmelCase		):
            calculate_current_element(
                _lowerCAmelCase       ,			_lowerCAmelCase       ,			_lowerCAmelCase       ,			_lowerCAmelCase		)
      return current_row

def 		__lowerCAmelCase   (							_UpperCamelCase       ,			_UpperCamelCase       ,			_UpperCamelCase       ,			_UpperCamelCase       ,			)    ->				None:






      '''simple docstring'''

      lowerCamelCase__:						Any							   = triangle[current_row_idx - 1][current_col_idx - 1]
      lowerCamelCase__:						Dict							   = triangle[current_row_idx - 1][current_col_idx]
      lowerCamelCase__:						Optional[Any]							   = above_to_left_elt + above_to_right_elt

def 		__lowerCAmelCase   (							_UpperCamelCase		)    ->				list[list[int]]:






      '''simple docstring'''

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

      lowerCamelCase__:						str							   = [[1]]

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

      return result

def 		__lowerCAmelCase   (							)    ->				None:






      '''simple docstring'''

      from collections.abc import Callable
      from timeit import timeit

      def benchmark_a_function(_UpperCamelCase       ,			_UpperCamelCase		) -> None:
            lowerCamelCase__:						Tuple							   = f"""{func.__name__}({value})"""
            lowerCamelCase__:						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()










from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


A				:       List[str]      =  {
    'configuration_time_series_transformer': [
        'TIME_SERIES_TRANSFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'TimeSeriesTransformerConfig',
    ],
}

try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	A				:       str      =  [
	    'TIME_SERIES_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST',
	    'TimeSeriesTransformerForPrediction',
	    'TimeSeriesTransformerModel',
	    'TimeSeriesTransformerPreTrainedModel',
	]


if TYPE_CHECKING:
	from .configuration_time_series_transformer import (
	    TIME_SERIES_TRANSFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP,
	    TimeSeriesTransformerConfig,
	)

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_time_series_transformer import (
		    TIME_SERIES_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
		    TimeSeriesTransformerForPrediction,
		    TimeSeriesTransformerModel,
		    TimeSeriesTransformerPreTrainedModel,
		)

else:
	import sys

	A				:       str      =  _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)





