# Solution For Add Two Integers

Problem Statement:

Given two integers a and b, return the sum of them.

Constraints:

-1000 <= a, b <= 1000

Solution:

The problem is quite straightforward, we just need to add two integers. We can use the ‘+’ operator for this.

We can simply write a function that takes two integer parameters and returns their sum. The solution in Python is given below:

`def add_two_integers(a: int, b: int) -> int: return a + b`

We can also solve this problem using the bit-wise operator.

`def add_two_integers(a: int, b: int) -> int: while b != 0: carry = a & b a = a ^ b b = carry << 1 return a`

In the above solution, we are using the bit-wise operators ‘&’, ‘|’ and ‘<<‘. We are using a while loop to perform the addition.

First, we take the bitwise AND of ‘a’ and ‘b’ and assign it to ‘carry’. We then take the bitwise XOR of ‘a’ and ‘b’ and assign it to ‘a’. We shift ‘carry’ one position to the left and assign it to ‘b’.

We then repeat the above steps until ‘b’ becomes 0. Finally, we return the value of ‘a’.

The time complexity of this solution is O(1) and the space complexity is also O(1).

Test Cases:

Let’s test our solution with some test cases:

`assert add_two_integers(1, 2) == 3 assert add_two_integers(0, 0) == 0 assert add_two_integers(-1, 1) == 0`

Conclusion:

In this problem, we learned how to add two integers using both the ‘+’ operator and the bit-wise operators ‘&’, ‘|’ and ‘<<‘. The problem was quite straightforward and easy to solve.

## Step by Step Implementation For Add Two Integers

```/**
* public class ListNode {
*     int val;
*     ListNode next;
*     ListNode() {}
*     ListNode(int val) { this.val = val; }
*     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
* }
*/
class Solution {
public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
// create a dummy head node to simplify the code
// create a pointer to keep track of the current node
// create a carry variable to keep track of the carry
int carry = 0;

// while both lists are not null
while (l1 != null || l2 != null) {
// compute the sum of the current digits and the carry
int sum = carry;
if (l1 != null) {
sum += l1.val;
l1 = l1.next;
}
if (l2 != null) {
sum += l2.val;
l2 = l2.next;
}

// compute the carry
carry = sum / 10;
// create a new node with the sum % 10
curr.next = new ListNode(sum % 10);
curr = curr.next;
}

// if there is a carry left over, create a new node with the carry
if (carry > 0) {
curr.next = new ListNode(carry);
}

// return the dummy head's next node, which is the head of the sum list
}
}```
```def add_two_integers(a, b):
"""
:type a: int
:type b: int
:rtype: int
"""
return a + b```
```var addTwoIntegers = function(a, b) {
// Check if both inputs are valid integers
if (!Number.isInteger(a) || !Number.isInteger(b)) {
return null;
}
// Initialize result
let result = 0;
// Add each digit of the two integers starting from the ones digit
for (let i = 0; i < Math.max(a.toString().length, b.toString().length); i++) {
// Get the digit in the ones place for each integer
const aDigit = a.toString()[a.toString().length - 1 - i] || 0;
const bDigit = b.toString()[b.toString().length - 1 - i] || 0;
// Add the digits and carry over any remainders
result += (parseInt(aDigit) + parseInt(bDigit)) % 10;
// If there is a remainder, carry it over to the next digit
if (parseInt(aDigit) + parseInt(bDigit) >= 10) {
result += 1;
}
// Move to the next digit place
result *= 10;
}
// Return the result divided by 10 to remove the extra digit place
return result / 10;
};```
```class Solution {
public:
int addTwoIntegers(int a, int b) {
// Initialize result
int result = 0;

// Determine how to iterate over bits
int i = 0;
for (int i = 0; i < 32; i++) {
// Get bit values
int bit_a = (a >> i) & 1;
int bit_b = (b >> i) & 1;

// Toggle the bit in result if both input bits are 1
if (bit_a == 1 && bit_b == 1) {
result ^= (1 << i);
}
// Else, add the bit from a or b to result (bitwise OR)
else {
result |= (bit_a | bit_b) << i;
}
}

return result;
}
};```
```public class Solution {
public int AddTwoIntegers(int a, int b) {
// return sum of a and b
return a + b;
}
}```

Scroll to Top
[gravityforms id="5" description="false" titla="false" ajax="true"]