Vultr DocsLatest Content

Sum of Two Integers

Updated on 27 June, 2025
Sum of Two Integers header image

Problem Statement

In this task, you are required to compute the sum of two given integers ( a ) and ( b ). However, the challenge lies in the fact that you cannot use the traditional addition (+) and subtraction (-) operators directly to achieve the result. This condition necessitates the exploration of alternative computational techniques to perform the addition.

Examples

Example 1

Input:

a = 1, b = 2

Output:

3

Example 2

Input:

a = 2, b = 3

Output:

5

Constraints

  • -1000 <= a, b <= 1000

Approach and Intuition

The primary goal is to sum two integers without using the explicit addition or subtraction operators. Here's a logical approach using bitwise operations, a common method for such constraints.

  1. Bitwise XOR (^) Operation: This operation can be used to add two numbers without carrying any of the bits over. For two bits, XOR outputs 1 if the bits are different; this mirrors addition without carry.

  2. Bitwise AND (&) Operation: AND operation helps in determining which bits will carry over. It returns 1 only if both bits at the same position are 1. The result of this operation is then shifted left by one position to align the carry with the correct position for addition.

  3. Iteration until Carry is Zero: The process of XOR-ing the numbers and determining the carry (using AND) is repeated until there is no carry left. Typically, this involves:

    • Keeping track of the initial numbers as x and y, where x is the XOR result, and y is the shifted AND result. Initially, x = a and y = b.
    • Updating x to x ^ y (addition without carry) and y to (x & y) << 1 (calculate carry, shifted to correct position).
    • This loop continues until y becomes zero. At this point, x contains the final sum.

From the examples:

  • Example 1: For a = 1 and b = 2, bitwise sum without direct addition results in 3, as there's no overlap in bit positions.
  • Example 2: Following the bitwise logic with a = 2 and b = 3 also correctly gives 5 without using direct addition.

This approach functions correctly within the constraints (-1000 <= a, b <= 1000) and ensures that the summation is achieved purely through bitwise manipulation.

Solutions

  • C++
  • Java
  • Python
cpp 
class Solution {
public:
    int calculateSum(int x, int y) {
        long limit = 0xFFFFFFFF;
            
        while (y != 0) {
            int sum = (x ^ y) & limit;
            int carry = ((x & y) & limit) << 1;
            x = sum;
            y = carry;
        }
             
        return x < INT_MAX ? x : ~(x ^ limit);
    }
};

This C++ solution involves a function calculateSum that adds two integers without using the '+' operator. This approach utilizes bitwise operations: XOR for summing bits without carrying and AND for determining bit carry, which is then shifted left. The solution handles edge cases with proper sign representation by incorporating a 32-bit limit mask.

Here's how the function operates:

  1. Define a limit variable (mask) to control integer overflow, ensuring compatibility with 32-bit integer operations.

  2. Use a while loop to perform the addition as long as there is a carry-over (y != 0). Inside the loop:

    • Compute the 'sum' of x and y using XOR, applying the limit to handle overflow.

    • Determine the 'carry', which is bits carried over to the next higher bit, again applying the limit for overflow and then shifting left by one (<< 1) to align correctly for the next iteration of addition.

    • Update x with the 'sum' and y with the 'carry' for the next iteration.

  3. After exiting the loop (meaning no more carry bits), return x. If x exceeds the highest positive value representable in an integer, adjust it using bitwise operations to correct the sign.

This method effectively handles integer addition efficiently, providing a means to perform arithmetic operations at a lower level, simulating how processors might handle such tasks. The use of the limit ensures that the function works correctly across different compiler implementations that may handle integer sizes and overflows differently.

java 
class Solution {
    public int sum(int x, int y) {
        while (y != 0) {
            int temp = x ^ y;
            int carryOver = (x & y) << 1;
            x = temp;
            y = carryOver;
        }
            
        return x;
    }
}

This Java implementation calculates the sum of two integers without using arithmetic operators. It employs bitwise operators to achieve the addition. During each iteration of the while loop, two operations occur:

  • The main addition without carry is performed by XOR(^) between x and y.
  • The carry-over, which needs to be added in the subsequent iteration, is calculated using the AND(&) operation followed by a left shift(<<) by one position.

The process repeats, updating x with the new temporary sum and y with the new carry, until there's no carry left (y becomes 0). At that point, x contains the final sum, which is then returned.

This method effectively mimics the addition process in digital logic circuits, leveraging the properties of bitwise operations to simulate how hardware-based addition works at the bit level.

python 
class Solution:
    def sumTwo(self, x: int, y: int) -> int:
        full_mask = 0xFFFFFFFF
    
        while y != 0:
            x, y = (x ^ y) & full_mask, ((x & y) << 1) & full_mask
    
        max_positive = 0x7FFFFFFF
        return x if x < max_positive else ~(x ^ full_mask)

In this Python3 solution, the algorithm calculates the sum of two integers, x and y, without using the + or - operators, emulating the addition process using bitwise operations.

  • A full_mask value of 0xFFFFFFFF is used to handle the 32-bit integer overflow. Bitwise AND operation with this mask ensures that the value simulates a 32-bit signed integer.
  • The main loop continues until y becomes zero. Inside the loop:
    • The XOR operation x ^ y calculates the sum without carrying bits.
    • The AND operation followed by shifting left (x & y) << 1 calculates the carry bits.
    • Both results are combined using the tuple packing method to update x and y simultaneously, applying the full_mask to both to maintain the 32-bit constraint.
  • After exiting the loop, if the final result in x is less than 0x7FFFFFFF (the maximum positive value for a 32-bit signed integer), it directly returns x.
  • If x exceeds 0x7FFFFFFF, the function adjusts it by calculating ~(x ^ full_mask) to correct the interpretation of the number as a signed integer.

This method simulates the addition using logical bit operations, ensuring compatibility with systems where direct integer arithmetic may not be desired or applicable.

Comments