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

import math
from collections import Counter
from string import ascii_lowercase

def 						UpperCamelCase_     (	__SCREAMING_SNAKE_CASE       ):
    """simple docstring"""






    snake_case_			, snake_case_ :    str     			=						analyze_text(__SCREAMING_SNAKE_CASE       )
    snake_case_ :    Union[str, Any]     			=						list(" " + ascii_lowercase       )
    # what is our total sum of probabilities.
    snake_case_ :    Any     			=						sum(single_char_strings.values()       )

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

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

    # two len string
    snake_case_ :    Optional[Any]     			=						sum(two_char_strings.values()       )
    snake_case_ :    Optional[Any]     			=						0
    # for each alpha (two in size) calculate entropy.
    for cha in my_alphas:
        for cha in my_alphas:
            snake_case_ :    int     			=						cha + cha
            if sequence in two_char_strings:
                snake_case_ :    Union[str, Any]     			=						two_char_strings[sequence]
                snake_case_ :    Any     			=						int(__SCREAMING_SNAKE_CASE       ) / all_sum
                my_sec_sum += prob * math.loga(__SCREAMING_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 						UpperCamelCase_     (	__SCREAMING_SNAKE_CASE       ):
    """simple docstring"""






    snake_case_ :    int     			=						Counter()  # type: ignore
    snake_case_ :    List[str]     			=						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(__SCREAMING_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 						UpperCamelCase_     (	):
    """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 __future__ import annotations

from cmath import sqrt

def 						UpperCamelCase_     (	__SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE       ):
    """simple docstring"""






    if a == 0:
        raise ValueError("Coefficient 'a' must not be zero."       )
    snake_case_ :    Union[str, Any]     			=						b * b - 4 * a * c

    snake_case_ :    List[str]     			=						(-b + sqrt(__SCREAMING_SNAKE_CASE       )) / (2 * a)
    snake_case_ :    int     			=						(-b - sqrt(__SCREAMING_SNAKE_CASE       )) / (2 * a)

    return (
        root_a.real if not root_a.imag else root_a,
        root_a.real if not root_a.imag else root_a,
    )

def 						UpperCamelCase_     (	):
    """simple docstring"""






    snake_case_			, snake_case_ :    str     			=						quadratic_roots(a=5,		b=6,		c=1       )
    print(f'The solutions are: {solutiona} and {solutiona}'       )


if __name__ == "__main__":
  main()




