





'''simple docstring'''

import math

import qiskit







def 							UpperCAmelCase_    (	lowerCAmelCase_ = 1		,							lowerCAmelCase_ = 1		,							lowerCAmelCase_ = 1							):

    """simple docstring"""






    if (
        isinstance(lowerCAmelCase_		,							lowerCAmelCase_							)
        or isinstance(lowerCAmelCase_		,							lowerCAmelCase_							)
        or isinstance(lowerCAmelCase_		,							lowerCAmelCase_							)
    ):
        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(lowerCAmelCase_							) != input_a)
        or (math.floor(lowerCAmelCase_							) != input_a)
        or (math.floor(lowerCAmelCase_							) != 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
    lowercase         = qiskit.QuantumRegister(4		,							"qr"							)
    lowercase         = qiskit.ClassicalRegister(2		,							"cr"							)
    # list the entries
    lowercase         = [input_a, input_a, carry_in]

    lowercase         = qiskit.QuantumCircuit(lowerCAmelCase_		,							lowerCAmelCase_							)

    for i in range(0		,							3							):
        if entry[i] == 2:
            quantum_circuit.h(lowerCAmelCase_							)  # for hadamard entries
        elif entry[i] == 1:
            quantum_circuit.x(lowerCAmelCase_							)  # for 1 entries
        elif entry[i] == 0:
            quantum_circuit.i(lowerCAmelCase_							)  # 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]		,							lowerCAmelCase_							)  # measure the last two qbits

    lowercase         = qiskit.Aer.get_backend("aer_simulator"							)
    lowercase         = qiskit.execute(lowerCAmelCase_		,							lowerCAmelCase_		,							shots=1000							)

    return job.result().get_counts(lowerCAmelCase_							)


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











'''simple docstring'''

from __future__ import annotations

class       UpperCAmelCase :




		def __init__(self      :	Dict							,			A__      :	str							,			A__      :	str				)					-> str:
						lowercase   ,							lowercase         = text, pattern
						lowercase   ,							lowercase         = len(A__				), len(A__				)




		def 				UpperCAmelCase__   (self      :	Any							,			A__      :	str				)					-> int:

						for i in range(self.patLen - 1							,			-1							,			-1				):
										if char == self.pattern[i]:
														return i
						return -1




		def 				UpperCAmelCase__   (self      :	List[Any]							,			A__      :	int				)					-> int:

						for i in range(self.patLen - 1							,			-1							,			-1				):
										if self.pattern[i] != self.text[current_pos + i]:
														return current_pos + i
						return -1





		def 				UpperCAmelCase__   (self      :	Optional[Any]				)					-> list[int]:
						# searches pattern in text and returns index positions
						lowercase         = []
						for i in range(self.textLen - self.patLen + 1				):
										lowercase         = self.mismatch_in_text(A__				)
										if mismatch_index == -1:
														positions.append(A__				)
										else:
														lowercase         = self.match_in_pattern(self.text[mismatch_index]				)
														lowercase         = (
														    mismatch_index - match_index
														)  # shifting index lgtm [py/multiple-definition]
						return positions




__lowerCamelCase : List[str]											=			"ABAABA"
__lowerCamelCase : List[str]											=			"AB"
__lowerCamelCase : Union[str, Any]											=			BoyerMooreSearch(text, pattern)
__lowerCamelCase : List[str]											=			bms.bad_character_heuristic()

if len(positions) == 0:
			print("No match found")
else:
			print("Pattern found in following positions: ")
			print(positions)




