


'''simple docstring'''


from __future__ import annotations

import math
from collections import Counter
from string import ascii_lowercase






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

		# one length string
		_UpperCAmelCase						:				List[str]	    =					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						:				str	    =					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						:				Union[str, Any]	    =					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						:				Any	    =					cha + cha
						if sequence in two_char_strings:
								_UpperCAmelCase						:				Tuple	    =					two_char_strings[sequence]
								_UpperCAmelCase						:				List[Any]	    =					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						:				Any	    =					Counter()  # type: ignore
		_UpperCAmelCase						:				Optional[int]	    =					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       (__lowerCAmelCase					,       __lowerCAmelCase      ):

		if density <= 0:
				raise ValueError("Impossible fluid density"      )
		if bulk_modulus <= 0:
				raise ValueError("Impossible bulk modulus"      )

		return (bulk_modulus / density) ** 0.5


if __name__ == "__main__":
						import doctest

						doctest.testmod()



