






"""simple docstring"""





from timeit import timeit

__lowerCamelCase							=  {
    'MALAYALAM': True,
    'String': False,
    'rotor': True,
    'level': True,
    'A': True,
    'BB': True,
    'ABC': False,
    'amanaplanacanalpanama': True,  # "a man a plan a canal panama"
}
# Ensure our test data is valid
assert all((key == key[::-1]) is value for key, value in test_data.items())



def   a    (     __UpperCAmelCase      :    str  )    ->							bool:
						__magic_name__:	List[Any]							=       0
						__magic_name__:	Any							=       len(__UpperCAmelCase  ) - 1
						while start_i < end_i:
												if s[start_i] == s[end_i]:
																		start_i += 1
																		end_i -= 1
												else:
																		return False
						return True



def   a    (     __UpperCAmelCase      :    str  )    ->							bool:
						__magic_name__:	Any							=       len(__UpperCAmelCase  ) // 2
						__magic_name__:	str							=       len(__UpperCAmelCase  )

						# We need to traverse till half of the length of string
						# as we can get access of the i'th last element from
						# i'th index.
						# eg: [0,1,2,3,4,5] => 4th index can be accessed
						# with the help of 1st index (i==n-i-1)
						# where n is length of string
						return all(s[i] == s[n - i - 1] for i in range(__UpperCAmelCase  )  )



def   a    (     __UpperCAmelCase      :    str  )    ->							bool:
						if len(__UpperCAmelCase  ) <= 2:
												return True
						if s[0] == s[len(__UpperCAmelCase  ) - 1]:
												return is_palindrome_recursive(s[1:-1]  )
						else:
												return False



def   a    (     __UpperCAmelCase      :    str  )    ->							bool:
						return s == s[::-1]



def   a    (     __UpperCAmelCase      :    str  )    ->							None:
						__magic_name__:	List[Any]							=       f'all({name}(key) is value for key, value in test_data.items())'
						__magic_name__:	Optional[Any]							=       f'from __main__ import test_data, {name}'
						__magic_name__:	Union[str, Any]							=       5_0_0_0_0_0
						__magic_name__:	Dict							=       timeit(stmt=__UpperCAmelCase      ,   setup=__UpperCAmelCase      ,   number=__UpperCAmelCase  )
						print(f'{name:<35} finished {number:,} runs in {result:.5f} seconds'  )


if __name__ == "__main__":
							for key, value in test_data.items():
														assert is_palindrome(key) is is_palindrome_recursive(key)
														assert is_palindrome(key) is is_palindrome_slice(key)
														print(f'''{key:21} {value}''')
							print('a man a plan a canal panama')

							# finished 500,000 runs in 0.46793 seconds
							benchmark_function('is_palindrome_slice')
							# finished 500,000 runs in 0.85234 seconds
							benchmark_function('is_palindrome')
							# finished 500,000 runs in 1.32028 seconds
							benchmark_function('is_palindrome_recursive')
							# finished 500,000 runs in 2.08679 seconds
							benchmark_function('is_palindrome_traversal')











"""simple docstring"""





def   a    (     __UpperCAmelCase      :    int      ,   __UpperCAmelCase      :    int  )    ->							int:
						while b:
												__magic_name__,			__magic_name__:	Optional[int]							=       b, a % b
						return a



def   a    (     __UpperCAmelCase      :    int      ,   __UpperCAmelCase      :    int  )    ->							int:
						return a if b == 0 else euclidean_gcd_recursive(__UpperCAmelCase      ,   a % b  )



def   a    (     )    ->							List[Any]:
						print(f'euclidean_gcd(3, 5) = {euclidean_gcd(3      ,   5  )}'  )
						print(f'euclidean_gcd(5, 3) = {euclidean_gcd(5      ,   3  )}'  )
						print(f'euclidean_gcd(1, 3) = {euclidean_gcd(1      ,   3  )}'  )
						print(f'euclidean_gcd(3, 6) = {euclidean_gcd(3      ,   6  )}'  )
						print(f'euclidean_gcd(6, 3) = {euclidean_gcd(6      ,   3  )}'  )

						print(f'euclidean_gcd_recursive(3, 5) = {euclidean_gcd_recursive(3      ,   5  )}'  )
						print(f'euclidean_gcd_recursive(5, 3) = {euclidean_gcd_recursive(5      ,   3  )}'  )
						print(f'euclidean_gcd_recursive(1, 3) = {euclidean_gcd_recursive(1      ,   3  )}'  )
						print(f'euclidean_gcd_recursive(3, 6) = {euclidean_gcd_recursive(3      ,   6  )}'  )
						print(f'euclidean_gcd_recursive(6, 3) = {euclidean_gcd_recursive(6      ,   3  )}'  )


if __name__ == "__main__":
							main()



