



from string import ascii_uppercase







def  _snake_case			(							__snake_case       ,	__snake_case       ,	__snake_case = False       ,	__snake_case = ascii_uppercase     )  ->  str:






      '''simple docstring'''







      UpperCAmelCase_	:						List[Any]					   =		keyword.upper()
      UpperCAmelCase_	:						str					   =		plaintext.upper()
      UpperCAmelCase_	:						str					   =		set(__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_	:						Optional[Any]					   =		[]
      for char in keyword:
            if char in alphabet_set and char not in unique_chars:
                  unique_chars.append(__snake_case     )
    # the number of those unique characters will determine the number of rows
      UpperCAmelCase_	:						Tuple					   =		len(__snake_case     )

      # create a shifted version of the alphabet
      UpperCAmelCase_	:						str					   =		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_	:						Optional[int]					   =		[
          shifted_alphabet[k : k + num_unique_chars_in_keyword]
          for k in range(0       ,	2_6       ,	__snake_case     )
      ]

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

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

      if verbose:
            print(__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'''))





import math

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







def  _snake_case			(							__snake_case = 1       ,	__snake_case = 1     )  ->  qiskit.result.counts.Counts:






      '''simple docstring'''







      if isinstance(__snake_case       ,	__snake_case     ) or isinstance(__snake_case       ,	__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(__snake_case     ) != bit_a) or (math.floor(__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_	:						Union[str, Any]					   =		QuantumRegister(2       ,	"qr"     )
      UpperCAmelCase_	:						Tuple					   =		ClassicalRegister(2       ,	"cr"     )

      UpperCAmelCase_	:						Union[str, Any]					   =		QuantumCircuit(__snake_case       ,	__snake_case     )

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

      # send the information
      UpperCAmelCase_	:						Any					   =		str(__snake_case     ) + str(__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(__snake_case       ,	__snake_case     )

      UpperCAmelCase_	:						Union[str, Any]					   =		Aer.get_backend("aer_simulator"     )
      UpperCAmelCase_	:						Dict					   =		execute(__snake_case       ,	__snake_case       ,	shots=1_0_0_0     )

      return job.result().get_counts(__snake_case     )


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