def      lowerCamelCase_(__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE  )->    str:
							_SCREAMING_SNAKE_CASE		:						list[list[str]]			  =    [[] for _ in range(__snake_case  )]
							_SCREAMING_SNAKE_CASE		:						List[str]			  =    key - 1

							if key <= 0:
														raise ValueError("""Height of grid can't be 0 or negative"""  )
							if key == 1 or len(__snake_case  ) <= key:
														return input_string

							for position, character in enumerate(__snake_case  ):
														_SCREAMING_SNAKE_CASE		:						str			  =    position % (lowest * 2)  # puts it in bounds
														_SCREAMING_SNAKE_CASE		:						str			  =    min(__snake_case     ,	lowest * 2 - num  )  # creates zigzag pattern
														temp_grid[num].append(__snake_case  )
							_SCREAMING_SNAKE_CASE		:						Union[str, Any]			  =    ["".join(__snake_case  ) for row in temp_grid]
							_SCREAMING_SNAKE_CASE		:						Optional[int]			  =    "".join(__snake_case  )

							return output_string



def      lowerCamelCase_(__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE  )->    str:
							_SCREAMING_SNAKE_CASE		:						Union[str, Any]			  =    []
							_SCREAMING_SNAKE_CASE		:						Tuple			  =    key - 1

							if key <= 0:
														raise ValueError("""Height of grid can't be 0 or negative"""  )
							if key == 1:
														return input_string

							_SCREAMING_SNAKE_CASE		:						list[list[str]]			  =    [[] for _ in range(__snake_case  )]  # generates template
							for position in range(len(__snake_case  )  ):
														_SCREAMING_SNAKE_CASE		:						Tuple			  =    position % (lowest * 2)  # puts it in bounds
														_SCREAMING_SNAKE_CASE		:						Union[str, Any]			  =    min(__snake_case     ,	lowest * 2 - num  )  # creates zigzag pattern
														temp_grid[num].append("""*"""  )

							_SCREAMING_SNAKE_CASE		:						str			  =    0
							for row in temp_grid:  # fills in the characters
														_SCREAMING_SNAKE_CASE		:						Dict			  =    input_string[counter : counter + len(__snake_case  )]
														grid.append(list(__snake_case  )  )
														counter += len(__snake_case  )

							_SCREAMING_SNAKE_CASE		:						Union[str, Any]			  =    ""  # reads as zigzag
							for position in range(len(__snake_case  )  ):
														_SCREAMING_SNAKE_CASE		:						Any			  =    position % (lowest * 2)  # puts it in bounds
														_SCREAMING_SNAKE_CASE		:						int			  =    min(__snake_case     ,	lowest * 2 - num  )  # creates zigzag pattern
														output_string += grid[num][0]
														grid[num].pop(0  )
							return output_string



def      lowerCamelCase_(__SCREAMING_SNAKE_CASE  )->    dict[int, str]:
							_SCREAMING_SNAKE_CASE		:						Tuple			  =    {}
							for key_guess in range(1     ,	len(__snake_case  )  ):  # tries every key
														_SCREAMING_SNAKE_CASE		:						Dict			  =    decrypt(__snake_case     ,	__snake_case  )
							return results


if __name__ == "__main__":
			import doctest

			doctest.testmod()



"""simple docstring"""





from typing import Any

import numpy as np



def      lowerCamelCase_(__SCREAMING_SNAKE_CASE  )->    bool:
							return np.array_equal(__SCREAMING_SNAKE_CASE     ,	matrix.conjugate().T  )



def      lowerCamelCase_(__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE  )->    Any:
							_SCREAMING_SNAKE_CASE		:						Optional[int]			  =    v.conjugate().T
							_SCREAMING_SNAKE_CASE		:						Optional[int]			  =    v_star.dot(__SCREAMING_SNAKE_CASE  )
							assert isinstance(__SCREAMING_SNAKE_CASE     ,	np.ndarray  )
							return (v_star_dot.dot(__SCREAMING_SNAKE_CASE  )) / (v_star.dot(__SCREAMING_SNAKE_CASE  ))



def      lowerCamelCase_()->    None:
							_SCREAMING_SNAKE_CASE		:						Optional[Any]			  =    np.array([[2, 2 + 1j, 4], [2 - 1j, 3, 1j], [4, -1j, 1]]  )
							_SCREAMING_SNAKE_CASE		:						int			  =    np.array([[1], [2], [3]]  )
							assert is_hermitian(__SCREAMING_SNAKE_CASE  ), F"""{a} is not hermitian."""
							print(rayleigh_quotient(__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE  )  )

							_SCREAMING_SNAKE_CASE		:						int			  =    np.array([[1, 2, 4], [2, 3, -1], [4, -1, 1]]  )
							assert is_hermitian(__SCREAMING_SNAKE_CASE  ), F"""{a} is not hermitian."""
							assert rayleigh_quotient(__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE  ) == float(3  )


if __name__ == "__main__":
			import doctest

			doctest.testmod()
			tests()


