


from timeit import timeit

UpperCAmelCase_   :				Optional[Any]						      = {
    '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_		(    __A				:    str       )			->	bool:

							"""simple docstring"""

							a_      :	Union[str, Any]							=						0
							a_      :	int							=						len(__A       ) - 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_		(    __A				:    str       )			->	bool:

							"""simple docstring"""

							a_      :	List[Any]							=						len(__A       ) // 2
							a_      :	List[str]							=						len(__A       )

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







def  SCREAMING_SNAKE_CASE_		(    __A				:    str       )			->	bool:

							"""simple docstring"""

							if len(__A       ) <= 2:
														return True
							if s[0] == s[len(__A       ) - 1]:
														return is_palindrome_recursive(s[1:-1]       )
							else:
														return False







def  SCREAMING_SNAKE_CASE_		(    __A				:    str       )			->	bool:

							"""simple docstring"""

							return s == s[::-1]







def  SCREAMING_SNAKE_CASE_		(    __A				:    str       )			->	None:

							"""simple docstring"""

							a_      :	Optional[int]							=						F"""all({name}(key) is value for key, value in test_data.items())"""
							a_      :	Tuple							=						F"""from __main__ import test_data, {name}"""
							a_      :	Any							=						50_00_00
							a_      :	Optional[int]							=						timeit(stmt=__A						,					setup=__A						,					number=__A       )
							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')






def  SCREAMING_SNAKE_CASE_		(    __A				:    int						,					__A				:    int						,					__A				:    int       )			->	float:

       """simple docstring"""

       a_      :	Optional[int]							=						(num_of_terms / 2) * (2 * first_term + (num_of_terms - 1) * common_diff)
       # formula for sum of series
       return total







def  SCREAMING_SNAKE_CASE_		(    )			->	Optional[Any]:

       """simple docstring"""

       print(sum_of_series(1						,					1						,					10       )       )


if __name__ == "__main__":
   import doctest

   doctest.testmod()


