Sum of Two Integers

Signal

"Add without +" means simulating addition the way hardware does it: XOR gives you the sum of each bit position ignoring carries, AND-then-shift gives you exactly the carries, and you repeat until there's no carry left to add.

Approach

At the bit level, a ^ b is the sum of a and b with every carry dropped, and (a & b) << 1 is exactly those dropped carries, shifted into position. So: compute both, then treat the carry as a new number to add to the XOR-sum, and repeat until the carry is 0. In C or Java, fixed-width integers make this loop terminate naturally. Python integers don't wrap at 32 bits — they're arbitrary precision — so a negative carry-free sum can loop forever or come out with extra high bits set. The fix is to mask every intermediate value to 32 bits with & 0xFFFFFFFF, and at the very end, detect whether the 32-bit result "looks negative" (its top bit is set, i.e. it's greater than 0x7FFFFFFF) and convert it back into a genuine negative Python int via two's-complement inversion.

Skeleton

mask = 0xFFFFFFFF
while b & mask:
    carry = (a & b) << 1
    a = (a ^ b) & mask
    b = carry & mask
return a if a <= 0x7FFFFFFF else ~(a ^ mask)

Solution

def get_sum(a: int, b: int) -> int:
    mask = 0xFFFFFFFF
    while b & mask:
        carry = (a & b) << 1
        a = (a ^ b) & mask
        b = carry & mask
    return a if a <= 0x7FFFFFFF else ~(a ^ mask)

Complexity

O(1) time — at most 32 iterations, one per bit position. O(1) space.

Pitfalls

• This is the whole difficulty of the problem in Python: porting the bit-trick directly from C/Java without masking gives wrong answers or an infinite loop, because Python's int never overflows or wraps — b & mask is what makes the loop actually terminate, and the final a <= 0x7FFFFFFF check plus ~(a ^ mask) is what turns a 32-bit two's-complement bit pattern back into a real negative Python integer.
• Masking a but forgetting to mask b (the carry) leaves stray high bits that make the while b & mask loop condition wrong.
• Testing only positive inputs hides this entire class of bug — always trace through at least one negative operand by hand before trusting the solution.