

"""simple docstring"""
from collections import Counter
from timeit import timeit




def 					a__						(						lowerCAmelCase = ""			,	)	-> bool:
      return sum(c % 2 for c in Counter(input_str.replace(""" """			,	""""""    ).lower()    ).values()    ) < 2




def 					a__						(						lowerCAmelCase = ""    )	-> bool:
      if len(lowerCAmelCase    ) == 0:
            return True
      UpperCAmelCase__			:							Any							=    input_str.replace(""" """			,	""""""    ).lower()
      # character_freq_dict: Stores the frequency of every character in the input string
      UpperCAmelCase__			:							dict[str, int]							=    {}

      for character in lower_case_input_str:
            UpperCAmelCase__			:							Optional[int]							=    character_freq_dict.get(lowerCAmelCase			,	0    ) + 1
      UpperCAmelCase__			:							Optional[int]							=    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 					a__						(						lowerCAmelCase = ""    )	-> None:
      print("""\nFor string = """			,	lowerCAmelCase			,	""":"""    )
      print(
          """> can_string_be_rearranged_as_palindrome_counter()"""			,	"""\tans ="""			,	can_string_be_rearranged_as_palindrome_counter(lowerCAmelCase    )			,	"""\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(lowerCAmelCase    )			,	"""\ttime ="""			,	timeit(
              """z.can_string_be_rearranged_as_palindrome(z.check_str)"""			,	setup="""import __main__ as z"""			,	)			,	"""seconds"""			,	)


if __name__ == "__main__":
    _A							=  input(
        """Enter string to determine if it can be rearranged as a palindrome or not: """
    ).strip()
    benchmark(check_str)
    _A							=  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"""
from __future__ import annotations

from functools import lru_cache
from math import ceil

_A							=  1_00

_A							=  set(range(3, NUM_PRIMES, 2))
primes.add(2)
_A							=  42

for prime in range(3, ceil(NUM_PRIMES**0.5), 2):
    if prime not in primes:
        continue
    primes.difference_update(set(range(prime * prime, NUM_PRIMES, prime)))




@lru_cache(maxsize=1_00    )
def 					a__						(						lowerCAmelCase    )	-> set[int]:
      if number_to_partition < 0:
            return set()
      elif number_to_partition == 0:
            return {1}

      UpperCAmelCase__			:							set[int]							=    set()
      UpperCAmelCase__			:							int
      UpperCAmelCase__			:							int

      for prime in primes:
            if prime > number_to_partition:
                  continue
            for sub in partition(number_to_partition - prime    ):
                  ret.add(sub * prime    )

      return ret




def 					a__						(						lowerCAmelCase = 50_00    )	-> int | None:
      for number_to_partition in range(1			,	lowerCAmelCase    ):
            if len(partition(lowerCAmelCase    )    ) > number_unique_partitions:
                  return number_to_partition
      return None


if __name__ == "__main__":
    print(f'''{solution() = }''')

