

def 						lowerCamelCase__      ( __A    :int		):


       """simple docstring"""




       __snake_case       	=							generate_pascal_triangle(__A		)
       for row_idx in range(__A		):
              # 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__      ( __A    :int		):


       """simple docstring"""




       if not isinstance(__A	,__A		):
              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       	=							[]
       for current_row_idx in range(__A		):
              __snake_case       	=							populate_current_row(__A	,__A		)
              triangle.append(__A		)
       return triangle







def 						lowerCamelCase__      ( __A    :list[list[int]]	,__A    :int		):


       """simple docstring"""




       __snake_case       	=							[-1] * (current_row_idx + 1)
       # first and last elements of current row are equal to 1
       __snake_case	,    __snake_case       	=							1, 1
       for current_col_idx in range(1	,__A		):
              calculate_current_element(
                  __A	,__A	,__A	,__A		)
       return current_row







def 						lowerCamelCase__      ( __A    :list[list[int]]	,__A    :list[int]	,__A    :int	,__A    :int	,):


       """simple docstring"""




       __snake_case       	=							triangle[current_row_idx - 1][current_col_idx - 1]
       __snake_case       	=							triangle[current_row_idx - 1][current_col_idx]
       __snake_case       	=							above_to_left_elt + above_to_right_elt







def 						lowerCamelCase__      ( __A    :int		):


       """simple docstring"""




       if not isinstance(__A	,__A		):
              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       	=							[[1]]

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

       return result







def 						lowerCamelCase__      ( ):


       """simple docstring"""




       from collections.abc import Callable
       from timeit import timeit

       def benchmark_a_function(__A    :Callable	,__A    :int		) -> None:
              __snake_case       	=							F'{func.__name__}({value})'
              __snake_case       	=							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(__A	,__A		)
              print()


if __name__ == "__main__":
    import doctest

    doctest.testmod()
    benchmark()




def 						lowerCamelCase__      ( __A    :int	,__A    :float	,__A    :float		):


       """simple docstring"""




       return round(float(moles / volume		) * nfactor		)







def 						lowerCamelCase__      ( __A    :float	,__A    :float	,__A    :float		):


       """simple docstring"""




       return round(float((moles * 0.0_821 * temperature) / (volume)		)		)







def 						lowerCamelCase__      ( __A    :float	,__A    :float	,__A    :float		):


       """simple docstring"""




       return round(float((moles * 0.0_821 * temperature) / (pressure)		)		)







def 						lowerCamelCase__      ( __A    :float	,__A    :float	,__A    :float		):


       """simple docstring"""




       return round(float((pressure * volume) / (0.0_821 * moles)		)		)


if __name__ == "__main__":
    import doctest

    doctest.testmod()

