from __future__ import annotations

import math
from collections import Counter
from string import ascii_lowercase






def        __UpperCAmelCase    (       UpperCAmelCase       )->       None:



			"""simple docstring"""







			lowercase		,lowercase							=		analyze_text(UpperCAmelCase       )
			lowercase							=		list(''' ''' + ascii_lowercase       )
			# what is our total sum of probabilities.
			lowercase							=		sum(single_char_strings.values()       )

			# one length string
			lowercase							=		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:
									lowercase							=		single_char_strings[ch]
									lowercase							=		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
			lowercase							=		sum(two_char_strings.values()       )
			lowercase							=		0
			# for each alpha (two in size) calculate entropy.
			for cha in my_alphas:
						for cha in my_alphas:
									lowercase							=		cha + cha
									if sequence in two_char_strings:
												lowercase							=		two_char_strings[sequence]
												lowercase							=		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       )->       tuple[dict, dict]:



			"""simple docstring"""







			lowercase							=		Counter()  # type: ignore
			lowercase							=		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    (       )->       List[Any]:



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






def        __UpperCAmelCase    (       UpperCAmelCase,		UpperCAmelCase       )->       int:



			"""simple docstring"""







			while a != 0:
						lowercase		,lowercase							=		b % a, a
			return b






def        __UpperCAmelCase    (       UpperCAmelCase,		UpperCAmelCase       )->       int:



			"""simple docstring"""







			if gcd(UpperCAmelCase,		UpperCAmelCase       ) != 1:
						lowercase							=		f'mod inverse of {a!r} and {m!r} does not exist'
						raise ValueError(UpperCAmelCase       )
			lowercase		,lowercase		,lowercase							=		1, 0, a
			lowercase		,lowercase		,lowercase							=		0, 1, m
			while va != 0:
						lowercase							=		ua // va
						lowercase		,lowercase		,lowercase		,lowercase		,lowercase		,lowercase							=		(ua - q * va), (ua - q * va), (ua - q * va), va, va, va
			return ua % m





