





import numpy as np
import qiskit




def  A_(      A					,   A ):
	UpperCAmelCase_		    =  qiskit.QuantumCircuit(num_qubits + 1 )

	# First, let's deal with the case in which oracle is balanced
	if case == "balanced":
		# First generate a random number that tells us which CNOTs to
		# wrap in X-gates:
		UpperCAmelCase_		    =  np.random.randint(1					,   2**num_qubits )
		# Next, format 'b' as a binary string of length 'n', padded with zeros:
		UpperCAmelCase_		    =  format(A					,   f"""0{num_qubits}b""" )
		# Next, we place the first X-gates. Each digit in our binary string
		# corresponds to a qubit, if the digit is 0, we do nothing, if it's 1
		# we apply an X-gate to that qubit:
		for index, bit in enumerate(A ):
			if bit == "1":
				oracle_qc.x(A )
        # Do the controlled-NOT gates for each qubit, using the output qubit
        # as the target:
		for index in range(A ):
			oracle_qc.cx(A					,   A )
		# Next, place the final X-gates
		for index, bit in enumerate(A ):
			if bit == "1":
				oracle_qc.x(A )

    # Case in which oracle is constant
	if case == "constant":
		# First decide what the fixed output of the oracle will be
		# (either always 0 or always 1)
		UpperCAmelCase_		    =  np.random.randint(2 )
		if output == 1:
			oracle_qc.x(A )

	UpperCAmelCase_		    =  oracle_qc.to_gate()
	UpperCAmelCase_		    =  """Oracle"""  # To show when we display the circuit
	return oracle_gate




def  A_(      A					,   A ):
	UpperCAmelCase_		    =  qiskit.QuantumCircuit(num_qubits + 1					,   A )
	# Set up the output qubit:
	dj_circuit.x(A )
	dj_circuit.h(A )
	# And set up the input register:
	for qubit in range(A ):
		dj_circuit.h(A )
	# Let's append the oracle gate to our circuit:
	dj_circuit.append(A					,   range(num_qubits + 1 ) )
	# Finally, perform the H-gates again and measure:
	for qubit in range(A ):
		dj_circuit.h(A )

	for i in range(A ):
		dj_circuit.measure(A					,   A )

	return dj_circuit




def  A_(      A					,   A ):
	UpperCAmelCase_		    =  qiskit.Aer.get_backend("""aer_simulator""" )

	UpperCAmelCase_		    =  dj_oracle(A					,   A )
	UpperCAmelCase_		    =  dj_algorithm(A					,   A )

	# Execute the circuit on the simulator
	UpperCAmelCase_		    =  qiskit.execute(A					,   A					,   shots=1000 )

	# Return the histogram data of the results of the experiment.
	return job.result().get_counts(A )


if __name__ == "__main__":
				print(f"Deutsch Jozsa - Constant Oracle: {deutsch_jozsa('constant', 3)}")
				print(f"Deutsch Jozsa - Balanced Oracle: {deutsch_jozsa('balanced', 3)}")









import doctest

import projectq
from projectq.ops import H, Measure




def  A_(      A ):
	UpperCAmelCase_		    =  quantum_engine.allocate_qubit()
	H | qubit
	Measure | qubit
	return int(A )


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

				# initialises a new quantum backend
				UpperCamelCase__ :			Dict       	=			projectq.MainEngine()

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

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

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


