


'''simple docstring'''


from __future__ import annotations

import math
from collections import Counter
from string import ascii_lowercase






def  __lowerCAmelCase (__lowerCAmelCase   ):
		_UpperCAmelCase		:       str								=      analyze_text(__lowerCAmelCase   )
		_UpperCAmelCase		:       Dict								=      list(" " + ascii_lowercase   )
		# what is our total sum of probabilities.
		_UpperCAmelCase		:       Dict								=      sum(single_char_strings.values()   )

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

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

		# two len string
		_UpperCAmelCase		:       Tuple								=      sum(two_char_strings.values()   )
		_UpperCAmelCase		:       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		:       Tuple								=      two_char_strings[sequence]
								_UpperCAmelCase		:       str								=      int(__lowerCAmelCase   ) / all_sum
								my_sec_sum += prob * math.loga(__lowerCAmelCase   )

    # 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  __lowerCAmelCase (__lowerCAmelCase   ):
		_UpperCAmelCase		:       Optional[int]								=      Counter()  # type: ignore
		_UpperCAmelCase		:       Tuple								=      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(__lowerCAmelCase   ) - 1   ):
				single_char_strings[text[i]] += 1
				two_char_strings[text[i : i + 2]] += 1
		return single_char_strings, two_char_strings






def  __lowerCAmelCase ():
		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 ():
		_UpperCAmelCase		:       str								=      0
		for i in range(1      , 1_001   ):
				total += i**i
		return str(__lowerCAmelCase   )[-10:]


if __name__ == "__main__":
						print(solution())



