


"""simple docstring"""
from timeit import timeit

SCREAMING_SNAKE_CASE :    Dict									=				{
    """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 		lowercase							(     _snake_case						:      str     )     ->bool:
	"""simple docstring"""





	__snake_case	:						Dict						=				0
	__snake_case	:						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 		lowercase							(     _snake_case						:      str     )     ->bool:
	"""simple docstring"""





	__snake_case	:						List[Any]						=				len(_snake_case     ) // 2
	__snake_case	:						Optional[Any]						=				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 		lowercase							(     _snake_case						:      str     )     ->bool:
	"""simple docstring"""





	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 		lowercase							(     _snake_case						:      str     )     ->bool:
	"""simple docstring"""





	return s == s[::-1]






def 		lowercase							(     _snake_case						:      str     )     ->None:
	"""simple docstring"""





	__snake_case	:						List[str]						=				f"""all({name}(key) is value for key, value in test_data.items())"""
	__snake_case	:						Optional[int]						=				f"""from __main__ import test_data, {name}"""
	__snake_case	:						List[str]						=				500_000
	__snake_case	:						Any						=				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""")









'''simple docstring'''




class 		UpperCAmelCase_      :





     def __init__( self       :      List[str]    ,      UpperCAmelCase__       :      list[int]    )				->  None:
        lowerCAmelCase     =			len(UpperCAmelCase__    )
        lowerCAmelCase     =			[0] * len_array

        if len_array > 0:
           lowerCAmelCase     =			array[0]

        for i in range(1    ,      UpperCAmelCase__    ):
           lowerCAmelCase     =			self.prefix_sum[i - 1] + array[i]





     def 							__UpperCAmelCase      ( self       :      Optional[Any]    ,      UpperCAmelCase__       :      int    ,      UpperCAmelCase__       :      int    )				->  int:
        if start == 0:
           return self.prefix_sum[end]

        return self.prefix_sum[end] - self.prefix_sum[start - 1]





     def 							__UpperCAmelCase      ( self       :      int    ,      UpperCAmelCase__       :      int    )				->  bool:
        lowerCAmelCase     =			{0}
        for sum_item in self.prefix_sum:
           if sum_item - target_sum in sums:
              return True

           sums.add(UpperCAmelCase__    )

        return False


if __name__ == "__main__":
       import doctest

       doctest.testmod()





