


def 						_UpperCAmelCase				(			SCREAMING_SNAKE_CASE__			:					int				):
     __UpperCamelCase    							=generate_pascal_triangle(SCREAMING_SNAKE_CASE__				)
     for row_idx in range(SCREAMING_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 						_UpperCAmelCase				(			SCREAMING_SNAKE_CASE__			:					int				):

     if not isinstance(SCREAMING_SNAKE_CASE__			,     SCREAMING_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(SCREAMING_SNAKE_CASE__				):
          __UpperCamelCase    							=populate_current_row(SCREAMING_SNAKE_CASE__			,     SCREAMING_SNAKE_CASE__				)
          triangle.append(SCREAMING_SNAKE_CASE__				)
     return triangle

def 						_UpperCAmelCase				(			SCREAMING_SNAKE_CASE__			:					list[list[int]]			,     SCREAMING_SNAKE_CASE__			:					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			,     SCREAMING_SNAKE_CASE__				):
          calculate_current_element(
              SCREAMING_SNAKE_CASE__			,     SCREAMING_SNAKE_CASE__			,     SCREAMING_SNAKE_CASE__			,     SCREAMING_SNAKE_CASE__				)
     return current_row

def 						_UpperCAmelCase				(			SCREAMING_SNAKE_CASE__			:					list[list[int]]			,     SCREAMING_SNAKE_CASE__			:					list[int]			,     SCREAMING_SNAKE_CASE__			:					int			,     SCREAMING_SNAKE_CASE__			:					int			,     ):
     __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 						_UpperCAmelCase				(			SCREAMING_SNAKE_CASE__			:					int				):

     if not isinstance(SCREAMING_SNAKE_CASE__			,     SCREAMING_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			,     SCREAMING_SNAKE_CASE__				):
          __UpperCamelCase    							=[0] + result[-1] + [0]
          __UpperCamelCase    							=row_index + 1
          # Calculate the number of distinct elements in a row
          __UpperCamelCase    							=sum(divmod(SCREAMING_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(SCREAMING_SNAKE_CASE__				)

     return result

def 						_UpperCAmelCase				(			):
     from collections.abc import Callable
     from timeit import timeit

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


if __name__ == "__main__":
   import doctest

   doctest.testmod()
   benchmark()









# Copyright 2023 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from typing import TYPE_CHECKING

# rely on isort to merge the imports
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


_A		       =						{
    'configuration_vivit': ['VIVIT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'VivitConfig'],
}
try:
   if not is_vision_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   _A		       =						['VivitImageProcessor']


try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   _A		       =						[
       'VIVIT_PRETRAINED_MODEL_ARCHIVE_LIST',
       'VivitModel',
       'VivitPreTrainedModel',
       'VivitForVideoClassification',
   ]


if TYPE_CHECKING:
   from .configuration_vivit import VIVIT_PRETRAINED_CONFIG_ARCHIVE_MAP, VivitConfig

   try:
      if not is_vision_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .image_processing_vivit import VivitImageProcessor

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_vivit import (
          VIVIT_PRETRAINED_MODEL_ARCHIVE_LIST,
          VivitForVideoClassification,
          VivitModel,
          VivitPreTrainedModel,
      )


else:
   import sys

   _A		       =						_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)





