





from __future__ import annotations

import math
from collections import Counter
from string import ascii_lowercase







def   __lowerCamelCase   (				__a  :str       )						->							None:






		"""simple docstring"""

		A__ ,     A__     =  analyze_text(__a       )
		A__     =  list(""" """ + ascii_lowercase       )
		# what is our total sum of probabilities.
		A__     =  sum(single_char_strings.values()       )

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






		"""simple docstring"""

		A__     =  Counter()  # type: ignore
		A__     =  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   __lowerCamelCase   (				)						->							List[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()










class     A     :
			'''simple docstring'''




			def __init__(     self  :       Optional[int]  )      ->      Dict:







					"""simple docstring"""






					A__     =  {}






			def   a_			(     self  :       Any  )      ->      None:







					"""simple docstring"""






					print(self.vertex  )
					for i in self.vertex:
							print(__lowerCAmelCase				,      """ -> """				,      """ -> """.join([str(__lowerCAmelCase  ) for j in self.vertex[i]]  )  )






			def   a_			(     self  :       Optional[int]				,      __lowerCAmelCase  :       int				,      __lowerCAmelCase  :       int  )      ->      None:







					"""simple docstring"""






					if from_vertex in self.vertex:
							self.vertex[from_vertex].append(__lowerCAmelCase  )
					else:
							# else make a new vertex
							A__     =  [to_vertex]






			def   a_			(     self  :       List[str]  )      ->      None:







					"""simple docstring"""






					A__     =  [False] * len(self.vertex  )

					# call the recursive helper function
					for i in range(len(self.vertex  )  ):
							if not visited[i]:
									self.dfs_recursive(__lowerCAmelCase				,      __lowerCAmelCase  )







			def   a_			(     self  :       List[str]				,      __lowerCAmelCase  :       int				,      __lowerCAmelCase  :       list  )      ->      None:







					"""simple docstring"""






					A__     =  True

					print(__lowerCAmelCase				,      end=""" """  )

					# Recur for all the vertices that are adjacent to this node
					for i in self.vertex:
							if not visited[i]:
									self.dfs_recursive(__lowerCAmelCase				,      __lowerCAmelCase  )


if __name__ == "__main__":
					A       :   Tuple					= Graph()
					g.add_edge(0, 1)
					g.add_edge(0, 2)
					g.add_edge(1, 2)
					g.add_edge(2, 0)
					g.add_edge(2, 3)
					g.add_edge(3, 3)

					g.print_graph()
					print('''DFS:''')
					g.dfs()

					# OUTPUT:
					# 0  ->  1 -> 2
					# 1  ->  2
					# 2  ->  0 -> 3
					# 3  ->  3
					# DFS:
					#  0 1 2 3



