# Solution For Adding Two Negabinary Numbers

The problem “Adding Two Negabinary Numbers” on LeetCode is stated as follows:

Given two numbers arr1 and arr2 in negabinary representation, return the negabinary sum of the two numbers.

Negabinary is a base-2 system where the values of the digits can be -1, 0, or 1, instead of 0 or 1 in regular binary. For example, the negabinary representation of the number 3 is “11010”.

To solve this problem, we can follow the following steps:

1. Convert the two negabinary numbers to decimal. We can do this by iterating through each digit of the numbers, starting from the least significant digit, and multiplying the value of the digit (which can be -1, 0, or 1) by the corresponding power of 2 (which can be 2^n where n is the position of the digit, or -2^n if n is odd). We can then add the results to get the decimal equivalents of the two numbers.

2. Add the decimal equivalents of the two numbers obtained in step 1.

3. Convert the decimal sum obtained in step 2 to negabinary representation. To do this, we can use the “division by -2” algorithm, similar to the “division by 2” algorithm used for converting decimal to binary. We repeatedly divide the sum by -2 and keep track of the remainder at each step. If the remainder is negative, we add 2 to it and set the next dividend to be equal to the current dividend plus 1. We continue this process until the quotient is zero and we have obtained the negabinary representation of the sum.

Here is the Python implementation of the above algorithm:

“`
class Solution:
def addNegabinary(self, arr1: List[int], arr2: List[int]) -> List[int]:
# Convert the two negabinary numbers to decimal
num1 = sum(arr1[i] * (-2)i for i in range(len(arr1)))
num2 = sum(arr2[i] * (-2)
i for i in range(len(arr2)))

``````    # Add the decimal equivalents of the two numbers
decimal_sum = num1 + num2

# Convert the sum to negabinary representation
negabinary_sum = []
while decimal_sum != 0:
remainder = decimal_sum % -2
decimal_sum //= -2
if remainder < 0:
remainder += 2
decimal_sum += 1
negabinary_sum.append(remainder)

if not negabinary_sum:
return 
return negabinary_sum[::-1]
``````

“`

In the above implementation, we first convert the two negabinary numbers to decimal using list comprehension. We then add the decimal equivalents of the two numbers to get the decimal sum. Finally, we convert the decimal sum to negabinary representation using a while loop that implements the “division by -2” algorithm. The resulting negabinary sum is returned.

Note that we have to check if the negabinary sum is empty and return  in that case. This happens if both arr1 and arr2 are . We also reverse the negabinary sum using list slicing to get the correct order of digits.

## Step by Step Implementation For Adding Two Negabinary Numbers

```/**
* 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) {
// Initialize carry to 0
int carry = 0;
// Initialize head of the resultant list to null
// Initialize current node to head

// While both lists exist
while (l1 != null || l2 != null) {
// If one of the lists has ended, pad 0 to the other list
if (l1 == null) {
l1 = new ListNode(0);
}
if (l2 == null) {
l2 = new ListNode(0);
}

// Calculate sum of current digits and carry
int sum = l1.val + l2.val + carry;
// Calculate carry for next iteration
carry = (sum >= 2) ? -1 : 0;
// Get value of current digit
sum = (sum % 2 + 2) % 2;

// Create a new node with the sum as the data
ListNode newNode = new ListNode(sum);

// If this is the first node of the resultant list
// Set current node as head
} else {
// Else, connect it to the tail
curr.next = newNode;
// Set current node as the new node
curr = curr.next;
}

// Move to the next nodes of the input lists
l1 = l1.next;
l2 = l2.next;
}

// If carry is left over, add a new node with carry as the data
if (carry == -1) {
curr.next = new ListNode(-1);
}

// Return head of the resultant list
}
}```
```def addNegabinary(a, b):

# initialize result

result = 0

# initialize base value

base = 1

# traverse both arrays from right to left

i, j = len(a) - 1, len(b) - 1

while i >= 0 or j >= 0:

# find sum of current digits and carry

sum = 0

if i >= 0:
sum += a[i]
i -= 1

if j >= 0:
sum += b[j]
j -= 1

# if current digit sum is 1 or 3, add 1 to result

if sum == 1 or sum == 3:
result += base

# increment base by 2

base = base * 2

# return result

return result```
```/**
* @param {number[]} arr1
* @param {number[]} arr2
* @return {number[]}
*/
var addNegabinary = function(arr1, arr2) {

};```
```class Solution {
public:
vector addNegabinary(vector& arr1, vector& arr2) {
int i = arr1.size() - 1, j = arr2.size() - 1, carry = 0;
vector result;
while (i >= 0 || j >= 0 || carry) {
int sum = (i >= 0 ? arr1[i--] : 0) + (j >= 0 ? arr2[j--] : 0) + carry;
result.push_back(sum & 1);
carry = -(sum >> 1);
}
while (result.size() > 1 && result.back() == 0)
result.pop_back();
reverse(result.begin(), result.end());
return result;
}
};```
```public class Solution {
public int[] AddNegabinary(int[] arr1, int[] arr2) {