



from timeit import timeit

__UpperCAmelCase			  =			{
    '''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 						UpperCamelCase      (  snake_case__			:       str      )      ->	bool:
   UpperCamelCase       :    str		      =      0
   UpperCamelCase       :    Optional[int]		      =      len(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 						UpperCamelCase      (  snake_case__			:       str      )      ->	bool:
   UpperCamelCase       :    List[str]		      =      len(snake_case__      ) // 2
   UpperCamelCase       :    Optional[int]		      =      len(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(snake_case__      )      )
def 						UpperCamelCase      (  snake_case__			:       str      )      ->	bool:
   if len(snake_case__      ) <= 2:
      return True
   if s[0] == s[len(snake_case__      ) - 1]:
      return is_palindrome_recursive(s[1:-1]      )
   else:
      return False
def 						UpperCamelCase      (  snake_case__			:       str      )      ->	bool:
   return s == s[::-1]
def 						UpperCamelCase      (  snake_case__			:       str      )      ->	None:
   UpperCamelCase       :    List[Any]		      =      F"""all({name}(key) is value for key, value in test_data.items())"""
   UpperCamelCase       :    Optional[Any]		      =      F"""from __main__ import test_data, {name}"""
   UpperCamelCase       :    Dict		      =      500000
   UpperCamelCase       :    Optional[int]		      =      timeit(stmt=snake_case__			,	setup=snake_case__			,	number=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''')







from __future__ import annotations

import numpy as np
def 							UpperCamelCase_(					_A :list[float]	)->		Optional[Any]:
			return np.maximum(0					,  _A	)


if __name__ == "__main__":
						print(np.array(relu([-1, 0, 5])))  # --> [0, 0, 5]


