
import numpy as np
import qiskit





def 		SCREAMING_SNAKE_CASE__			(					__lowerCAmelCase			,						__lowerCAmelCase							):
    snake_case__  = 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:
        snake_case__  = np.random.randint(1			,						2**num_qubits							)
        # Next, format 'b' as a binary string of length 'n', padded with zeros:
        snake_case__  = 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)
        snake_case__  = np.random.randint(2							)
        if output == 1:
            oracle_qc.x(__lowerCAmelCase							)

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





def 		SCREAMING_SNAKE_CASE__			(					__lowerCAmelCase			,						__lowerCAmelCase							):
    snake_case__  = 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							):
    snake_case__  = qiskit.Aer.get_backend("aer_simulator"							)

    snake_case__  = dj_oracle(__lowerCAmelCase			,						__lowerCAmelCase							)
    snake_case__  = dj_algorithm(__lowerCAmelCase			,						__lowerCAmelCase							)

    # Execute the circuit on the simulator
    snake_case__  = qiskit.execute(__lowerCAmelCase			,						__lowerCAmelCase			,						shots=1_000							)

    # 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)}''')







'''simple docstring'''






def 					_snake_case   (     A ,    A       )						->    float:
							return a + b


if __name__ == "__main__":
		__UpperCAmelCase    				=							5
		__UpperCAmelCase    				=							6
		print(f"""The sum of {a} + {b} is {add(a, b)}""")