






'''simple docstring'''







_A     :      List[str]     					={0: [2, 3], 1: [0], 2: [1], 3: [4], 4: []}

_A     :      List[Any]     					={0: [1, 2, 3], 1: [2], 2: [0], 3: [4], 4: [5], 5: [3]}





def 			SCREAMING_SNAKE_CASE_	(UpperCamelCase    ,      UpperCamelCase    ,      UpperCamelCase				)				->	List[Any]:
							lowerCamelCase__ :     Optional[int]	  =	True
							lowerCamelCase__ :     List[str]	  =	[]

							for neighbour in graph[vert]:
														if not visited[neighbour]:
																					order += topology_sort(__a    ,      __a    ,      __a				)

							order.append(__a				)

							return order





def 			SCREAMING_SNAKE_CASE_	(UpperCamelCase    ,      UpperCamelCase    ,      UpperCamelCase				)				->	Optional[Any]:
							lowerCamelCase__ :     Optional[Any]	  =	True
							lowerCamelCase__ :     Union[str, Any]	  =	[vert]

							for neighbour in reversed_graph[vert]:
														if not visited[neighbour]:
																					component += find_components(__a    ,      __a    ,      __a				)

							return component





def 			SCREAMING_SNAKE_CASE_	(UpperCamelCase				)				->	Union[str, Any]:
							lowerCamelCase__ :     List[str]	  =	len(__a				) * [False]
							lowerCamelCase__ :     List[str]	  =	{vert: [] for vert in range(len(__a				)				)}

							for vert, neighbours in graph.items():
														for neighbour in neighbours:
																					reversed_graph[neighbour].append(__a				)

							lowerCamelCase__ :     Dict	  =	[]
							for i, was_visited in enumerate(__a				):
														if not was_visited:
																					order += topology_sort(__a    ,      __a    ,      __a				)

							lowerCamelCase__ :     Optional[Any]	  =	[]
							lowerCamelCase__ :     Union[str, Any]	  =	len(__a				) * [False]

							for i in range(len(__a				)				):
														lowerCamelCase__ :     Optional[Any]	  =	order[len(__a				) - i - 1]
														if not visited[vert]:
																					lowerCamelCase__ :     List[str]	  =	find_components(__a    ,      __a    ,      __a				)
																					components_list.append(__a				)

							return components_list









'''simple docstring'''







def 			SCREAMING_SNAKE_CASE_	(UpperCamelCase				)				->	list:

							# bit count represents no. of bits in the gray code
							if bit_count < 0:
														raise ValueError("""The given input must be positive"""				)

							# get the generated string sequence
							lowerCamelCase__ :     List[str]	  =	gray_code_sequence_string(UpperCamelCase				)
							#
							# convert them to integers
							for i in range(len(UpperCamelCase				)				):
														lowerCamelCase__ :     int	  =	int(sequence[i]    ,      2				)

							return sequence





def 			SCREAMING_SNAKE_CASE_	(UpperCamelCase				)				->	list:

							# The approach is a recursive one
							# Base case achieved when either n = 0 or n=1
							if bit_count == 0:
														return ["0"]

							if bit_count == 1:
														return ["0", "1"]

							lowerCamelCase__ :     Optional[Any]	  =	1 << bit_count  # defines the length of the sequence
							# 1<< n is equivalent to 2^n

							# recursive answer will generate answer for n-1 bits
							lowerCamelCase__ :     Any	  =	gray_code_sequence_string(bit_count - 1				)

							lowerCamelCase__ :     Union[str, Any]	  =	[]

							# append 0 to first half of the smaller sequence generated
							for i in range(seq_len // 2				):
														lowerCamelCase__ :     Optional[int]	  =	"""0""" + smaller_sequence[i]
														sequence.append(UpperCamelCase				)

							# append 1 to second half ... start from the end of the list
							for i in reversed(range(seq_len // 2				)				):
														lowerCamelCase__ :     int	  =	"""1""" + smaller_sequence[i]
														sequence.append(UpperCamelCase				)

							return sequence


if __name__ == "__main__":
			import doctest

			doctest.testmod()

