





'''simple docstring'''




class UpperCAmelCase							:



    def __init__(  self					):
     __UpperCAmelCase					=   {}



    def 					__lowerCamelCase						(  self					):
     print(self.vertex					)
     for i in self.vertex:
      print(__A     ,			' -> '     ,			' -> '.join([str(__A					) for j in self.vertex[i]]					)					)



    def 					__lowerCamelCase						(  self     ,			__A     ,			__A					):
     # check if vertex is already present,
     if from_vertex in self.vertex:
      self.vertex[from_vertex].append(__A					)
     else:
      # else make a new vertex
      __UpperCAmelCase					=   [to_vertex]



    def 					__lowerCamelCase						(  self					):
     # visited array for storing already visited nodes
     __UpperCAmelCase					=   [False] * len(self.vertex					)

     # call the recursive helper function
     for i in range(len(self.vertex					)					):
      if not visited[i]:
       self.dfs_recursive(__A     ,			__A					)




    def 					__lowerCamelCase						(  self     ,			__A     ,			__A					):
     # mark start vertex as visited
     __UpperCAmelCase					=   True

     print(__A     ,			end=' '					)

     # Recur for all the vertices that are adjacent to this node
     for i in self.vertex:
      if not visited[i]:
       self.dfs_recursive(__A     ,			__A					)


if __name__ == "__main__":
    _A:					Optional[int]							=				Graph()
    g.add_edge(0, 1)
    g.add_edge(0, 2)
    g.add_edge(1, 2)
    g.add_edge(2, 0)
    g.add_edge(2, 3)
    g.add_edge(3, 3)

    g.print_graph()
    print("""DFS:""")
    g.dfs()

    # OUTPUT:
    # 0  ->  1 -> 2
    # 1  ->  2
    # 2  ->  0 -> 3
    # 3  ->  3
    # DFS:
    #  0 1 2 3












'''simple docstring'''




import math

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







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

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

 __UpperCAmelCase					=   QuantumCircuit(_lowerCAmelCase       ,    _lowerCAmelCase    )

 __UpperCAmelCase					=   number_of_qubits

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

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

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

 return job.result().get_counts(_lowerCAmelCase    )


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





