
"""simple docstring"""





from __future__ import annotations

import math
from collections import Counter
from string import ascii_lowercase



def 						_lowerCAmelCase				(				UpperCamelCase_				):
		__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 						_lowerCAmelCase				(				UpperCamelCase_				):
		__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 						_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"""





__magic_name__       =			"Tobias Carryer"

from time import time
class 						SCREAMING_SNAKE_CASE_ :




		"""simple docstring"""





		def __init__(     self							,  lowerCAmelCase__							,  lowerCAmelCase__							,  lowerCAmelCase__							,  lowerCAmelCase__=int(time())):  # noqa: B008
				__SCREAMING_SNAKE_CASE            = multiplier
				__SCREAMING_SNAKE_CASE            = increment
				__SCREAMING_SNAKE_CASE            = modulo
				__SCREAMING_SNAKE_CASE            = seed




		def 	snake_case_     (     self):
				__SCREAMING_SNAKE_CASE            = (self.multiplier * self.seed + self.increment) % self.modulo
				return self.seed


if __name__ == "__main__":
							# Show the LCG in action.
							__magic_name__       =			LinearCongruentialGenerator(1664525, 1013904223, 2 << 31)
							while True:
														print(lcg.next_number())




