






"""simple docstring"""



from __future__ import annotations

import math
from collections import Counter
from string import ascii_lowercase

def  _snake_case				(     lowerCamelCase__	:    str  )				->	None:
							lowerCamelCase_       :							Any									=analyze_text(a_  )
							lowerCamelCase_       :							Optional[int]									=list(" " + ascii_lowercase  )
							# what is our total sum of probabilities.
							lowerCamelCase_       :							Optional[int]									=sum(single_char_strings.values()  )

							# one length string
							lowerCamelCase_       :							Union[str, Any]									=0
							# for each alpha we go in our dict and if it is in it we calculate entropy
							for ch in my_alphas:
														if ch in single_char_strings:
																					lowerCamelCase_       :							Union[str, Any]									=single_char_strings[ch]
																					lowerCamelCase_       :							Any									=my_str / all_sum
																					my_fir_sum += prob * math.loga(a_  )  # entropy formula.

    # print entropy
							print(F"""{round(-1 * my_fir_sum  ):.1f}"""  )

							# two len string
							lowerCamelCase_       :							str									=sum(two_char_strings.values()  )
							lowerCamelCase_       :							str									=0
							# for each alpha (two in size) calculate entropy.
							for cha in my_alphas:
														for cha in my_alphas:
																					lowerCamelCase_       :							List[Any]									=cha + cha
																					if sequence in two_char_strings:
																												lowerCamelCase_       :							Any									=two_char_strings[sequence]
																												lowerCamelCase_       :							Dict									=int(a_  ) / all_sum
																												my_sec_sum += prob * math.loga(a_  )

    # print second entropy
							print(F"""{round(-1 * my_sec_sum  ):.1f}"""  )

							# print the difference between them
							print(F"""{round((-1 * my_sec_sum) - (-1 * my_fir_sum)  ):.1f}"""  )

def  _snake_case				(     lowerCamelCase__	:    str  )				->	tuple[dict, dict]:
							lowerCamelCase_       :							Optional[Any]									=Counter()  # type: ignore
							lowerCamelCase_       :							List[str]									=Counter()  # type: ignore
							single_char_strings[text[-1]] += 1

							# first case when we have space at start.
							two_char_strings[" " + text[0]] += 1
							for i in range(0				,						len(a_  ) - 1  ):
														single_char_strings[text[i]] += 1
														two_char_strings[text[i : i + 2]] += 1
							return single_char_strings, two_char_strings

def  _snake_case				(     )				->	Optional[Any]:
							import doctest

							doctest.testmod()
							# text = (
							#     "Had repulsive dashwoods suspicion sincerity but advantage now him. Remark "
							#     "easily garret nor nay. Civil those mrs enjoy shy fat merry. You greatest "
							#     "jointure saw horrible. He private he on be imagine suppose. Fertile "
							#     "beloved evident through no service elderly is. Blind there if every no so "
							#     "at. Own neglected you preferred way sincerity delivered his attempted. To "
							#     "of message cottage windows do besides against uncivil.  Delightful "
							#     "unreserved impossible few estimating men favourable see entreaties. She "
							#     "propriety immediate was improving. He or entrance humoured likewise "
							#     "moderate. Much nor game son say feel. Fat make met can must form into "
							#     "gate. Me we offending prevailed discovery. "
							# )

							# calculate_prob(text)


if __name__ == "__main__":
						main()










"""simple docstring"""
def      __lowerCamelCase   (							a_     :		list							)			->      list:

      if len(a_							) < 2:
            return collection

      def circle_sort_util(a_     :		list ,   a_     :		int ,   a_     :		int							) -> bool:
            __SCREAMING_SNAKE_CASE   :int						=  False

            if low == high:
                  return swapped

            __SCREAMING_SNAKE_CASE   :int						=  low
            __SCREAMING_SNAKE_CASE   :Tuple						=  high

            while left < right:
                  if collection[left] > collection[right]:
                        __SCREAMING_SNAKE_CASE				,__SCREAMING_SNAKE_CASE   :str						=  (
                            collection[right],
                            collection[left],
                        )
                        __SCREAMING_SNAKE_CASE   :Optional[int]						=  True

                  left += 1
                  right -= 1

            if left == right and collection[left] > collection[right + 1]:
                  __SCREAMING_SNAKE_CASE				,__SCREAMING_SNAKE_CASE   :Tuple						=  (
                      collection[right + 1],
                      collection[left],
                  )

                  __SCREAMING_SNAKE_CASE   :Tuple						=  True

            __SCREAMING_SNAKE_CASE   :int						=  low + int((high - low) / 2							)
            __SCREAMING_SNAKE_CASE   :int						=  circle_sort_util(a_ ,   a_ ,   a_							)
            __SCREAMING_SNAKE_CASE   :Union[str, Any]						=  circle_sort_util(a_ ,   mid + 1 ,   a_							)

            return swapped or left_swap or right_swap

      __SCREAMING_SNAKE_CASE   :Optional[Any]						=  True

      while is_not_sorted is True:
            __SCREAMING_SNAKE_CASE   :Tuple						=  circle_sort_util(a_ ,   0 ,   len(a_							) - 1							)

      return collection


if __name__ == "__main__":
  lowerCamelCase_								=		input("Enter numbers separated by a comma:\n").strip()
  lowerCamelCase_								=		[int(item) for item in user_input.split(",")]
  print(circle_sort(unsorted))