
from __future__ import annotations

import math
from collections import Counter
from string import ascii_lowercase






def 	a_		(	__lowercase       :     str			)			->  None:
			_snake_case     , _snake_case          =      analyze_text(__lowercase			)
			_snake_case          =      list(' ' + ascii_lowercase			)
			# what is our total sum of probabilities.
			_snake_case          =      sum(single_char_strings.values()			)

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

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

			# two len string
			_snake_case          =      sum(two_char_strings.values()			)
			_snake_case          =      0
			# for each alpha (two in size) calculate entropy.
			for cha in my_alphas:
						for cha in my_alphas:
									_snake_case          =      cha + cha
									if sequence in two_char_strings:
												_snake_case          =      two_char_strings[sequence]
												_snake_case          =      int(__lowercase			) / all_sum
												my_sec_sum += prob * math.loga(__lowercase			)

    # 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 	a_		(	__lowercase       :     str			)			->  tuple[dict, dict]:
			_snake_case          =      Counter()  # type: ignore
			_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(__lowercase			) - 1			):
						single_char_strings[text[i]] += 1
						two_char_strings[text[i : i + 2]] += 1
			return single_char_strings, two_char_strings






def 	a_		(	)			->  str:
			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()

def 	a_		(	__lowercase       :     List[Any]			)			->  Tuple:
			_snake_case          =      len(__lowercase			)
			for i in range(length - 1			):
						_snake_case          =      i
						for k in range(i + 1	, __lowercase			):
									if collection[k] < collection[least]:
												_snake_case          =      k
						if least != i:
									_snake_case     , _snake_case          =      (collection[i], collection[least])
			return collection


if __name__ == "__main__":
			_lowerCamelCase	:    str          =      input('''Enter numbers separated by a comma:\n''').strip()
			_lowerCamelCase	:    List[Any]          =      [int(item) for item in user_input.split(''',''')]
			print(selection_sort(unsorted))