def 	__lowerCamelCase							(				__a    : str      ,							__a    : List[Any]		)      ->       list[list[int]]:
	_lowercase   =[]
	_lowercase   =len(lowercase_		)
	for i in range(lowercase_		):
		_lowercase   =[]
		for j in range(lowercase_		):
			_lowercase   =0
			for k in range(lowercase_		):
				_lowercase   =val + matrix_a[i][k] * matrix_b[k][j]
			list_a.append(lowercase_		)
		matrix_c.append(lowercase_		)
	return matrix_c

def 	__lowerCamelCase							(				__a    : Union[str, Any]		)      ->       list[list[int]]:
	return [[int(row == column		) for column in range(lowercase_		)] for row in range(lowercase_		)]

def 	__lowerCamelCase							(				__a    : Union[str, Any]		)      ->       int:
	if n <= 1:
		return n
	_lowercase   =identity(2		)
	_lowercase   =[[1, 1], [1, 0]]
	_lowercase   =n - 1
	while n > 0:
		if n % 2 == 1:
			_lowercase   =multiply(lowercase_      ,							lowercase_		)
		_lowercase   =multiply(lowercase_      ,							lowercase_		)
		_lowercase   =int(n / 2		)
	return res_matrix[0][0]

def 	__lowerCamelCase							(				__a    : Any		)      ->       int:
	if n <= 1:
		return n
	_lowercase   =0
	_lowercase   =1
	for _ in range(2      ,							n + 1		):
		_lowercase   ,  _lowercase   =fiba, fiba + fiba
	return fiba

def 	__lowerCamelCase							(				)      ->       None:
	for ordinal in "0th 1st 2nd 3rd 10th 100th 1000th".split():
		_lowercase   =int("".join(c for c in ordinal if c in "0123456789"		)		)  # 1000th --> 1000
		print(
		    f'''{ordinal} fibonacci number using matrix exponentiation is '''
		    f'''{nth_fibonacci_matrix(lowercase_		)} and using bruteforce is '''
		    f'''{nth_fibonacci_bruteforce(lowercase_		)}\n'''		)
	# from timeit import timeit
	# print(timeit("nth_fibonacci_matrix(1000000)",
	#              "from main import nth_fibonacci_matrix", number=5))
	# print(timeit("nth_fibonacci_bruteforce(1000000)",
	#              "from main import nth_fibonacci_bruteforce", number=5))
	# 2.3342058970001744
	# 57.256506615000035


if __name__ == "__main__":
						import doctest

						doctest.testmod()
						main()










"""simple docstring"""



import numpy as np
import qiskit







def     _SCREAMING_SNAKE_CASE  (				lowercase_     ,					lowercase_		)		->						qiskit.QuantumCircuit:
 A__			=							qiskit.QuantumCircuit(num_qubits + 1		)

 # First, let's deal with the case in which oracle is balanced
 if case == "balanced":
  # First generate a random number that tells us which CNOTs to
  # wrap in X-gates:
  A__			=							np.random.randint(1     ,					2**num_qubits		)
  # Next, format 'b' as a binary string of length 'n', padded with zeros:
  A__			=							format(lowercase_     ,					f"""0{num_qubits}b"""		)
  # Next, we place the first X-gates. Each digit in our binary string
  # corresponds to a qubit, if the digit is 0, we do nothing, if it's 1
  # we apply an X-gate to that qubit:
  for index, bit in enumerate(lowercase_		):
   if bit == "1":
    oracle_qc.x(lowercase_		)
        # Do the controlled-NOT gates for each qubit, using the output qubit
        # as the target:
  for index in range(lowercase_		):
   oracle_qc.cx(lowercase_     ,					lowercase_		)
  # Next, place the final X-gates
  for index, bit in enumerate(lowercase_		):
   if bit == "1":
    oracle_qc.x(lowercase_		)

    # Case in which oracle is constant
 if case == "constant":
  # First decide what the fixed output of the oracle will be
  # (either always 0 or always 1)
  A__			=							np.random.randint(2		)
  if output == 1:
   oracle_qc.x(lowercase_		)

 A__			=							oracle_qc.to_gate()
 A__			=							"Oracle"  # To show when we display the circuit
 return oracle_gate







def     _SCREAMING_SNAKE_CASE  (				lowercase_     ,					lowercase_		)		->						qiskit.QuantumCircuit:
 A__			=							qiskit.QuantumCircuit(num_qubits + 1     ,					lowercase_		)
 # Set up the output qubit:
 dj_circuit.x(lowercase_		)
 dj_circuit.h(lowercase_		)
 # And set up the input register:
 for qubit in range(lowercase_		):
  dj_circuit.h(lowercase_		)
 # Let's append the oracle gate to our circuit:
 dj_circuit.append(lowercase_     ,					range(num_qubits + 1		)		)
 # Finally, perform the H-gates again and measure:
 for qubit in range(lowercase_		):
  dj_circuit.h(lowercase_		)

 for i in range(lowercase_		):
  dj_circuit.measure(lowercase_     ,					lowercase_		)

 return dj_circuit







def     _SCREAMING_SNAKE_CASE  (				lowercase_     ,					lowercase_		)		->						qiskit.result.counts.Counts:
 A__			=							qiskit.Aer.get_backend("aer_simulator"		)

 A__			=							dj_oracle(lowercase_     ,					lowercase_		)
 A__			=							dj_algorithm(lowercase_     ,					lowercase_		)

 # Execute the circuit on the simulator
 A__			=							qiskit.execute(lowercase_     ,					lowercase_     ,					shots=10_00		)

 # Return the histogram data of the results of the experiment.
 return job.result().get_counts(lowercase_		)


if __name__ == "__main__":
      print(f'Deutsch Jozsa - Constant Oracle: {deutsch_jozsa("constant", 3)}')
      print(f'Deutsch Jozsa - Balanced Oracle: {deutsch_jozsa("balanced", 3)}')





