



from __future__ import annotations

import math
from collections import Counter
from string import ascii_lowercase
def 						UpperCamelCase      (  snake_case__			:       str      )      ->	None:
   UpperCamelCase      ,	UpperCamelCase       :    Tuple		      =      analyze_text(snake_case__      )
   UpperCamelCase       :    Optional[Any]		      =      list(' ' + ascii_lowercase      )
   # what is our total sum of probabilities.
   UpperCamelCase       :    List[str]		      =      sum(single_char_strings.values()      )

   # one length string
   UpperCamelCase       :    Optional[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:
         UpperCamelCase       :    Tuple		      =      single_char_strings[ch]
         UpperCamelCase       :    Any		      =      my_str / all_sum
         my_fir_sum += prob * math.loga(snake_case__      )  # entropy formula.

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

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

    # 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 						UpperCamelCase      (  snake_case__			:       str      )      ->	tuple[dict, dict]:
   UpperCamelCase       :    List[str]		      =      Counter()  # type: ignore
   UpperCamelCase       :    Any		      =      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(snake_case__      ) - 1      ):
      single_char_strings[text[i]] += 1
      two_char_strings[text[i : i + 2]] += 1
   return single_char_strings, two_char_strings
def 						UpperCamelCase      (  )      ->	Optional[int]:
   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"""




from __future__ import annotations

from bisect import bisect_left
from functools import total_ordering
from heapq import merge






@total_ordering
class       UpperCAmelCase_    (							_UpperCamelCase		):



      def __lt__(	self	:      int	,      A	:      Dict		):
           return self[-1] < other[-1]



      def __eq__(	self	:      Union[str, Any]	,      A	:      Union[str, Any]		):
           return self[-1] == other[-1]







def 		__snake_case		( SCREAMING_SNAKE_CASE__      :		list							)    ->  list:





     '''simple docstring'''

     _UpperCAmelCase     :      list[Stack]														=       []
     # sort into stacks
     for element in collection:
          _UpperCAmelCase     :      Any														=       Stack([element]							)
          _UpperCAmelCase     :      str														=       bisect_left(SCREAMING_SNAKE_CASE__		,    SCREAMING_SNAKE_CASE__							)
          if i != len(SCREAMING_SNAKE_CASE__							):
               stacks[i].append(SCREAMING_SNAKE_CASE__							)
          else:
               stacks.append(SCREAMING_SNAKE_CASE__							)

    # use a heap-based merge to merge stack efficiently
     _UpperCAmelCase     :      Optional[Any]														=       merge(*(reversed(SCREAMING_SNAKE_CASE__							) for stack in stacks)							)
     return collection


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