



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

__a      =				{
    "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_  (			_lowercase	):







						'''simple docstring'''


						snake_case_ :Dict						=			0
						snake_case_ :Tuple						=			len(_lowercase	) - 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_  (			_lowercase	):







						'''simple docstring'''


						snake_case_ :List[Any]						=			len(_lowercase	) // 2
						snake_case_ :Dict						=			len(_lowercase	)

						# 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(_lowercase	)	)
def    A_  (			_lowercase	):







						'''simple docstring'''


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







						'''simple docstring'''


						return s == s[::-1]
def    A_  (			_lowercase	):







						'''simple docstring'''


						snake_case_ :Optional[int]						=			f"""all({name}(key) is value for key, value in test_data.items())"""
						snake_case_ :int						=			f"""from __main__ import test_data, {name}"""
						snake_case_ :Any						=			500000
						snake_case_ :Union[str, Any]						=			timeit(stmt=_lowercase,					setup=_lowercase,					number=_lowercase	)
						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 typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available


lowerCamelCase				:		str     =   {
    "configuration_nezha": ["NEZHA_PRETRAINED_CONFIG_ARCHIVE_MAP", "NezhaConfig"],
}

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 lowerCamelCase				:		List[str]     =   [
     "NEZHA_PRETRAINED_MODEL_ARCHIVE_LIST",
     "NezhaForNextSentencePrediction",
     "NezhaForMaskedLM",
     "NezhaForPreTraining",
     "NezhaForMultipleChoice",
     "NezhaForQuestionAnswering",
     "NezhaForSequenceClassification",
     "NezhaForTokenClassification",
     "NezhaModel",
     "NezhaPreTrainedModel",
 ]


if TYPE_CHECKING:
 from .configuration_nezha import NEZHA_PRETRAINED_CONFIG_ARCHIVE_MAP, NezhaConfig

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_nezha import (
      NEZHA_PRETRAINED_MODEL_ARCHIVE_LIST,
      NezhaForMaskedLM,
      NezhaForMultipleChoice,
      NezhaForNextSentencePrediction,
      NezhaForPreTraining,
      NezhaForQuestionAnswering,
      NezhaForSequenceClassification,
      NezhaForTokenClassification,
      NezhaModel,
      NezhaPreTrainedModel,
  )


else:
 import sys

 lowerCamelCase				:		str     =   _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)



