Add Binary

class Solution {
public:
    string addBinary(string a, string b) {
        string res;
        int carry = 0;
        int sum = 0;
        int i = a.size() - 1, j = b.size() - 1;
        int a_val = 0, b_val = 0;
        while (i >= 0 || j >= 0 || carry) {
            a_val = (i >= 0 ? a[i] - '0' : 0);
            b_val = (j >= 0 ? b[j] - '0' : 0);

            sum = a_val + b_val + carry;
            carry = sum / 2;
            sum %= 2;
            res.insert(0, 1, sum + '0');

            i = (i >= 0 ? -- i : i);
            j = (j >= 0 ? -- j : j);
        }
        return res;
    }
};

int i = a.length()-1;
int j = b.length()-1;
string res;
int sum;
int jinwei = 0;
while ((i>=0) || (j>=0))
{
    int per1 = (i>=0) ? (a.at(i) - '0') : 0;
    int per2 = (j>=0) ? (b.at(j) - '0') : 0;
    sum = per1 + + per2 + jinwei;
    if (sum == 0 || sum == 1)
    {
        res.append(1, sum+'0');
        jinwei = 0;
    }
    else if (sum == 2 || sum == 3)
    {
        res.append(1, (sum%2) + '0');
        jinwei = 1;
    }
    else if (sum == 4)
    {
        res.append(1, '0');
        jinwei = 2;
    }
    i--;
    j--;
}
if(jinwei == 1)
    res.append(1, '1');
else if (jinwei == 2)
    res += "01";
reverse(res.begin(), res.end());
return res;

private int cal_one_bit(int carry, int a_bit, int b_bit, StringBuilder stringBuilder) {
    int one_bit_sum = carry + a_bit + b_bit;
    if (one_bit_sum > 2) {
        carry = 1;
        stringBuilder.insert(0, '1');
    } else if (one_bit_sum == 2) {
        carry = 1;
        stringBuilder.insert(0, '0');
    } else if (one_bit_sum == 1) {
        carry = 0;
        stringBuilder.insert(0, '1');
    } else {
        carry = 0;
        stringBuilder.insert(0, '0');
    }

    return carry;
}

public String addBinary(String a, String b) {
    // find which one is longer, ensure a.length <= b.length
    if (a.length() > b.length()) {
        String tmp = a;
        a = b;
        b = tmp;
    }
    int carry = 0;
    int i = a.length() - 1, j = b.length() - 1;
    StringBuilder resultString = new StringBuilder();

    while (i >=0 && j >=0) {
        int a_one_bit = a.charAt(i) - '0';
        int b_one_bit = b.charAt(j) - '0';
        carry = cal_one_bit(carry, a_one_bit, b_one_bit, resultString);         
        i--;j--;
    }

    while (j >= 0) {
        int b_one_bit = b.charAt(j) - '0';
        carry = cal_one_bit(carry, 0, b_one_bit, resultString); 
        j--;
    }        
    if (carry == 1) {
        resultString.insert(0, '1');
    }

    return resultString.toString();

}

string addBinary(string a, string b) {
// Start typing your C/C++ solution below
// DO NOT write int main() function
string sum="";
int la=a.length()-1;
int lb=b.length()-1;
int c=0;
while (la >=0 || lb >= 0 ||c >0)        
{
    int v = c;
    if (la >=0) v+=a[la]-'0';
    if (lb >=0) v+=b[lb]-'0';

    c = v/2;
    sum = string(1,('0'+(v&1)))+sum;            
    la--;
    lb--;
}
return sum;

}

    if( a.empty() && b.empty())
        return "0"; 
    string result;
    int pos_a = a.size() - 1;
    int pos_b = b.size() - 1;
    int carry = 0;
    char tmp_a;   
    char tmp_b;   
    int left = 0;

    while( pos_a != -1 || pos_b != -1 )
    {             
        tmp_a = (pos_a == -1) ? '0': a.at(pos_a);
        tmp_b = (pos_b == -1) ? '0': b.at(pos_b);
        left = ((tmp_a - '0') + (tmp_b - '0') + carry )%2;
        carry = ((tmp_a - '0') + (tmp_b - '0') + carry )/2;
        result.insert(0,1,left + '0');
        if(pos_a != -1)
            pos_a--;  
        if(pos_b != -1)
            pos_b--;  
    } 
    if( carry == 1)
        result.insert(0,1,carry + '0');
    return result;

