



import numpy as np
import qiskit







def    lowerCAmelCase_  (lowerCAmelCase__:		str		,	lowerCAmelCase__:		int     ):





			"""simple docstring"""


			UpperCAmelCase_:		Union[str, 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:
						UpperCAmelCase_:		Optional[Any]       			=					np.random.randint(1		,	2**num_qubits     )
						# Next, format 'b' as a binary string of length 'n', padded with zeros:
						UpperCAmelCase_:		Optional[Any]       			=					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)
						UpperCAmelCase_:		Union[str, Any]       			=					np.random.randint(2     )
						if output == 1:
									oracle_qc.x(lowerCAmelCase__     )

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







def    lowerCAmelCase_  (lowerCAmelCase__:		qiskit.QuantumCircuit		,	lowerCAmelCase__:		int     ):





			"""simple docstring"""


			UpperCAmelCase_:		Union[str, Any]       			=					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    lowerCAmelCase_  (lowerCAmelCase__:		str		,	lowerCAmelCase__:		int     ):





			"""simple docstring"""


			UpperCAmelCase_:		List[Any]       			=					qiskit.Aer.get_backend("""aer_simulator"""     )

			UpperCAmelCase_:		Tuple       			=					dj_oracle(lowerCAmelCase__		,	lowerCAmelCase__     )
			UpperCAmelCase_:		Union[str, Any]       			=					dj_algorithm(lowerCAmelCase__		,	lowerCAmelCase__     )

			# Execute the circuit on the simulator
			UpperCAmelCase_:		Optional[int]       			=					qiskit.execute(lowerCAmelCase__		,	lowerCAmelCase__		,	shots=1_0_0_0     )

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











import decimal







def    lowerCAmelCase_  ():





			"""simple docstring"""


			UpperCAmelCase_:		Union[str, Any]       			=    0
			UpperCAmelCase_:		Optional[Any]       			=    decimal.Context(prec=1_0_5     )
			for i in range(2		,	1_0_0     ):
						UpperCAmelCase_:		str       			=    decimal.Decimal(lowerCAmelCase__     )
						UpperCAmelCase_:		Any       			=    number.sqrt(lowerCAmelCase__     )
						if len(str(lowerCAmelCase__     )     ) > 1:
									answer += int(str(lowerCAmelCase__     )[0]     )
									UpperCAmelCase_:		str       			=    str(lowerCAmelCase__     )[2:1_0_1]
									answer += sum(int(lowerCAmelCase__     ) for x in sqrt_number_str     )
			return answer


if __name__ == "__main__":
	import doctest

	doctest.testmod()
	print(F'''{solution() = }''')






