





'''simple docstring'''




from __future__ import annotations

import math
from collections import Counter
from string import ascii_lowercase
def 	UpperCAmelCase_							(					__lowercase							:      str       )		->       None:


     '''simple docstring'''



     _UpperCAmelCase							,  _UpperCAmelCase     							=   analyze_text(__lowercase       )
     _UpperCAmelCase     							=   list(" " + ascii_lowercase       )
     # what is our total sum of probabilities.
     _UpperCAmelCase     							=   sum(single_char_strings.values()       )

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


     '''simple docstring'''



     _UpperCAmelCase     							=   Counter()  # type: ignore
     _UpperCAmelCase     							=   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 	UpperCAmelCase_							(					)		->       Optional[Any]:


     '''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 math import pow
def 			__UpperCamelCase       (   UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     ):
 if current_sum == needed_sum:
  # If the sum of the powers is equal to needed_sum, then we have a solution.
  solutions_count += 1
  return current_sum, solutions_count

 lowercase__				:    Optional[Any]  =					int(pow(UpperCAmelCase		,     UpperCAmelCase     )     )
 if current_sum + i_to_n <= needed_sum:
  # If the sum of the powers is less than needed_sum, then continue adding powers.
  current_sum += i_to_n
  lowercase__ ,							lowercase__				:    Dict  =					backtrack(
      UpperCAmelCase		,     UpperCAmelCase		,     current_number + 1		,     UpperCAmelCase		,     UpperCAmelCase     )
  current_sum -= i_to_n
 if i_to_n < needed_sum:
  # If the power of i is less than needed_sum, then try with the next power.
  lowercase__ ,							lowercase__				:    str  =					backtrack(
      UpperCAmelCase		,     UpperCAmelCase		,     current_number + 1		,     UpperCAmelCase		,     UpperCAmelCase     )
 return current_sum, solutions_count
def 			__UpperCamelCase       (   UpperCAmelCase		,     UpperCAmelCase     ):
 if not (1 <= needed_sum <= 1000 and 2 <= power <= 10):
  raise ValueError(
      '''Invalid input\n'''
      '''needed_sum must be between 1 and 1000, power between 2 and 10.'''     )

 return backtrack(UpperCAmelCase		,     UpperCAmelCase		,     1		,     0		,     0     )[1]  # Return the solutions_count


if __name__ == "__main__":
  import doctest

  doctest.testmod()

