






'''simple docstring'''

from collections import Counter
from timeit import timeit
def     __lowercase  (_lowercase = "",						)   ->     bool:


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


     """simple docstring"""
     if len(_lowercase     ) == 0:
          return True
     __lowerCamelCase						:       Tuple				   =				input_str.replace(""" """,						""""""     ).lower()
     # character_freq_dict: Stores the frequency of every character in the input string
     __lowerCamelCase						:       dict[str, int]				   =				{}

     for character in lower_case_input_str:
          __lowerCamelCase						:       List[Any]				   =				character_freq_dict.get(_lowercase,						0     ) + 1
     __lowerCamelCase						:       Optional[Any]				   =				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  (_lowercase = ""     )   ->     None:


     """simple docstring"""
     print("""\nFor string = """,						_lowercase,						""":"""     )
     print(
         """> can_string_be_rearranged_as_palindrome_counter()""",						"""\tans =""",						can_string_be_rearranged_as_palindrome_counter(_lowercase     ),						"""\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(_lowercase     ),						"""\ttime =""",						timeit(
             """z.can_string_be_rearranged_as_palindrome(z.check_str)""",						setup="""import __main__ as z""",						),						"""seconds""",						)


if __name__ == "__main__":
   UpperCAmelCase__						:Optional[Any]          =			input(
       """Enter string to determine if it can be rearranged as a palindrome or not: """
   ).strip()
   benchmark(check_str)
   UpperCAmelCase__						:List[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'''

from __future__ import annotations

from typing import Any
def     __lowercase  (_lowercase     )   ->     int:


     """simple docstring"""
     if not postfix_notation:
          return 0

     __lowerCamelCase						:       Optional[int]				   =				{"""+""", """-""", """*""", """/"""}
     __lowerCamelCase						:       list[Any]				   =				[]

     for token in postfix_notation:
          if token in operations:
               __lowerCamelCase   ,      __lowerCamelCase						:       List[Any]				   =				stack.pop(), stack.pop()
               if token == "+":
                    stack.append(a + b     )
               elif token == "-":
                    stack.append(a - b     )
               elif token == "*":
                    stack.append(a * b     )
               else:
                    if a * b < 0 and a % b != 0:
                         stack.append(a // b + 1     )
                    else:
                         stack.append(a // b     )
          else:
               stack.append(int(_lowercase     )     )

     return stack.pop()


if __name__ == "__main__":
   import doctest

   doctest.testmod()



