




from __future__ import annotations

import math
from collections import Counter
from string import ascii_lowercase

def  UpperCAmelCase_							(				__UpperCAmelCase						:     str							) ->			None:
						SCREAMING_SNAKE_CASE_						,			SCREAMING_SNAKE_CASE_     						=      analyze_text(__UpperCAmelCase							)
						SCREAMING_SNAKE_CASE_     						=      list(' ' + ascii_lowercase							)
						# what is our total sum of probabilities.
						SCREAMING_SNAKE_CASE_     						=      sum(single_char_strings.values()							)

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

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

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

    # 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						:     str							) ->			tuple[dict, dict]:
						SCREAMING_SNAKE_CASE_     						=      Counter()  # type: ignore
						SCREAMING_SNAKE_CASE_     						=      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(__UpperCAmelCase							) - 1							):
												single_char_strings[text[i]] += 1
												two_char_strings[text[i : i + 2]] += 1
						return single_char_strings, two_char_strings

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





from abc import ABC, abstractmethod
from argparse import ArgumentParser





class 	lowerCamelCase_							(				_SCREAMING_SNAKE_CASE ):


 '''simple docstring'''







 @staticmethod
 @abstractmethod
 def 				lowerCAmelCase_  (							_lowerCAmelCase  :		ArgumentParser						):
       raise NotImplementedError()




 @abstractmethod
 def 				lowerCAmelCase_  (							self  :		Dict						):
       raise NotImplementedError()