






"""simple docstring"""



from __future__ import annotations

import math
from collections import Counter
from string import ascii_lowercase

def 					_snake_case							(	lowerCamelCase__      :       Any    )							->      None:
							lowerCamelCase_			:				Optional[Any]										=analyze_text(__snake_case    )
							lowerCamelCase_			:				str										=list(" " + ascii_lowercase    )
							# what is our total sum of probabilities.
							lowerCamelCase_			:				Tuple										=sum(single_char_strings.values()    )

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

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

							# two len string
							lowerCamelCase_			:				List[Any]										=sum(two_char_strings.values()    )
							lowerCamelCase_			:				str										=0
							# for each alpha (two in size) calculate entropy.
							for cha in my_alphas:
														for cha in my_alphas:
																					lowerCamelCase_			:				Union[str, Any]										=cha + cha
																					if sequence in two_char_strings:
																												lowerCamelCase_			:				List[str]										=two_char_strings[sequence]
																												lowerCamelCase_			:				Tuple										=int(__snake_case    ) / all_sum
																												my_sec_sum += prob * math.loga(__snake_case    )

    # 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 					_snake_case							(	lowerCamelCase__      :       List[str]    )							->      tuple[dict, dict]:
							lowerCamelCase_			:				Optional[int]										=Counter()  # type: ignore
							lowerCamelCase_			:				Optional[Any]										=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(__snake_case    ) - 1    ):
														single_char_strings[text[i]] += 1
														two_char_strings[text[i : i + 2]] += 1
							return single_char_strings, two_char_strings

def 					_snake_case							(	)							->      Union[str, Any]:
							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"""






# Function to print upper half of diamond (pyramid)


def      _lowercase							(    __snake_case      )		->  Dict:
			for i in range(0   ,__snake_case      ):
						for _ in range(0   ,n - i - 1      ):  # printing spaces
									print(" "   ,end=""      )
						for _ in range(0   ,i + 1      ):  # printing stars
									print("* "   ,end=""      )
						print()


def      _lowercase							(    __snake_case      )		->  Tuple:
			for i in range(__snake_case   ,0   ,-1      ):
						for _ in range(__snake_case   ,0   ,-1      ):  # printing stars
									print("* "   ,end=""      )
						print()
						for _ in range(n - i + 1   ,0   ,-1      ):  # printing spaces
									print(" "   ,end=""      )


def      _lowercase							(    __snake_case      )		->  Any:
			if n <= 0:
						print("       ...       ....        nothing printing :("      )
						return
			floyd(__snake_case      )  # upper half
			reverse_floyd(__snake_case      )  # lower half


if __name__ == "__main__":
	print(R'| /\ | |- |  |-  |--| |\  /| |-')
	print(R'|/  \| |- |_ |_  |__| | \/ | |_')
	__snake_case				:  Tuple =       1
	while K:
		__snake_case				:  List[str] =       int(input('enter the number and , and see the magic : '))
		print()
		pretty_print(user_number)
		__snake_case				:  Optional[Any] =       int(input('press 0 to exit... and 1 to continue...'))

	print('Good Bye...')