


# A Bipartite Graph is a graph whose vertices can be divided into two independent sets,
# U and V such that every edge (u, v) either connects a vertex from U to V or a vertex
# from V to U. In other words, for every edge (u, v), either u belongs to U and v to V,
# or u belongs to V and v to U. We can also say that there is no edge that connects
# vertices of same set.
from queue import Queue



def       lowerCAmelCase			(		lowerCAmelCase_			)->			List[str]:
				lowerCAmelCase_			:   Dict     					=					Queue()
				lowerCAmelCase_			:   Optional[Any]     					=					[False] * len(lowerCAmelCase_			)
				lowerCAmelCase_			:   Union[str, Any]     					=					[-1] * len(lowerCAmelCase_			)

				def bfs():
								while not queue.empty():
												lowerCAmelCase_			:   Optional[Any]     					=					queue.get()
												lowerCAmelCase_			:   List[Any]     					=					True

												for neighbour in graph[u]:
																if neighbour == u:
																				return False

																if color[neighbour] == -1:
																				lowerCAmelCase_			:   List[str]     					=					1 - color[u]
																				queue.put(lowerCAmelCase_			)

																elif color[neighbour] == color[u]:
																				return False

								return True

				for i in range(len(lowerCAmelCase_			)			):
								if not visited[i]:
												queue.put(lowerCAmelCase_			)
												lowerCAmelCase_			:   Union[str, Any]     					=					0
												if bfs() is False:
																return False

				return True


if __name__ == "__main__":
						# Adjacency List of graph
						print(check_bipartite({0: [1, 3], 1: [0, 2], 2: [1, 3], 3: [0, 2]}))



import doctest

import projectq
from projectq.ops import H, Measure



def       lowerCAmelCase			(		lowerCAmelCase_			)->			int:
				lowerCAmelCase_			:   List[Any]     					=					quantum_engine.allocate_qubit()
				H | qubit
				Measure | qubit
				return int(lowerCAmelCase_			)


if __name__ == "__main__":
						doctest.testmod()

						# initialises a new quantum backend
						_UpperCAmelCase      :	str  =projectq.MainEngine()

						# Generate a list of 10 random numbers
						_UpperCAmelCase      :	Optional[int]  =[get_random_number(quantum_engine) for _ in range(10)]

						# Flushes the quantum engine from memory
						quantum_engine.flush()

						print("""Random numbers""", random_numbers_list)