


from collections import Counter
from timeit import timeit






def   _lowercase(					__a				:						str = ""    ,     ):
							return sum(c % 2 for c in Counter(input_str.replace(' '    ,     ''     ).lower()     ).values()     ) < 2






def   _lowercase(					__a				:						str = ""     ):
							if len(__a     ) == 0:
														return True
							a__      =input_str.replace(' '    ,     ''     ).lower()
							# character_freq_dict: Stores the frequency of every character in the input string
							a__      ={}

							for character in lower_case_input_str:
														a__      =character_freq_dict.get(__a    ,     0     ) + 1
							a__      =0

							for character_count in character_freq_dict.values():
														if character_count % 2:
																					odd_char += 1
							if odd_char > 1:
														return False
							return True






def   _lowercase(					__a				:						str = ""     ):
							print('\nFor string = '    ,     __a    ,     ':'     )
							print(
							    '> can_string_be_rearranged_as_palindrome_counter()'    ,     '\tans ='    ,     can_string_be_rearranged_as_palindrome_counter(__a     )    ,     '\ttime ='    ,     timeit(
							        'z.can_string_be_rearranged_as_palindrome_counter(z.check_str)'    ,     setup='import __main__ as z'    ,     )    ,     'seconds'    ,     )
							print(
							    '> can_string_be_rearranged_as_palindrome()'    ,     '\tans ='    ,     can_string_be_rearranged_as_palindrome(__a     )    ,     '\ttime ='    ,     timeit(
							        'z.can_string_be_rearranged_as_palindrome(z.check_str)'    ,     setup='import __main__ as z'    ,     )    ,     'seconds'    ,     )


if __name__ == "__main__":
	_lowerCAmelCase:						Any   				=       input(
	    'Enter string to determine if it can be rearranged as a palindrome or not: '
	).strip()
	benchmark(check_str)
	_lowerCAmelCase:						Optional[Any]   				=       can_string_be_rearranged_as_palindrome_counter(check_str)
	print(F"""{check_str} can {'' if status else 'not '}be rearranged as a palindrome""")








'''simple docstring'''

def    a__							(							lowercase   :	Dict,   lowercase   :	Optional[Any] )						->						int:





     """simple docstring"""

     _UpperCamelCase							       =			0
     _UpperCamelCase							       =			len(lowercase ) - 1

     while left <= right:
          # avoid divided by 0 during interpolation
          if sorted_collection[left] == sorted_collection[right]:
               if sorted_collection[left] == item:
                    return left
               else:
                    return None

          _UpperCamelCase							       =			left + ((item - sorted_collection[left]) * (right - left)) // (
              sorted_collection[right] - sorted_collection[left]
          )

          # out of range check
          if point < 0 or point >= len(lowercase ):
               return None

          _UpperCamelCase							       =			sorted_collection[point]
          if current_item == item:
               return point
          else:
               if point < left:
                    _UpperCamelCase							       =			left
                    _UpperCamelCase							       =			point
               elif point > right:
                    _UpperCamelCase							       =			right
                    _UpperCamelCase							       =			point
               else:
                    if item < current_item:
                         _UpperCamelCase							       =			point - 1
                    else:
                         _UpperCamelCase							       =			point + 1
     return None







def    a__							(							lowercase   :	int,   lowercase   :	Optional[int],   lowercase   :	List[Any],   lowercase   :	List[Any] )						->						Dict:





     """simple docstring"""

     if sorted_collection[left] == sorted_collection[right]:
          if sorted_collection[left] == item:
               return left
          else:
               return None

     _UpperCamelCase							       =			left + ((item - sorted_collection[left]) * (right - left)) // (
         sorted_collection[right] - sorted_collection[left]
     )

     # out of range check
     if point < 0 or point >= len(lowercase ):
          return None

     if sorted_collection[point] == item:
          return point
     elif point < left:
          return interpolation_search_by_recursion(lowercase,   lowercase,   lowercase,   lowercase )
     elif point > right:
          return interpolation_search_by_recursion(lowercase,   lowercase,   lowercase,   lowercase )
     else:
          if sorted_collection[point] > item:
               return interpolation_search_by_recursion(
                   lowercase,   lowercase,   lowercase,   point - 1 )
          else:
               return interpolation_search_by_recursion(
                   lowercase,   lowercase,   point + 1,   lowercase )







def    a__							(							lowercase   :	Any )						->						List[Any]:





     """simple docstring"""

     if collection != sorted(lowercase ):
          raise ValueError('''Collection must be ascending sorted''' )
     return True


if __name__ == "__main__":
   import sys
   lowercase__		:     int			=							0
   if debug == 1:
      lowercase__		:     Optional[Any]			=							[10, 30, 40, 45, 50, 66, 77, 93]
      try:
         __assert_sorted(collection)
      except ValueError:
         sys.exit('Sequence must be ascending sorted to apply interpolation search')
      lowercase__		:     List[str]			=							67

   lowercase__		:     Optional[int]			=							interpolation_search(collection, target)
   if result is not None:
      print(F"""{target} found at positions: {result}""")
   else:
      print('Not found')



