code: 
  
  
  
  
  
  import numpy as np
  import qiskit
  
  
  def 		_SCREAMING_SNAKE_CASE    (   lowerCAmelCase__       ,lowerCAmelCase__	):
  		lowerCamelCase_  :    List[Any]   	=			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:
  				lowerCamelCase_  :    Any   	=			np.random.randint(1       ,2**num_qubits	)
  				# Next, format 'b' as a binary string of length 'n', padded with zeros:
  				lowerCamelCase_  :    Tuple   	=			format(lowerCAmelCase__       ,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(lowerCAmelCase__	):
  						if bit == "1":
  								oracle_qc.x(lowerCAmelCase__	)
          # Do the controlled-NOT gates for each qubit, using the output qubit
          # as the target:
  				for index in range(lowerCAmelCase__	):
  						oracle_qc.cx(lowerCAmelCase__       ,lowerCAmelCase__	)
  				# Next, place the final X-gates
  				for index, bit in enumerate(lowerCAmelCase__	):
  						if bit == "1":
  								oracle_qc.x(lowerCAmelCase__	)
  
      # 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)
  				lowerCamelCase_  :    Dict   	=			np.random.randint(2	)
  				if output == 1:
  						oracle_qc.x(lowerCAmelCase__	)
  
  		lowerCamelCase_  :    Optional[int]   	=			oracle_qc.to_gate()
  		lowerCamelCase_  :    str   	=			'Oracle'  # To show when we display the circuit
  		return oracle_gate
  
  
  def 		_SCREAMING_SNAKE_CASE    (   lowerCAmelCase__       ,lowerCAmelCase__	):
  		lowerCamelCase_  :    int   	=			qiskit.QuantumCircuit(num_qubits + 1       ,lowerCAmelCase__	)
  		# Set up the output qubit:
  		dj_circuit.x(lowerCAmelCase__	)
  		dj_circuit.h(lowerCAmelCase__	)
  		# And set up the input register:
  		for qubit in range(lowerCAmelCase__	):
  				dj_circuit.h(lowerCAmelCase__	)
  		# Let's append the oracle gate to our circuit:
  		dj_circuit.append(lowerCAmelCase__       ,range(num_qubits + 1	)	)
  		# Finally, perform the H-gates again and measure:
  		for qubit in range(lowerCAmelCase__	):
  				dj_circuit.h(lowerCAmelCase__	)
  
  		for i in range(lowerCAmelCase__	):
  				dj_circuit.measure(lowerCAmelCase__       ,lowerCAmelCase__	)
  
  		return dj_circuit
  
  
  def 		_SCREAMING_SNAKE_CASE    (   lowerCAmelCase__       ,lowerCAmelCase__	):
  		lowerCamelCase_  :    Any   	=			qiskit.Aer.get_backend('aer_simulator'	)
  
  		lowerCamelCase_  :    Dict   	=			dj_oracle(lowerCAmelCase__       ,lowerCAmelCase__	)
  		lowerCamelCase_  :    Optional[int]   	=			dj_algorithm(lowerCAmelCase__       ,lowerCAmelCase__	)
  
  		# Execute the circuit on the simulator
  		lowerCamelCase_  :    Any   	=			qiskit.execute(lowerCAmelCase__       ,lowerCAmelCase__       ,shots=10_00	)
  
  		# Return the histogram data of the results of the experiment.
  		return job.result().get_counts(lowerCAmelCase__	)
  
  
  if __name__ == "__main__":
  		print(F'''Deutsch Jozsa - Constant Oracle: {deutsch_jozsa("constant", 3)}''')
  		print(F'''Deutsch Jozsa - Balanced Oracle: {deutsch_jozsa("balanced", 3)}''')
  
style_context: 
  
  
  
  
  
  def 		_SCREAMING_SNAKE_CASE    (   lowerCAmelCase__       ,lowerCAmelCase__	):
  		return (input_a, input_a).count(0	) % 2
  
  
  def 		_SCREAMING_SNAKE_CASE    (   ):
  		assert xor_gate(0       ,0	) == 0
  		assert xor_gate(0       ,1	) == 1
  		assert xor_gate(1       ,0	) == 1
  		assert xor_gate(1       ,1	) == 0
  
  
  if __name__ == "__main__":
  		print(xor_gate(0, 0))
  		print(xor_gate(0, 1))
  