



"""simple docstring"""





from timeit import timeit

lowerCamelCase       	=						{
    """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__     (				lowerCAmelCase__				):
      UpperCAmelCase_      			=							0
      UpperCAmelCase_      			=							len(lowerCAmelCase__				) - 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__     (				lowerCAmelCase__				):
      UpperCAmelCase_      			=							len(lowerCAmelCase__				) // 2
      UpperCAmelCase_      			=							len(lowerCAmelCase__				)

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





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





def        a__     (				lowerCAmelCase__				):
      return s == s[::-1]





def        a__     (				lowerCAmelCase__				):
      UpperCAmelCase_      			=							f"""all({name}(key) is value for key, value in test_data.items())"""
      UpperCAmelCase_      			=							f"""from __main__ import test_data, {name}"""
      UpperCAmelCase_      			=							500000
      UpperCAmelCase_      			=							timeit(stmt=lowerCAmelCase__     ,      setup=lowerCAmelCase__     ,      number=lowerCAmelCase__				)
      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"""





# Copyright 2023 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


lowerCamelCase       	=						{
    """configuration_mgp_str""": ["""MGP_STR_PRETRAINED_CONFIG_ARCHIVE_MAP""", """MgpstrConfig"""],
    """processing_mgp_str""": ["""MgpstrProcessor"""],
    """tokenization_mgp_str""": ["""MgpstrTokenizer"""],
}

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  lowerCamelCase       	=						[
      """MGP_STR_PRETRAINED_MODEL_ARCHIVE_LIST""",
      """MgpstrModel""",
      """MgpstrPreTrainedModel""",
      """MgpstrForSceneTextRecognition""",
  ]

if TYPE_CHECKING:
  from .configuration_mgp_str import MGP_STR_PRETRAINED_CONFIG_ARCHIVE_MAP, MgpstrConfig
  from .processing_mgp_str import MgpstrProcessor
  from .tokenization_mgp_str import MgpstrTokenizer

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_mgp_str import (
        MGP_STR_PRETRAINED_MODEL_ARCHIVE_LIST,
        MgpstrForSceneTextRecognition,
        MgpstrModel,
        MgpstrPreTrainedModel,
    )
else:
  import sys

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




