



"""simple docstring"""






from __future__ import annotations

import math
from collections import Counter
from string import ascii_lowercase






def 	snake_case_  (				A_ :		str						):


							'''simple docstring'''





							_lowerCamelCase						:    str         =			analyze_text(A_						)
							_lowerCamelCase						:    List[Any]         =			list(''' ''' + ascii_lowercase						)
							# what is our total sum of probabilities.
							_lowerCamelCase						:    Tuple         =			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						:    List[str]         =			single_char_strings[ch]
																					_lowerCamelCase						:    str         =			my_str / all_sum
																					my_fir_sum += prob * math.loga(A_						)  # entropy formula.

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

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

    # 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_  (				A_ :		str						):


							'''simple docstring'''





							_lowerCamelCase						:    Dict         =			Counter()  # type: ignore
							_lowerCamelCase						:    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(A_						) - 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_  (				):


							'''simple docstring'''





							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"""






from itertools import permutations






def 	snake_case_  (				A_ :		tuple						):


       '''simple docstring'''





       if num[3] % 2 != 0:
              return False

       if (num[2] + num[3] + num[4]) % 3 != 0:
              return False

       if num[5] % 5 != 0:
              return False

       _lowerCamelCase						:    Any         =			[7, 11, 13, 17]
       for i, test in enumerate(A_						):
              if (num[i + 4] * 1_00 + num[i + 5] * 10 + num[i + 6]) % test != 0:
                     return False
       return True






def 	snake_case_  (				A_ :		int = 10						):


       '''simple docstring'''





       return sum(
           int(''''''.join(map(A_,    A_						)						)						)
           for num in permutations(range(A_						)						)
           if is_substring_divisible(A_						)						)


if __name__ == "__main__":
   print(F"""{solution() = }""")


