


from __future__ import annotations

import math
from collections import Counter
from string import ascii_lowercase





def   _UpperCAmelCase       (     UpperCAmelCase      :			int      ):
      """simple docstring"""




      __lowerCamelCase     :      List[Any]       						=						analyze_text(_lowercase      )
      __lowerCamelCase     :      Any       						=						list(""" """ + ascii_lowercase      )
      # what is our total sum of probabilities.
      __lowerCamelCase     :      Union[str, Any]       						=						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     :      Any       						=						single_char_strings[ch]
                  __lowerCamelCase     :      int       						=						my_str / all_sum
                  my_fir_sum += prob * math.loga(_lowercase      )  # 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     :      Optional[Any]       						=						cha + cha
                  if sequence in two_char_strings:
                        __lowerCamelCase     :      int       						=						two_char_strings[sequence]
                        __lowerCamelCase     :      Optional[int]       						=						int(_lowercase      ) / all_sum
                        my_sec_sum += prob * math.loga(_lowercase      )

    # 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       (     UpperCAmelCase      :			Optional[Any]      ):
      """simple docstring"""




      __lowerCamelCase     :      Optional[Any]       						=						Counter()  # type: ignore
      __lowerCamelCase     :      List[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(_lowercase      ) - 1      ):
            single_char_strings[text[i]] += 1
            two_char_strings[text[i : i + 2]] += 1
      return single_char_strings, two_char_strings





def   _UpperCAmelCase       (     ):
      """simple docstring"""




      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()







from typing import Any





def   _UpperCAmelCase       (     UpperCAmelCase      :			list      ):
      """simple docstring"""




      if not input_list:
            return []
      __lowerCamelCase     :      int       						=						[input_list.count(UpperCAmelCase      ) for value in input_list]
      __lowerCamelCase     :      Tuple       						=						max(UpperCAmelCase      )  # Gets the maximum count in the input list.
      # Gets values of modes
      return sorted({input_list[i] for i, value in enumerate(UpperCAmelCase      ) if value == y}      )


if __name__ == "__main__":
    import doctest

    doctest.testmod()



