
def 	A_ (							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 	A_ (							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 	A_ (							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 	A_ (							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 	A_ (							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 	A_ (							)      ->    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 collections import Counter
from timeit import timeit




def 	A_ (							snake_case							:   str = "" ,      )      ->    bool:



						'''simple docstring'''

						return sum(c % 2 for c in Counter(input_str.replace(''' ''' ,      '''''' ).lower() ).values() ) < 2




def 	A_ (							snake_case							:   str = "" )      ->    bool:



						'''simple docstring'''

						if len(snake_case ) == 0:
												return True
						__UpperCamelCase       =			input_str.replace(''' ''' ,      '''''' ).lower()
						# character_freq_dict: Stores the frequency of every character in the input string
						__UpperCamelCase       =			{}

						for character in lower_case_input_str:
												__UpperCamelCase       =			character_freq_dict.get(snake_case ,      0 ) + 1
						__UpperCamelCase       =			0

						for character_count in character_freq_dict.values():
												if character_count % 2:
																		odd_char += 1
						if odd_char > 1:
												return False
						return True




def 	A_ (							snake_case							:   str = "" )      ->    None:



						'''simple docstring'''

						print('''\nFor string = ''' ,      snake_case ,      ''':''' )
						print(
						    '''> can_string_be_rearranged_as_palindrome_counter()''' ,      '''\tans =''' ,      can_string_be_rearranged_as_palindrome_counter(snake_case ) ,      '''\ttime =''' ,      timeit(
						        '''z.can_string_be_rearranged_as_palindrome_counter(z.check_str)''' ,      setup='''import __main__ as z''' ,      ) ,      '''seconds''' ,      )
						print(
						    '''> can_string_be_rearranged_as_palindrome()''' ,      '''\tans =''' ,      can_string_be_rearranged_as_palindrome(snake_case ) ,      '''\ttime =''' ,      timeit(
						        '''z.can_string_be_rearranged_as_palindrome(z.check_str)''' ,      setup='''import __main__ as z''' ,      ) ,      '''seconds''' ,      )


if __name__ == "__main__":
				lowercase__							:							Tuple									=			input(
				    "Enter string to determine if it can be rearranged as a palindrome or not: "
				).strip()
				benchmark(check_str)
				lowercase__							:							Dict									=			can_string_be_rearranged_as_palindrome_counter(check_str)
				print(F"{check_str} can {'' if status else 'not '}be rearranged as a palindrome")




