'''simple docstring'''


import math

import qiskit
from qiskit import Aer, ClassicalRegister, QuantumCircuit, QuantumRegister, execute


def    _lowerCamelCase       ( lowerCamelCase_   :				int = 1      ,	lowerCamelCase_   :				int = 1  ):



     """simple docstring"""





     if isinstance(lowerCamelCase_      ,	lowerCamelCase_  ) or isinstance(lowerCamelCase_      ,	lowerCamelCase_  ):
          raise TypeError('inputs must be integers.'  )
     if (bit_a < 0) or (bit_a < 0):
          raise ValueError('inputs must be positive.'  )
     if (math.floor(lowerCamelCase_  ) != bit_a) or (math.floor(lowerCamelCase_  ) != bit_a):
          raise ValueError('inputs must be exact integers.'  )
     if (bit_a > 1) or (bit_a > 1):
          raise ValueError('inputs must be less or equal to 1.'  )

     # build registers
     UpperCAmelCase_				:  Dict  = QuantumRegister(2      ,	'qr'  )
     UpperCAmelCase_				:  str  = ClassicalRegister(2      ,	'cr'  )

     UpperCAmelCase_				:  int  = QuantumCircuit(lowerCamelCase_      ,	lowerCamelCase_  )

     # entanglement the qubits
     quantum_circuit.h(1  )
     quantum_circuit.cx(1      ,	0  )

     # send the information
     UpperCAmelCase_				:  Union[str, Any]  = str(lowerCamelCase_  ) + str(lowerCamelCase_  )

     if c_information == "11":
          quantum_circuit.x(1  )
          quantum_circuit.z(1  )
     elif c_information == "10":
          quantum_circuit.z(1  )
     elif c_information == "01":
          quantum_circuit.x(1  )
     else:
          quantum_circuit.i(1  )

     # unentangled the circuit
     quantum_circuit.cx(1      ,	0  )
     quantum_circuit.h(1  )

     # measure the circuit
     quantum_circuit.measure(lowerCamelCase_      ,	lowerCamelCase_  )

     UpperCAmelCase_				:  List[Any]  = Aer.get_backend('aer_simulator'  )
     UpperCAmelCase_				:  int  = execute(lowerCamelCase_      ,	lowerCamelCase_      ,	shots=1000  )

     return job.result().get_counts(lowerCamelCase_  )


if __name__ == "__main__":
 print(f'''Counts for classical state send: {superdense_coding(1,1)}''')







'''simple docstring'''


def    _lowerCamelCase       ( lowerCamelCase_   :				list  ):



     """simple docstring"""





     UpperCAmelCase_				:  Optional[int]  = len(lowerCamelCase_  )

     # Set the gap value to be decreased by a factor of 1.3
     # after each iteration
     UpperCAmelCase_				:  Optional[Any]  = 1.3

     # Continue sorting until the gap is 1
     while gap > 1:
          # Decrease the gap value
          UpperCAmelCase_				:  Optional[Any]  = int(gap / shrink  )

          # Sort the elements using insertion sort
          for i in range(lowerCamelCase_      ,	len(lowerCamelCase_  )  ):
               UpperCAmelCase_				:  Optional[int]  = collection[i]
               UpperCAmelCase_				:  Tuple  = i
               while j >= gap and collection[j - gap] > temp:
                    UpperCAmelCase_				:  Tuple  = collection[j - gap]
                    j -= gap
               UpperCAmelCase_				:  Optional[int]  = temp

     return collection


if __name__ == "__main__":
 import doctest

 doctest.testmod()






