



'''simple docstring'''





from copy import deepcopy






class        lowerCAmelCase_:
  '''simple docstring'''




  def __init__(    self  ,__UpperCAmelCase = None  ,__UpperCAmelCase = None      )    ->		None:

      if arr is None and size is not None:
          lowerCAmelCase__ :  List[str]							      =					size
          lowerCAmelCase__ :  str							      =					[0] * size
      elif arr is not None:
          self.init(__UpperCAmelCase      )
      else:
          raise ValueError("""Either arr or size must be specified"""      )




  def 							UpperCAmelCase_	(    self  ,__UpperCAmelCase      )    ->		None:
      lowerCAmelCase__ :  Any							      =					len(__UpperCAmelCase      )
      lowerCAmelCase__ :  Any							      =					deepcopy(__UpperCAmelCase      )
      for i in range(1  ,self.size      ):
          lowerCAmelCase__ :  Optional[Any]							      =					self.next_(__UpperCAmelCase      )
          if j < self.size:
              self.tree[j] += self.tree[i]




  def 							UpperCAmelCase_	(    self      )    ->		list[int]:
      lowerCAmelCase__ :  Dict							      =					self.tree[:]
      for i in range(self.size - 1  ,0  ,-1      ):
          lowerCAmelCase__ :  Union[str, Any]							      =					self.next_(__UpperCAmelCase      )
          if j < self.size:
              arr[j] -= arr[i]
      return arr




  @staticmethod
  def 							UpperCAmelCase_	(    __UpperCAmelCase      )    ->		int:
      return index + (index & (-index))




  @staticmethod
  def 							UpperCAmelCase_	(    __UpperCAmelCase      )    ->		int:
      return index - (index & (-index))




  def 							UpperCAmelCase_	(    self  ,__UpperCAmelCase  ,__UpperCAmelCase      )    ->		None:
      if index == 0:
          self.tree[0] += value
          return
      while index < self.size:
          self.tree[index] += value
          lowerCAmelCase__ :  Optional[Any]							      =					self.next_(__UpperCAmelCase      )




  def 							UpperCAmelCase_	(    self  ,__UpperCAmelCase  ,__UpperCAmelCase      )    ->		None:
      self.add(__UpperCAmelCase  ,value - self.get(__UpperCAmelCase      )      )




  def 							UpperCAmelCase_	(    self  ,__UpperCAmelCase      )    ->		int:
      if right == 0:
          return 0
      lowerCAmelCase__ :  List[Any]							      =					self.tree[0]
      right -= 1  # make right inclusive
      while right > 0:
          result += self.tree[right]
          lowerCAmelCase__ :  Union[str, Any]							      =					self.prev(__UpperCAmelCase      )
      return result




  def 							UpperCAmelCase_	(    self  ,__UpperCAmelCase  ,__UpperCAmelCase      )    ->		int:
      return self.prefix(__UpperCAmelCase      ) - self.prefix(__UpperCAmelCase      )




  def 							UpperCAmelCase_	(    self  ,__UpperCAmelCase      )    ->		int:
      return self.query(__UpperCAmelCase  ,index + 1      )






  def 							UpperCAmelCase_	(    self  ,__UpperCAmelCase      )    ->		int:
      value -= self.tree[0]
      if value < 0:
          return -1

      lowerCAmelCase__ :  Any							      =					1  # Largest power of 2 <= size
      while j * 2 < self.size:
          j *= 2

      lowerCAmelCase__ :  int							      =					0

      while j > 0:
          if i + j < self.size and self.tree[i + j] <= value:
              value -= self.tree[i + j]
              i += j
          j //= 2
      return i


if __name__ == "__main__":
 import doctest

 doctest.testmod()







'''simple docstring'''





from __future__ import annotations

import math
from collections import Counter
from string import ascii_lowercase
def    _SCREAMING_SNAKE_CASE  (       UpperCamelCase			):



    """simple docstring"""





    lowerCAmelCase__      ,   lowerCAmelCase__ :  List[str]							      =					analyze_text(UpperCamelCase			)
    lowerCAmelCase__ :  Optional[int]							      =					list(""" """ + ascii_lowercase			)
    # what is our total sum of probabilities.
    lowerCAmelCase__ :  List[Any]							      =					sum(single_char_strings.values()			)

    # one length string
    lowerCAmelCase__ :  Optional[int]							      =					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[Any]							      =					single_char_strings[ch]
            lowerCAmelCase__ :  List[Any]							      =					my_str / all_sum
            my_fir_sum += prob * math.loga(UpperCamelCase			)  # entropy formula.

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

    # two len string
    lowerCAmelCase__ :  Dict							      =					sum(two_char_strings.values()			)
    lowerCAmelCase__ :  int							      =					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__ :  Dict							      =					two_char_strings[sequence]
                lowerCAmelCase__ :  Tuple							      =					int(UpperCamelCase			) / all_sum
                my_sec_sum += prob * math.loga(UpperCamelCase			)

    # 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    _SCREAMING_SNAKE_CASE  (       UpperCamelCase			):



    """simple docstring"""





    lowerCAmelCase__ :  Optional[Any]							      =					Counter()  # type: ignore
    lowerCAmelCase__ :  Tuple							      =					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(UpperCamelCase			) - 1			):
        single_char_strings[text[i]] += 1
        two_char_strings[text[i : i + 2]] += 1
    return single_char_strings, two_char_strings
def    _SCREAMING_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()


