"""simple docstring"""







import math

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


def 	a__   (		UpperCAmelCase__							:      Any = 1		,      UpperCAmelCase__							:      Optional[Any] = 1      )->						qiskit.result.counts.Counts:
						if isinstance(_SCREAMING_SNAKE_CASE		,      _SCREAMING_SNAKE_CASE      ) or isinstance(_SCREAMING_SNAKE_CASE		,      _SCREAMING_SNAKE_CASE      ):
												raise TypeError("""inputs must be integers."""      )
						if (bit_a < 0) or (bit_a < 0):
												raise ValueError("""inputs must be positive."""      )
						if (math.floor(_SCREAMING_SNAKE_CASE      ) != bit_a) or (math.floor(_SCREAMING_SNAKE_CASE      ) != 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__       						=		QuantumRegister(2		,      """qr"""      )
						UpperCAmelCase__       						=		ClassicalRegister(2		,      """cr"""      )

						UpperCAmelCase__       						=		QuantumCircuit(_SCREAMING_SNAKE_CASE		,      _SCREAMING_SNAKE_CASE      )

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

						# send the information
						UpperCAmelCase__       						=		str(_SCREAMING_SNAKE_CASE      ) + str(_SCREAMING_SNAKE_CASE      )

						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(_SCREAMING_SNAKE_CASE		,      _SCREAMING_SNAKE_CASE      )

						UpperCAmelCase__       						=		Aer.get_backend("""aer_simulator"""      )
						UpperCAmelCase__       						=		execute(_SCREAMING_SNAKE_CASE		,      _SCREAMING_SNAKE_CASE		,      shots=1_0_0_0      )

						return job.result().get_counts(_SCREAMING_SNAKE_CASE      )


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









"""simple docstring"""



from string import ascii_uppercase




def       snake_case__		(   _SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE = False       ,	_SCREAMING_SNAKE_CASE = ascii_uppercase			)    ->str:
 UpperCAmelCase__ 						=				keyword.upper()
 UpperCAmelCase__ 						=				plaintext.upper()
 UpperCAmelCase__ 						=				set(_SCREAMING_SNAKE_CASE			)

 # create a list of unique characters in the keyword - their order matters
 # it determines how we will map plaintext characters to the ciphertext
 UpperCAmelCase__ 						=				[]
 for char in keyword:
  if char in alphabet_set and char not in unique_chars:
   unique_chars.append(_SCREAMING_SNAKE_CASE			)
    # the number of those unique characters will determine the number of rows
 UpperCAmelCase__ 						=				len(_SCREAMING_SNAKE_CASE			)

 # create a shifted version of the alphabet
 UpperCAmelCase__ 						=				unique_chars + [
     char for char in alphabet if char not in unique_chars
 ]

 # create a modified alphabet by splitting the shifted alphabet into rows
 UpperCAmelCase__ 						=				[
     shifted_alphabet[k : k + num_unique_chars_in_keyword]
     for k in range(0       ,	2_6       ,	_SCREAMING_SNAKE_CASE			)
 ]

 # map the alphabet characters to the modified alphabet characters
 # going 'vertically' through the modified alphabet - consider columns first
 UpperCAmelCase__ 						=				{}
 UpperCAmelCase__ 						=				0
 for column in range(_SCREAMING_SNAKE_CASE			):
  for row in modified_alphabet:
   # if current row (the last one) is too short, break out of loop
   if len(_SCREAMING_SNAKE_CASE			) <= column:
    break

   # map current letter to letter in modified alphabet
   UpperCAmelCase__ 						=				row[column]
   letter_index += 1

 if verbose:
  print(_SCREAMING_SNAKE_CASE			)
 # create the encrypted text by mapping the plaintext to the modified alphabet
 return "".join(mapping[char] if char in mapping else char for char in plaintext			)


if __name__ == "__main__":
 # example use
 print(mixed_keyword('''college''', '''UNIVERSITY'''))



