




import math

import numpy as np
import qiskit
from qiskit import Aer, ClassicalRegister, QuantumCircuit, QuantumRegister, execute

def  UpperCAmelCase_							(				__UpperCAmelCase						:     int = 3							) ->			qiskit.result.counts.Counts:
      if isinstance(__UpperCAmelCase      ,      __UpperCAmelCase							):
            raise TypeError('number of qubits must be a integer.'							)
      if number_of_qubits <= 0:
            raise ValueError('number of qubits must be > 0.'							)
      if math.floor(__UpperCAmelCase							) != number_of_qubits:
            raise ValueError('number of qubits must be exact integer.'							)
      if number_of_qubits > 10:
            raise ValueError('number of qubits too large to simulate(>10).'							)

      SCREAMING_SNAKE_CASE_     						=      QuantumRegister(__UpperCAmelCase      ,      'qr'							)
      SCREAMING_SNAKE_CASE_     						=      ClassicalRegister(__UpperCAmelCase      ,      'cr'							)

      SCREAMING_SNAKE_CASE_     						=      QuantumCircuit(__UpperCAmelCase      ,      __UpperCAmelCase							)

      SCREAMING_SNAKE_CASE_     						=      number_of_qubits

      for i in range(__UpperCAmelCase							):
            quantum_circuit.h(number_of_qubits - i - 1							)
            counter -= 1
            for j in range(__UpperCAmelCase							):
                  quantum_circuit.cp(np.pi / 2 ** (counter - j)      ,      __UpperCAmelCase      ,      __UpperCAmelCase							)

      for k in range(number_of_qubits // 2							):
            quantum_circuit.swap(__UpperCAmelCase      ,      number_of_qubits - k - 1							)

      # measure all the qubits
      quantum_circuit.measure(__UpperCAmelCase      ,      __UpperCAmelCase							)
      # simulate with 10000 shots
      SCREAMING_SNAKE_CASE_     						=      Aer.get_backend('qasm_simulator'							)
      SCREAMING_SNAKE_CASE_     						=      execute(__UpperCAmelCase      ,      __UpperCAmelCase      ,      shots=1_00_00							)

      return job.result().get_counts(__UpperCAmelCase							)


if __name__ == "__main__":
   print(
       f'''Total count for quantum fourier transform state is: \
    {quantum_fourier_transform(3)}'''
   )





def  UpperCAmelCase_							(				__UpperCAmelCase						:     str							) ->			str:
      SCREAMING_SNAKE_CASE_     						=      ''
      for ch in key:
            if ch == " " or ch not in key_no_dups and ch.isalpha():
                  key_no_dups += ch
      return key_no_dups

def  UpperCAmelCase_							(				__UpperCAmelCase						:     str							) ->			dict[str, str]:
      SCREAMING_SNAKE_CASE_     						=      [chr(i + 65							) for i in range(26							)]
      # Remove duplicate characters from key
      SCREAMING_SNAKE_CASE_     						=      remove_duplicates(key.upper()							)
      SCREAMING_SNAKE_CASE_     						=      len(__UpperCAmelCase							)
      # First fill cipher with key characters
      SCREAMING_SNAKE_CASE_     						=      {alphabet[i]: char for i, char in enumerate(__UpperCAmelCase							)}
      # Then map remaining characters in alphabet to
      # the alphabet from the beginning
      for i in range(len(__UpperCAmelCase							)      ,      26							):
            SCREAMING_SNAKE_CASE_     						=      alphabet[i - offset]
            # Ensure we are not mapping letters to letters previously mapped
            while char in key:
                  offset -= 1
                  SCREAMING_SNAKE_CASE_     						=      alphabet[i - offset]
            SCREAMING_SNAKE_CASE_     						=      char
      return cipher_alphabet

def  UpperCAmelCase_							(				__UpperCAmelCase						:     str      ,      __UpperCAmelCase						:     dict[str, str]							) ->			str:
      return "".join(cipher_map.get(__UpperCAmelCase      ,      __UpperCAmelCase							) for ch in message.upper()							)

def  UpperCAmelCase_							(				__UpperCAmelCase						:     str      ,      __UpperCAmelCase						:     dict[str, str]							) ->			str:
      SCREAMING_SNAKE_CASE_     						=      {v: k for k, v in cipher_map.items()}
      return "".join(rev_cipher_map.get(__UpperCAmelCase      ,      __UpperCAmelCase							) for ch in message.upper()							)

def  UpperCAmelCase_							(				) ->			None:
      SCREAMING_SNAKE_CASE_     						=      input('Enter message to encode or decode: '							).strip()
      SCREAMING_SNAKE_CASE_     						=      input('Enter keyword: '							).strip()
      SCREAMING_SNAKE_CASE_     						=      input('Encipher or decipher? E/D:'							).strip()[0].lower()
      try:
            SCREAMING_SNAKE_CASE_     						=      {'e': encipher, 'd': decipher}[option]
      except KeyError:
            raise KeyError('invalid input option'							)
      SCREAMING_SNAKE_CASE_     						=      create_cipher_map(__UpperCAmelCase							)
      print(func(__UpperCAmelCase      ,      __UpperCAmelCase							)							)


if __name__ == "__main__":
   import doctest

   doctest.testmod()
   main()