






from __future__ import annotations

import math
from collections import Counter
from string import ascii_lowercase



def       _A    (__a							)				-> None:
    """simple docstring"""






    SCREAMING_SNAKE_CASE_   :						List[Any]							=	analyze_text(__a							)
    SCREAMING_SNAKE_CASE_   :						Tuple							=	list(''' ''' + ascii_lowercase							)
    # what is our total sum of probabilities.
    SCREAMING_SNAKE_CASE_   :						List[Any]							=	sum(single_char_strings.values()							)

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

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

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

    # 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    (__a							)				-> tuple[dict, dict]:
    """simple docstring"""






    SCREAMING_SNAKE_CASE_   :						str							=	Counter()  # type: ignore
    SCREAMING_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(__a							) - 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[int]:
    """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"""






# Algorithm for the pigeonhole sorting





def       _A    (__a							)				-> Dict:
    """simple docstring"""






    SCREAMING_SNAKE_CASE_   :						Dict							=	min(__a							)  # min() finds the minimum value
    SCREAMING_SNAKE_CASE_   :						int							=	max(__a							)  # max() finds the maximum value

    SCREAMING_SNAKE_CASE_   :						Dict							=	max_val - min_val + 1  # size is difference of max and min values plus one

    # list of pigeonholes of size equal to the variable size
    SCREAMING_SNAKE_CASE_   :						Any							=	[0] * size

    # Populate the pigeonholes.
    for x in a:
        assert isinstance(__a					,       __a							), "integers only please"
        holes[x - min_val] += 1

    # Putting the elements back into the array in an order.
    SCREAMING_SNAKE_CASE_   :						Any							=	0
    for count in range(__a							):
        while holes[count] > 0:
            holes[count] -= 1
            SCREAMING_SNAKE_CASE_   :						Dict							=	count + min_val
            i += 1



def       _A    ()				-> Optional[int]:
    """simple docstring"""






    SCREAMING_SNAKE_CASE_   :						List[str]							=	[8, 3, 2, 7, 4, 6, 8]
    pigeonhole_sort(__a							)
    print('''Sorted order is:'''					,       ''' '''.join(__a							)							)


if __name__ == "__main__":
  main()


