






'''simple docstring'''







from timeit import timeit

_A     :      Tuple   					={
    '''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 			SCREAMING_SNAKE_CASE_	(UpperCamelCase							)				->	Optional[int]:
							lowerCamelCase__ :     Dict	  =	0
							lowerCamelCase__ :     List[Any]	  =	len(SCREAMING_SNAKE_CASE_							) - 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 			SCREAMING_SNAKE_CASE_	(UpperCamelCase							)				->	List[Any]:
							lowerCamelCase__ :     int	  =	len(SCREAMING_SNAKE_CASE_							) // 2
							lowerCamelCase__ :     Optional[Any]	  =	len(SCREAMING_SNAKE_CASE_							)

							# 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(SCREAMING_SNAKE_CASE_							)							)





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





def 			SCREAMING_SNAKE_CASE_	(UpperCamelCase							)				->	Optional[int]:
							return s == s[::-1]





def 			SCREAMING_SNAKE_CASE_	(UpperCamelCase							)				->	Any:
							lowerCamelCase__ :     Dict	  =	f'''all({name}(key) is value for key, value in test_data.items())'''
							lowerCamelCase__ :     List[str]	  =	f'''from __main__ import test_data, {name}'''
							lowerCamelCase__ :     int	  =	500000
							lowerCamelCase__ :     Optional[Any]	  =	timeit(stmt=SCREAMING_SNAKE_CASE_    ,      setup=SCREAMING_SNAKE_CASE_    ,      number=SCREAMING_SNAKE_CASE_							)
							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'''







from __future__ import annotations

import typing
from collections.abc import Iterable

import numpy as np

_A     :      Optional[Any]   					=typing.Union[Iterable[float], Iterable[int], np.ndarray]  # noqa: UP007
_A     :      Optional[int]   					=typing.Union[np.floataa, int, float]  # noqa: UP007





def 			SCREAMING_SNAKE_CASE_	(UpperCamelCase    ,      UpperCamelCase				)				->	VectorOut:
							return np.sqrt(np.sum((np.asarray(UpperCamelCase				) - np.asarray(UpperCamelCase				)) ** 2				)				)





def 			SCREAMING_SNAKE_CASE_	(UpperCamelCase    ,      UpperCamelCase				)				->	VectorOut:
							return sum((va - va) ** 2 for va, va in zip(UpperCamelCase    ,      UpperCamelCase				)				) ** (1 / 2)


if __name__ == "__main__":





			def 			SCREAMING_SNAKE_CASE_	()				->	None:
										from timeit import timeit

										print("""Without Numpy"""				)
										print(
										    timeit(
										        """euclidean_distance_no_np([1, 2, 3], [4, 5, 6])"""    ,      number=10000    ,      globals=globals()    ,      )				)
										print("""With Numpy"""				)
										print(
										    timeit(
										        """euclidean_distance([1, 2, 3], [4, 5, 6])"""    ,      number=10000    ,      globals=globals()    ,      )				)



			benchmark()

