Java Base -2
Intuition\nSimilier to the base 2 convertion but less human friendly, when add to carry, instead of add 1, I adding -1. But this will lead to an issue, if both 
# Intuition\nSimilier to the base 2 convertion but less human friendly, when add to carry, instead of add 1, I adding -1. But this will lead to an issue, if both arr1[i] and arr2[j] is 0 the result of arr1[i] + arr2[j] + carry could be -1, in such case we should borrow from higher bits, and set both carry and current val to 1\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\nInstead of grinding this kind of leetcode problem to get into some "elite" company, I should probably start my own company and torture someone else with this kind mind twisting problem, and when they give me an optimized answer, I keep torturing them with questions like "why you want to work here"(Yeah! I know the true answer is just salary, but I want to hear some fancy lies). \n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```\nclass Solution {\n    public int[] addNegabinary(int[] arr1, int[] arr2) {\n        List<Integer> list = new ArrayList<>();\n        int n = arr1.length;\n        int m = arr2.length;\n        int carry = 0;\n        int i = n - 1, j = m - 1;\n        while(i >= 0 && j >= 0) {\n            int val = arr1[i] + arr2[j] + carry; // calculate current value\n            int digit = 0;\n            if (val < 0) {\n// special case : when arr1[i] == 0 and arr2[j] == 0 and carry = -1, \n// borrow value from i - 2, set carry and digit both to 1\n// e.g considering [1] + [1] which will leads to result [-1, 0], which \n// means -( (-2)^1 ), to represent this value, we need borrow (-2)^2 from \n//higher bit, and set current bit to 1 which means(-2)^1, that\'s why set digit and carry to 1\n//                   [1]\n//                   [1]\n//                [-1,0] \n//               [1,1,0]. borrow from arr[i - 1] to represent arr[i] = -1\n                carry = 1;\n                digit = 1;\n            } \n            else {\n                carry = -(val / 2);\n                digit = val % 2;\n            }\n            list.add(0, digit);\n            --i;\n            --j;\n        }\n        while(i >= 0) {\n            int val = arr1[i] + carry;\n            int digit = 0;\n            if (val < 0) {\n                carry = 1;\n                digit = 1;\n            } \n            else {\n                carry = -(val / 2);\n                digit = val % 2;\n            }\n            list.add(0, digit);\n            --i;\n        }\n        while(j >= 0) {\n            int val = arr2[j] + carry;\n            int digit = 0;\n            if (val < 0) {\n                carry = 1;\n                digit = 1;\n            } \n            else {\n                carry = -(val / 2);\n                digit = val % 2;\n            }\n            list.add(0, digit);\n            --j;\n        }\n        if (carry != 0) {\n            if (carry == -1) {\n                list.add(0, 1);\n                list.add(0, 1);\n            }\n            else {\n                //carry == 1\n                list.add(0, carry);\n            }\n        }\n        // remove leading zeros\n        while(list.size() > 1 && list.get(0) == 0) {\n            list.remove(0);\n        }\n        int[] ans = new int[list.size()];\n        for (int k = 0; k < list.size(); ++k) {\n            ans[k] = list.get(k);\n        }\n        return ans;\n    }\n}\n```
['Java']