


'''simple docstring'''





from __future__ import annotations

from random import randrange






def   __lowerCamelCase	(       lowerCamelCase__		:	Optional[int]			):





			'''simple docstring'''




			if len(_UpperCAmelCase			) < 2:
						return collection
			lowerCamelCase								=     randrange(len(_UpperCAmelCase			)			)  # Use random element as pivot
			lowerCamelCase								=     collection[pivot_index]
			lowerCamelCase								=     []  # All elements greater than pivot
			lowerCamelCase								=     []  # All elements less than or equal to pivot

			for element in collection[:pivot_index]:
						(greater if element > pivot else lesser).append(_UpperCAmelCase			)

			for element in collection[pivot_index + 1 :]:
						(greater if element > pivot else lesser).append(_UpperCAmelCase			)

			return [*quick_sort(_UpperCAmelCase			), pivot, *quick_sort(_UpperCAmelCase			)]


if __name__ == "__main__":
		UpperCAmelCase      :						List[Any]    =		input("Enter numbers separated by a comma:\n").strip()
		UpperCAmelCase      :						Tuple    =		[int(item) for item in user_input.split(",")]
		print(quick_sort(unsorted))





import math

import qiskit
from qiskit import Aer, ClassicalRegister, QuantumCircuit, QuantumRegister, execute






def   __lowerCamelCase	(       lowerCamelCase__		:	int = 1     ,       lowerCamelCase__		:	int = 1			):





			'''simple docstring'''




			if isinstance(lowerCamelCase__     ,       lowerCamelCase__			) or isinstance(lowerCamelCase__     ,       lowerCamelCase__			):
						raise TypeError("""inputs must be integers."""			)
			if (bit_a < 0) or (bit_a < 0):
						raise ValueError("""inputs must be positive."""			)
			if (math.floor(lowerCamelCase__			) != bit_a) or (math.floor(lowerCamelCase__			) != bit_a):
						raise ValueError("""inputs must be exact integers."""			)
			if (bit_a > 1) or (bit_a > 1):
						raise ValueError("""inputs must be less or equal to 1."""			)

			# build registers
			lowerCamelCase								=     QuantumRegister(2     ,       """qr"""			)
			lowerCamelCase								=     ClassicalRegister(2     ,       """cr"""			)

			lowerCamelCase								=     QuantumCircuit(lowerCamelCase__     ,       lowerCamelCase__			)

			# entanglement the qubits
			quantum_circuit.h(1			)
			quantum_circuit.cx(1     ,       0			)

			# send the information
			lowerCamelCase								=     str(lowerCamelCase__			) + str(lowerCamelCase__			)

			if c_information == "11":
						quantum_circuit.x(1			)
						quantum_circuit.z(1			)
			elif c_information == "10":
						quantum_circuit.z(1			)
			elif c_information == "01":
						quantum_circuit.x(1			)
			else:
						quantum_circuit.i(1			)

			# unentangled the circuit
			quantum_circuit.cx(1     ,       0			)
			quantum_circuit.h(1			)

			# measure the circuit
			quantum_circuit.measure(lowerCamelCase__     ,       lowerCamelCase__			)

			lowerCamelCase								=     Aer.get_backend("""aer_simulator"""			)
			lowerCamelCase								=     execute(lowerCamelCase__     ,       lowerCamelCase__     ,       shots=1000			)

			return job.result().get_counts(lowerCamelCase__			)


if __name__ == "__main__":
		print(f"""Counts for classical state send: {superdense_coding(1,1)}""")

