




"""simple docstring"""


from __future__ import annotations


def  UpperCAmelCase__	(snake_case__							: list   ):
  """simple docstring"""

  if len(snake_case__   ) == 0:
    return []
  _snake_case		, _snake_case							:		Optional[Any]								=  min(snake_case__   ), max(snake_case__   )
  _snake_case							:		Optional[int]								=  int(max_value - min_value   ) + 1
  _snake_case							:		list[list]								=  [[] for _ in range(snake_case__   )]

  for i in my_list:
    buckets[int(i - min_value   )].append(snake_case__   )

  return [v for bucket in buckets for v in sorted(snake_case__   )]


if __name__ == "__main__":
     from doctest import testmod

     testmod()
     assert bucket_sort([4, 5, 3, 2, 1]) == [1, 2, 3, 4, 5]
     assert bucket_sort([0, 1, -10, 15, 2, -2]) == [-10, -2, 0, 1, 2, 15]








"""simple docstring"""


import math

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


def  UpperCAmelCase__	(snake_case__							: int = 3   ):
  """simple docstring"""

  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)."""   )

  _snake_case							:		Optional[int]								=  QuantumRegister(snake_case__		,       """qr"""   )
  _snake_case							:		List[Any]								=  ClassicalRegister(snake_case__		,       """cr"""   )

  _snake_case							:		Optional[int]								=  QuantumCircuit(snake_case__		,       snake_case__   )

  _snake_case							:		Dict								=  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
  _snake_case							:		Optional[int]								=  Aer.get_backend("""qasm_simulator"""   )
  _snake_case							:		Optional[int]								=  execute(snake_case__		,       snake_case__		,       shots=1_00_00   )

  return job.result().get_counts(snake_case__   )


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


