

"""simple docstring"""


from __future__ import annotations






def 					a__					(					__SCREAMING_SNAKE_CASE      ,				__SCREAMING_SNAKE_CASE				)			->			str:
  __lowerCAmelCase: Any					   =    "", "", ""
  __lowerCAmelCase: Any					   =    []

  for character in message_part:
    tmp.append(character_to_number[character]				)

  for each in tmp:
    one += each[0]
    two += each[1]
    three += each[2]

  return one + two + three






def 					a__					(					__SCREAMING_SNAKE_CASE      ,				__SCREAMING_SNAKE_CASE				)			->			tuple[str, str, str]:
  __lowerCAmelCase: Union[str, Any]					   =    "", ""
  __lowerCAmelCase: int					   =    []

  for character in message_part:
    this_part += character_to_number[character]

  for digit in this_part:
    tmp += digit
    if len(__SCREAMING_SNAKE_CASE				) == len(__SCREAMING_SNAKE_CASE				):
      result.append(__SCREAMING_SNAKE_CASE				)
      __lowerCAmelCase: Union[str, Any]					   =    ""

  return result[0], result[1], result[2]






def 					a__					(					__SCREAMING_SNAKE_CASE      ,				__SCREAMING_SNAKE_CASE				)			->			tuple[str, str, dict[str, str], dict[str, str]]:
  # Validate message and alphabet, set to upper and remove spaces
  __lowerCAmelCase: int					   =    alphabet.replace(" "      ,				""				).upper()
  __lowerCAmelCase: int					   =    message.replace(" "      ,				""				).upper()

  # Check length and characters
  if len(__SCREAMING_SNAKE_CASE				) != 2_7:
    raise KeyError("Length of alphabet has to be 27."				)
  for each in message:
    if each not in alphabet:
      raise ValueError("Each message character has to be included in alphabet!"				)

    # Generate dictionares
  __lowerCAmelCase: Optional[int]					   =    (
      "111",
      "112",
      "113",
      "121",
      "122",
      "123",
      "131",
      "132",
      "133",
      "211",
      "212",
      "213",
      "221",
      "222",
      "223",
      "231",
      "232",
      "233",
      "311",
      "312",
      "313",
      "321",
      "322",
      "323",
      "331",
      "332",
      "333",
  )
  __lowerCAmelCase: Tuple					   =    {}
  __lowerCAmelCase: Optional[int]					   =    {}
  for letter, number in zip(__SCREAMING_SNAKE_CASE      ,				__SCREAMING_SNAKE_CASE				):
    __lowerCAmelCase: List[Any]					   =    number
    __lowerCAmelCase: Any					   =    letter

  return message, alphabet, character_to_number, number_to_character






def 					a__					(					__SCREAMING_SNAKE_CASE      ,				__SCREAMING_SNAKE_CASE = "ABCDEFGHIJKLMNOPQRSTUVWXYZ."      ,				__SCREAMING_SNAKE_CASE = 5				)			->			str:
  __lowerCAmelCase: Optional[int]					   =    __prepare(
      __SCREAMING_SNAKE_CASE      ,				__SCREAMING_SNAKE_CASE				)
  __lowerCAmelCase: str					   =    "", ""

  for i in range(0      ,				len(__SCREAMING_SNAKE_CASE				) + 1      ,				__SCREAMING_SNAKE_CASE				):
    encrypted_numeric += __encrypt_part(
        message[i : i + period]      ,				__SCREAMING_SNAKE_CASE				)

  for i in range(0      ,				len(__SCREAMING_SNAKE_CASE				)      ,				3				):
    encrypted += number_to_character[encrypted_numeric[i : i + 3]]

  return encrypted






def 					a__					(					__SCREAMING_SNAKE_CASE      ,				__SCREAMING_SNAKE_CASE = "ABCDEFGHIJKLMNOPQRSTUVWXYZ."      ,				__SCREAMING_SNAKE_CASE = 5				)			->			str:
  __lowerCAmelCase: Dict					   =    __prepare(
      __SCREAMING_SNAKE_CASE      ,				__SCREAMING_SNAKE_CASE				)
  __lowerCAmelCase: List[str]					   =    []
  __lowerCAmelCase: Optional[int]					   =    ""

  for i in range(0      ,				len(__SCREAMING_SNAKE_CASE				) + 1      ,				__SCREAMING_SNAKE_CASE				):
    __lowerCAmelCase: List[Any]					   =    __decrypt_part(message[i : i + period]      ,				__SCREAMING_SNAKE_CASE				)

    for j in range(0      ,				len(__SCREAMING_SNAKE_CASE				)				):
      decrypted_numeric.append(a[j] + b[j] + c[j]				)

  for each in decrypted_numeric:
    decrypted += number_to_character[each]

  return decrypted


if __name__ == "__main__":
   __A		     =    "DEFEND THE EAST WALL OF THE CASTLE."
   __A		     =    encrypt_message(msg, "EPSDUCVWYM.ZLKXNBTFGORIJHAQ")
   __A		     =    decrypt_message(encrypted, "EPSDUCVWYM.ZLKXNBTFGORIJHAQ")
   print(F'''Encrypted: {encrypted}\nDecrypted: {decrypted}''')





"""simple docstring"""


import math

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






def 					a__					(					__SCREAMING_SNAKE_CASE = 1      ,				__SCREAMING_SNAKE_CASE = 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
		__lowerCAmelCase: str					   =    QuantumRegister(2      ,				"qr"				)
		__lowerCAmelCase: Optional[Any]					   =    ClassicalRegister(2      ,				"cr"				)

		__lowerCAmelCase: Dict					   =    QuantumCircuit(__SCREAMING_SNAKE_CASE      ,				__SCREAMING_SNAKE_CASE				)

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

		# send the information
		__lowerCAmelCase: Dict					   =    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				)

		__lowerCAmelCase: List[str]					   =    Aer.get_backend("aer_simulator"				)
		__lowerCAmelCase: Dict					   =    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)}''')


