
"""simple docstring"""







from __future__ import annotations

import math
from collections import Counter
from string import ascii_lowercase
def 					__lowerCAmelCase       (_UpperCamelCase	):
	__lowerCAmelCase    ,     __lowerCAmelCase    :		Optional[int]		    =   analyze_text(_UpperCamelCase	)
	__lowerCAmelCase    :		List[Any]		    =   list(' ' + ascii_lowercase	)
	# what is our total sum of probabilities.
	__lowerCAmelCase    :		List[str]		    =   sum(single_char_strings.values()	)

	# one length string
	__lowerCAmelCase    :		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:
			__lowerCAmelCase    :		int		    =   single_char_strings[ch]
			__lowerCAmelCase    :		Optional[int]		    =   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
	__lowerCAmelCase    :		Any		    =   sum(two_char_strings.values()	)
	__lowerCAmelCase    :		List[Any]		    =   0
	# for each alpha (two in size) calculate entropy.
	for cha in my_alphas:
		for cha in my_alphas:
			__lowerCAmelCase    :		Optional[int]		    =   cha + cha
			if sequence in two_char_strings:
				__lowerCAmelCase    :		Any		    =   two_char_strings[sequence]
				__lowerCAmelCase    :		Tuple		    =   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	):
	__lowerCAmelCase    :		List[str]		    =   Counter()  # type: ignore
	__lowerCAmelCase    :		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(_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"""







def 					__lowerCAmelCase       (_UpperCamelCase ,						_UpperCamelCase = False	):

	if not isinstance(_UpperCamelCase ,						_UpperCamelCase	):
		__lowerCAmelCase    :		str		    =   F"Expected string as input, found {type(_UpperCamelCase	)}"
		raise ValueError(_UpperCamelCase	)
	if not isinstance(_UpperCamelCase ,						_UpperCamelCase	):
		__lowerCAmelCase    :		Union[str, Any]		    =   F"Expected boolean as use_pascal parameter, found {type(_UpperCamelCase	)}"
		raise ValueError(_UpperCamelCase	)

	__lowerCAmelCase    :		Tuple		    =   input_str.split('_'	)

	__lowerCAmelCase    :		int		    =   0 if use_pascal else 1

	__lowerCAmelCase    :		Any		    =   words[start_index:]

	__lowerCAmelCase    :		Any		    =   [word[0].upper() + word[1:] for word in words_to_capitalize]

	__lowerCAmelCase    :		Any		    =   '' if use_pascal else words[0]

	return "".join([initial_word, *capitalized_words]	)


if __name__ == "__main__":
							from doctest import testmod

							testmod()