"""simple docstring"""







import numpy as np
import qiskit



def       A__    (	lowercase_     :	str      , lowercase_     :	int						)  ->							qiskit.QuantumCircuit:
   __lowerCamelCase    		=					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    		=					np.random.randint(1      , 2**num_qubits						)
      # Next, format 'b' as a binary string of length 'n', padded with zeros:
      __lowerCamelCase    		=					format(lowercase_      , 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(lowercase_						):
         if bit == "1":
            oracle_qc.x(lowercase_						)
        # Do the controlled-NOT gates for each qubit, using the output qubit
        # as the target:
      for index in range(lowercase_						):
         oracle_qc.cx(lowercase_      , lowercase_						)
      # Next, place the final X-gates
      for index, bit in enumerate(lowercase_						):
         if bit == "1":
            oracle_qc.x(lowercase_						)

    # 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    		=					np.random.randint(2						)
      if output == 1:
         oracle_qc.x(lowercase_						)

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



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

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

   return dj_circuit



def       A__    (	lowercase_     :	str      , lowercase_     :	int						)  ->							qiskit.result.counts.Counts:
   __lowerCamelCase    		=					qiskit.Aer.get_backend('aer_simulator'						)

   __lowerCamelCase    		=					dj_oracle(lowercase_      , lowercase_						)
   __lowerCamelCase    		=					dj_algorithm(lowercase_      , lowercase_						)

   # Execute the circuit on the simulator
   __lowerCamelCase    		=					qiskit.execute(lowercase_      , lowercase_      , shots=1000						)

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


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







"""simple docstring"""







def     __UpperCAmelCase							(       UpperCAmelCase_       :							str    )				->     str:

	'''simple docstring'''





	return " ".join(sorted(set(sentence.split()    )    )    )


if __name__ == "__main__":
	import doctest

	doctest.testmod()





