
'''simple docstring'''
import math

import qiskit







def 		A_(     A						:		int = 1		,     A						:		int = 1		,     A						:		int = 1):
							if (
							    isinstance(A		,     A)
							    or isinstance(A		,     A)
							    or isinstance(A		,     A)
							):
														raise TypeError('inputs must be integers.')

							if (input_a < 0) or (input_a < 0) or (carry_in < 0):
														raise ValueError('inputs must be positive.')

							if (
							    (math.floor(A) != input_a)
							    or (math.floor(A) != input_a)
							    or (math.floor(A) != carry_in)
							):
														raise ValueError('inputs must be exact integers.')

							if (input_a > 2) or (input_a > 2) or (carry_in > 2):
														raise ValueError('inputs must be less or equal to 2.')

							# build registers
							UpperCamelCase   			=     qiskit.QuantumRegister(4		,     'qr')
							UpperCamelCase   			=     qiskit.ClassicalRegister(2		,     'cr')
							# list the entries
							UpperCamelCase   			=     [input_a, input_a, carry_in]

							UpperCamelCase   			=     qiskit.QuantumCircuit(A		,     A)

							for i in range(0		,     3):
														if entry[i] == 2:
																					quantum_circuit.h(A)  # for hadamard entries
														elif entry[i] == 1:
																					quantum_circuit.x(A)  # for 1 entries
														elif entry[i] == 0:
																					quantum_circuit.i(A)  # for 0 entries

    # build the circuit
							quantum_circuit.ccx(0		,     1		,     3)  # ccx = toffoli gate
							quantum_circuit.cx(0		,     1)
							quantum_circuit.ccx(1		,     2		,     3)
							quantum_circuit.cx(1		,     2)
							quantum_circuit.cx(0		,     1)

							quantum_circuit.measure([2, 3]		,     A)  # measure the last two qbits

							UpperCamelCase   			=     qiskit.Aer.get_backend('aer_simulator')
							UpperCamelCase   			=     qiskit.execute(A		,     A		,     shots=1000)

							return job.result().get_counts(A)


if __name__ == "__main__":
						print(f"""Total sum count for state is: {quantum_full_adder(1, 1, 1)}""")






'''simple docstring'''
from __future__ import annotations

lowerCAmelCase					:    Union[str, Any]           = [-10, -5, 0, 5, 5.1, 11, 13, 21, 3, 4, -21, -10, -5, -1, 0]
lowerCAmelCase					:    List[str]           = [-5, 0, 5, 5.1, 11, 13, 21, -1, 4, -1, -10, -5, -1, 0, -1]







def 		A_(     A						:		list[float]):
							UpperCamelCase   			=     []
							UpperCamelCase   			=     len(A)

							for i in range(A):
														UpperCamelCase   			=     -1
														for j in range(i + 1		,     A):
																					if arr[i] < arr[j]:
																												UpperCamelCase   			=     arr[j]
																												break
														result.append(A)
							return result







def 		A_(     A						:		list[float]):
							UpperCamelCase   			=     []
							for i, outer in enumerate(A):
														UpperCamelCase   			=     -1
														for inner in arr[i + 1 :]:
																					if outer < inner:
																												UpperCamelCase   			=     inner
																												break
														result.append(A)
							return result







def 		A_(     A						:		list[float]):
							UpperCamelCase   			=     len(A)
							UpperCamelCase   			=     []
							UpperCamelCase   			=     [-1] * arr_size

							for index in reversed(range(A)):
														if stack:
																					while stack[-1] <= arr[index]:
																												stack.pop()
																												if not stack:
																																			break
														if stack:
																					UpperCamelCase   			=     stack[-1]
														stack.append(arr[index])
							return result


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

						testmod()
						print(next_greatest_element_slow(arr))
						print(next_greatest_element_fast(arr))
						print(next_greatest_element(arr))

						lowerCAmelCase					:    Optional[Any]           = (
						    'from __main__ import arr, next_greatest_element_slow, '
						    'next_greatest_element_fast, next_greatest_element'
						)
						print(
						    'next_greatest_element_slow():',
						    timeit('next_greatest_element_slow(arr)', setup=setup),
						)
						print(
						    'next_greatest_element_fast():',
						    timeit('next_greatest_element_fast(arr)', setup=setup),
						)
						print(
						    '     next_greatest_element():',
						    timeit('next_greatest_element(arr)', setup=setup),
						)




