






"""simple docstring"""
from __future__ import annotations

import math
from collections import Counter
from string import ascii_lowercase


def 							A						(				__snake_case: str  )    ->		None:

       """simple docstring"""





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

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

       """simple docstring"""





       __magic_name__      				=    Counter()  # type: ignore
       __magic_name__      				=    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 							A						(				)    ->		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 maths.prime_check import is_prime


def 							A						(				__snake_case: int  )    ->		int:

       """simple docstring"""





       if not isinstance(__snake_case ,     __snake_case  ):
              __magic_name__      				=    F"""Input value of [number={number}] must be an integer"""
              raise TypeError(__snake_case  )
       if is_prime(__snake_case  ) and is_prime(number + 2  ):
              return number + 2
       else:
              return -1


if __name__ == "__main__":
 import doctest

 doctest.testmod()