





"""simple docstring"""


import numpy as np
import qiskit





def 							a__			(  _UpperCAmelCase	,     _UpperCAmelCase	)    ->  qiskit.QuantumCircuit:

 '''simple docstring'''






 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(_UpperCAmelCase	,     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(_UpperCAmelCase	):
   if bit == "1":
    oracle_qc.x(_UpperCAmelCase	)
        # Do the controlled-NOT gates for each qubit, using the output qubit
        # as the target:
  for index in range(_UpperCAmelCase	):
   oracle_qc.cx(_UpperCAmelCase	,     _UpperCAmelCase	)
  # Next, place the final X-gates
  for index, bit in enumerate(_UpperCAmelCase	):
   if bit == "1":
    oracle_qc.x(_UpperCAmelCase	)

    # 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(_UpperCAmelCase	)

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





def 							a__			(  _UpperCAmelCase	,     _UpperCAmelCase	)    ->  qiskit.QuantumCircuit:

 '''simple docstring'''






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

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

 return dj_circuit





def 							a__			(  _UpperCAmelCase	,     _UpperCAmelCase	)    ->  qiskit.result.counts.Counts:

 '''simple docstring'''






 snake_case__    							=				qiskit.Aer.get_backend("aer_simulator"	)

 snake_case__    							=				dj_oracle(_UpperCAmelCase	,     _UpperCAmelCase	)
 snake_case__    							=				dj_algorithm(_UpperCAmelCase	,     _UpperCAmelCase	)

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

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


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 							a__			(  _UpperCAmelCase = 1_0_0_0	)    ->  int:

 '''simple docstring'''






 snake_case__    							=				[]
 snake_case__    							=				[]
 snake_case__    							=				3
 snake_case__    							=				5
 snake_case__    							=				1
 while True:
  snake_case__    							=				z * temp
  if result < n:
   zmulti.append(_UpperCAmelCase	)
   temp += 1
  else:
   snake_case__    							=				1
   break
 while True:
  snake_case__    							=				x * temp
  if result < n:
   xmulti.append(_UpperCAmelCase	)
   temp += 1
  else:
   break
 snake_case__    							=				list(set(xmulti + zmulti	)	)
 return sum(_UpperCAmelCase	)


if __name__ == "__main__":
   print(f'''{solution() = }''')

