



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

import math
from collections import Counter
from string import ascii_lowercase
def    A_  (			_lowercase	):







						'''simple docstring'''


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

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

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

						# two len string
						snake_case_ :Dict						=			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_ :Dict						=			cha + cha
																		if sequence in two_char_strings:
																								snake_case_ :Union[str, Any]						=			two_char_strings[sequence]
																								snake_case_ :Union[str, Any]						=			int(_lowercase	) / all_sum
																								my_sec_sum += prob * math.loga(_lowercase	)

    # 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_  (			_lowercase	):







						'''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(_lowercase	) - 1	):
												single_char_strings[text[i]] += 1
												two_char_strings[text[i : i + 2]] += 1
						return single_char_strings, two_char_strings
def    A_  (			):







						'''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"""
import re
def    A_  (			_lowercase	):







						'''simple docstring'''


						snake_case_ :Optional[int]						=			re.compile(
						    r"""^(?:0|94|\+94|0{2}94)""" r"""7(0|1|2|4|5|6|7|8)""" r"""(-| |)""" r"""\d{7}$"""	)

						return bool(re.search(_lowercase,					_lowercase	)	)


if __name__ == "__main__":
						__a      =				"0094702343221"

						print(is_sri_lankan_phone_number(phone))
