

'''simple docstring'''
from __future__ import annotations

import math
from collections import Counter
from string import ascii_lowercase







def 					_A		(	snake_case     )			->	Tuple:
   _lowercase			:      int			     =   analyze_text(lowerCAmelCase__     )
   _lowercase			:      Union[str, Any]			     =   list(" " + ascii_lowercase     )
   # what is our total sum of probabilities.
   _lowercase			:      Union[str, Any]			     =   sum(single_char_strings.values()     )

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

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

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

            # 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		(	snake_case     )			->	List[Any]:
   _lowercase			:      Any			     =   Counter()  # type: ignore
   _lowercase			:      int			     =   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(lowerCAmelCase__     ) - 1     ):
      single_char_strings[text[i]] += 1
      two_char_strings[text[i : i + 2]] += 1
   return single_char_strings, two_char_strings







def 					_A		(	)			->	Union[str, Any]:
   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    __UpperCamelCase     (				lowerCAmelCase__							:				str  ):
 if n_term == "":
  return []
 __a :  list						=  []
 for temp in range(int(lowerCAmelCase__  )  ):
  series.append(f"1/{temp + 1}" if series else '''1'''  )
 return series


if __name__ == "__main__":
      lowercase__       =input('Enter the last number (nth term) of the Harmonic Series')
      print('Formula of Harmonic Series => 1+1/2+1/3 ..... 1/n')
      print(harmonic_series(nth_term))
