
'''simple docstring'''
def 						UpperCamelCase_     (	__SCREAMING_SNAKE_CASE       ):
    """simple docstring"""






    snake_case_ :    Tuple     			=						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       ):
    """simple docstring"""






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

    snake_case_ :    list[list[int]]     			=						[]
    for current_row_idx in range(__SCREAMING_SNAKE_CASE       ):
        snake_case_ :    Dict     			=						populate_current_row(__SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE       )
        triangle.append(__SCREAMING_SNAKE_CASE       )
    return triangle

def 						UpperCamelCase_     (	__SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE       ):
    """simple docstring"""






    snake_case_ :    Dict     			=						[-1] * (current_row_idx + 1)
    # first and last elements of current row are equal to 1
    snake_case_ :    Union[str, Any]     			=						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,		__SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE,		):
    """simple docstring"""






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

def 						UpperCamelCase_     (	__SCREAMING_SNAKE_CASE       ):
    """simple docstring"""






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

    snake_case_ :    list[list[int]]     			=						[[1]]

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

    return result

def 						UpperCamelCase_     (	):
    """simple docstring"""






    from collections.abc import Callable
    from timeit import timeit

    def benchmark_a_function(__SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE       ) -> None:
        snake_case_ :    int     			=						f'{func.__name__}({value})'
        snake_case_ :    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(1_5       ):  # (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()






'''simple docstring'''
import doctest
from collections import deque

import numpy as np






class    UpperCAmelCase_				:





 def __init__(    self):
     snake_case_ :    List[Any]     			=						[2, 1, 2, -1]
     snake_case_ :    int     			=						[1, 2, 3, 4]





 def        snake_case__		(    self):
     snake_case_ :    str     			=						len(self.first_signal)
     snake_case_ :    Any     			=						len(self.second_signal)

     snake_case_ :    List[Any]     			=						max(lowercase_ ,       lowercase_)

     # create a zero matrix of max_length x max_length
     snake_case_ :    Dict     			=						[[0] * max_length for i in range(lowercase_)]

     # fills the smaller signal with zeros to make both signals of same length
     if length_first_signal < length_second_signal:
         self.first_signal += [0] * (max_length - length_first_signal)
     elif length_first_signal > length_second_signal:
         self.second_signal += [0] * (max_length - length_second_signal)
     for i in range(lowercase_):
         snake_case_ :    List[str]     			=						deque(self.second_signal)
         rotated_signal.rotate(lowercase_)
         for j, item in enumerate(lowercase_):
             matrix[i][j] += item

        # multiply the matrix with the first signal
     snake_case_ :    Any     			=						np.matmul(np.transpose(lowercase_) ,       np.transpose(self.first_signal))

     # rounding-off to two decimal places
     return [round(lowercase_ ,       2) for i in final_signal]


if __name__ == "__main__":
  doctest.testmod()




