

from __future__ import annotations

import math
from collections import Counter
from string import ascii_lowercase


def        __lowerCAmelCase    (       _UpperCamelCase		:  str	)		->							None:
 '''simple docstring'''


 SCREAMING_SNAKE_CASE								=			analyze_text(__snake_case	)
 SCREAMING_SNAKE_CASE								=			list(' ' + ascii_lowercase	)
 # what is our total sum of probabilities.
 SCREAMING_SNAKE_CASE								=			sum(single_char_strings.values()	)

 # one length string
 SCREAMING_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:
   SCREAMING_SNAKE_CASE								=			single_char_strings[ch]
   SCREAMING_SNAKE_CASE								=			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
 SCREAMING_SNAKE_CASE								=			sum(two_char_strings.values()	)
 SCREAMING_SNAKE_CASE								=			0
 # for each alpha (two in size) calculate entropy.
 for cha in my_alphas:
  for cha in my_alphas:
   SCREAMING_SNAKE_CASE								=			cha + cha
   if sequence in two_char_strings:
    SCREAMING_SNAKE_CASE								=			two_char_strings[sequence]
    SCREAMING_SNAKE_CASE								=			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        __lowerCAmelCase    (       _UpperCamelCase		:  str	)		->							tuple[dict, dict]:
 '''simple docstring'''


 SCREAMING_SNAKE_CASE								=			Counter()  # type: ignore
 SCREAMING_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(__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        __lowerCAmelCase    (       )		->							str:
 '''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()







def        __lowerCAmelCase    (       _UpperCamelCase		:  int = 10_00	)		->							int:
 '''simple docstring'''


 SCREAMING_SNAKE_CASE								=			2**power
 SCREAMING_SNAKE_CASE								=			str(_UpperCamelCase	)
 SCREAMING_SNAKE_CASE								=			list(_UpperCamelCase	)
 SCREAMING_SNAKE_CASE								=			0

 for i in list_num:
  sum_of_num += int(_UpperCamelCase	)

 return sum_of_num


if __name__ == "__main__":
      a_    :						List[str]    		=      int(input("Enter the power of 2: ").strip())
      print("2 ^ ", power, " = ", 2**power)
      a_    :						int    		=      solution(power)
      print("Sum of the digits is: ", result)

