


'''simple docstring'''


import numpy as np
import qiskit







def       snake_case_       (  SCREAMING_SNAKE_CASE__							,				SCREAMING_SNAKE_CASE__					):







				"""simple docstring"""





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

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

				_SCREAMING_SNAKE_CASE			:	str							=				oracle_qc.to_gate()
				_SCREAMING_SNAKE_CASE			:	List[str]							=				"""Oracle"""  # To show when we display the circuit
				return oracle_gate







def       snake_case_       (  SCREAMING_SNAKE_CASE__							,				SCREAMING_SNAKE_CASE__					):







				"""simple docstring"""





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

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

				return dj_circuit







def       snake_case_       (  SCREAMING_SNAKE_CASE__							,				SCREAMING_SNAKE_CASE__					):







				"""simple docstring"""





				_SCREAMING_SNAKE_CASE			:	str							=				qiskit.Aer.get_backend("""aer_simulator"""					)

				_SCREAMING_SNAKE_CASE			:	int							=				dj_oracle(SCREAMING_SNAKE_CASE__							,				SCREAMING_SNAKE_CASE__					)
				_SCREAMING_SNAKE_CASE			:	Tuple							=				dj_algorithm(SCREAMING_SNAKE_CASE__							,				SCREAMING_SNAKE_CASE__					)

				# Execute the circuit on the simulator
				_SCREAMING_SNAKE_CASE			:	Any							=				qiskit.execute(SCREAMING_SNAKE_CASE__							,				SCREAMING_SNAKE_CASE__							,				shots=1000					)

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


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_       (  SCREAMING_SNAKE_CASE__							,				SCREAMING_SNAKE_CASE__					):







				"""simple docstring"""





				if len(str(SCREAMING_SNAKE_CASE__					)					) == 1 or len(str(SCREAMING_SNAKE_CASE__					)					) == 1:
								return a * b

				_SCREAMING_SNAKE_CASE			:	Optional[Any]							=				max(len(str(SCREAMING_SNAKE_CASE__					)					)							,				len(str(SCREAMING_SNAKE_CASE__					)					)					)
				_SCREAMING_SNAKE_CASE			:	Tuple							=				ma // 2

				_SCREAMING_SNAKE_CASE		,	_SCREAMING_SNAKE_CASE			:	Optional[int]							=				divmod(SCREAMING_SNAKE_CASE__							,				10**ma					)
				_SCREAMING_SNAKE_CASE		,	_SCREAMING_SNAKE_CASE			:	Optional[int]							=				divmod(SCREAMING_SNAKE_CASE__							,				10**ma					)

				_SCREAMING_SNAKE_CASE			:	Dict							=				karatsuba(SCREAMING_SNAKE_CASE__							,				SCREAMING_SNAKE_CASE__					)
				_SCREAMING_SNAKE_CASE			:	List[Any]							=				karatsuba((aa + aa)							,				(ba + ba)					)
				_SCREAMING_SNAKE_CASE			:	List[Any]							=				karatsuba(SCREAMING_SNAKE_CASE__							,				SCREAMING_SNAKE_CASE__					)

				return (z * 10 ** (2 * ma)) + ((y - z - x) * 10 ** (ma)) + (x)







def       snake_case_       (  ):







				"""simple docstring"""





				print(karatsuba(1_5463							,				2_3489					)					)


if __name__ == "__main__":
				main()