class Solution {
public:
    string addBinary(string a, string b) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        string s;
        int one = 0;
        for (int i = a.size() - 1, j = b.size() - 1; i >= 0 || j >= 0; --i, --j) {
            one += i < 0 ? 0 : a[i] - '0';
            one += j < 0 ? 0 : b[j] - '0';
            s = ((one & 1) ? "1" : "0") + s;
            one >>= 1;
        }
        return one ? "1" + s : s;
    }
};

string addBinary(string a, string b) {
    // Start typing your C/C++ solution below
    // DO NOT write int main() function
    string result = "";
    int intA = 0;
    int intB = 0;
    int upper = 0; 
    int temp = 0; 
    int big = 0;
    int lengthA = a.length();
    int lengthB = b.length();

    big = (lengthA>lengthB? lengthA: lengthB);

    for(int i = 0; i < big; i++){

        if (lengthA >0) {
            intA = a[lengthA-1] - '0';
        }
        else intA = 0;

        if(lengthB > 0){
            intB = b[lengthB-1] - '0';
        }
        else intB = 0; 
        temp = intA + intB + upper;
        result = (temp%2? "1": "0") + result;
        upper = temp / 2;
        lengthA--; lengthB--;

    }

    result = (upper? "1": "") + result;

    return result; 
}

Just wanted to play some C++ features.

class Solution {
public:
    string addBinary(string a, string b) {
        /* Avoid string concatenation */
        string ret(max(a.size(), b.size()), '\0');

        int carry = 0;
        auto pa = a.rbegin();
        auto pb = b.rbegin();

        /* Add from right to left */    
        for_each(ret.rbegin(), ret.rend(), [&] (char& ch) {
            carry += (pa == a.rend()) ? (0) : (*(pa++)-'0');
            carry += (pb == b.rend()) ? (0) : (*(pb++)-'0');
            ch = (carry & 1) + '0';
            carry >>= 1;
        });

        return (carry) ? ("1" + ret) : (ret);
    }
};

Java Solution O(max(m,n))

public static String addBinary(String a, String b) {
        // Start typing your Java solution below
        // DO NOT write main() function
        int lena=a.length();
        int lenb=b.length();
        int carry=0;

        char[] charA = a.toCharArray();
        char[] charB = b.toCharArray();
        int i=lena-1;
        int j=lenb-1;
        int curr;
        StringBuilder ss = new StringBuilder();
        Stack<Integer> temp = new Stack<Integer>();

        while(i>=0 && j>=0)
        {
            curr = (int)(charA[i--]-'0')+(int)(charB[j--]-'0')+carry;
            carry = curr/2; 
            curr= curr%2;
            temp.push(curr);
        }

        while(i>=0)
        {
            curr = (int)(charA[i--]-'0')+carry;
            carry = curr/2;
            curr = curr%2;
            temp.push(curr);
        }
        while(j>=0)
        {
            curr = (int)(charB[j--]-'0')+carry;
            carry = curr/2;
            curr = curr%2;
            temp.push(curr);
        }

        if(carry!=0)
        temp.push(carry);

        while(!temp.isEmpty())
        {
            ss.append(temp.pop());

        }

        return ss.toString();

    }

Based on previous answer, but not using Stack nor StringBuilder.

public static String addBinary(String a, String b) {
    int lena=a.length();
    int lenb=b.length();
    int carry=0;

    char[] charA = a.toCharArray();
    char[] charB = b.toCharArray();
    int i=lena-1;
    int j=lenb-1;
    int curr;
    int maxl = lena>lenb?lena+1:lenb+1;
    char[] res = new char[maxl];

    while(i>=0 && j>=0){
        curr = (int)(charA[i--]-'0')+(int)(charB[j--]-'0')+carry;
        carry = curr/2; 
        curr= curr%2;
        res[--maxl] = (char)(curr+'0');
    }

    while(i>=0){
        curr = (int)(charA[i--]-'0')+carry;
        carry = curr/2;
        curr = curr%2;
        res[--maxl] = (char)(curr+'0');
    }
    while(j>=0){
        curr = (int)(charB[j--]-'0')+carry;
        carry = curr/2;
        curr = curr%2;
        res[--maxl] = (char)(curr+'0');
    }

    if(carry!=0)
        res[--maxl] = (char)(carry+'0');

    return new String(res);
}