





def 				__lowerCAmelCase(       _SCREAMING_SNAKE_CASE				)							-> str:




    """simple docstring"""




    _A     =							0

    # if input_string is "aba" than new_input_string become "a|b|a"
    _A     =							''
    _A     =							''

    # append each character + "|" in new_string for range(0, length-1)
    for i in input_string[: len(_SCREAMING_SNAKE_CASE				) - 1]:
        new_input_string += i + "|"
    # append last character
    new_input_string += input_string[-1]

    # we will store the starting and ending of previous furthest ending palindromic
    # substring
    _A,			_A     =							0, 0

    # length[i] shows the length of palindromic substring with center i
    _A     =							[1 for i in range(len(_SCREAMING_SNAKE_CASE				)				)]

    # for each character in new_string find corresponding palindromic string
    _A     =							0
    for j in range(len(_SCREAMING_SNAKE_CASE				)				):
        _A     =							1 if j > r else min(length[l + r - j] // 2							,     r - j + 1				)
        while (
            j - k >= 0
            and j + k < len(_SCREAMING_SNAKE_CASE				)
            and new_input_string[k + j] == new_input_string[j - k]
        ):
            k += 1

        _A     =							2 * k - 1

        # does this string is ending after the previously explored end (that is r) ?
        # if yes the update the new r to the last index of this
        if j + k - 1 > r:
            _A     =							j - k + 1  # noqa: E741
            _A     =							j + k - 1

        # update max_length and start position
        if max_length < length[j]:
            _A     =							length[j]
            _A     =							j

    # create that string
    _A     =							new_input_string[start - max_length // 2 : start + max_length // 2 + 1]
    for i in s:
        if i != "|":
            output_string += i

    return output_string


if __name__ == "__main__":
 import doctest

 doctest.testmod()










import math

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

def 	SCREAMING_SNAKE_CASE_							(	_snake_case	:int = 3				)  ->     qiskit.result.counts.Counts:
   if isinstance(_snake_case	,   _snake_case				):
      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(_snake_case				) != 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).'''				)

   _A      =       QuantumRegister(_snake_case	,   '''qr'''				)
   _A      =       ClassicalRegister(_snake_case	,   '''cr'''				)

   _A      =       QuantumCircuit(_snake_case	,   _snake_case				)

   _A      =       number_of_qubits

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

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

   # measure all the qubits
   quantum_circuit.measure(_snake_case	,   _snake_case				)
   # simulate with 10000 shots
   _A      =       Aer.get_backend('''qasm_simulator'''				)
   _A      =       execute(_snake_case	,   _snake_case	,   shots=10_000				)

   return job.result().get_counts(_snake_case				)


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



