067. Add Binary

/*
 * @lc app=leetcode id=66 lang=java
 *
 * [66] Plus One
 *
 * https://leetcode.com/problems/plus-one/description/
 *
 * algorithms
 * Easy (40.46%)
 * Total Accepted:    337.9K
 * Total Submissions: 834.3K
 * Testcase Example:  '[1,2,3]'
 *
 * Given a non-empty array of digits representing a non-negative integer, plus
 * one to the integer.
 * 
 * The digits are stored such that the most significant digit is at the head of
 * the list, and each element in the array contain a single digit.
 * 
 * You may assume the integer does not contain any leading zero, except the
 * number 0 itself.
 * 
 * Example 1:
 * Input: [1,2,3]
 * Output: [1,2,4]
 * Explanation: The array represents the integer 123.
 * 
 * Example 2:
 * Input: [4,3,2,1]
 * Output: [4,3,2,2]
 * Explanation: The array represents the integer 4321.
 * 
 */
 
 // Java solution 01:
class Solution {
    public String addBinary(String a, String b) {
        StringBuilder sb = new StringBuilder();
        int i = a.length() - 1;
        int j = b.length() - 1;
        int carry = 0;
        
        while(i >= 0 || j >= 0) {
            if(i >= 0) {
                carry += a.charAt(i) - '0';
                i--;
            }
            if(j >= 0) {
                carry += b.charAt(j) - '0';
                j--;
            }
            
            sb.insert(0, carry % 2);
            carry = carry / 2;
        }
        
        if(carry > 0) {
            sb.insert(0, carry);
        }
        
        return sb.toString();
    }
}


// Java solution 02:
public class Solution {
    public String addBinary(String a, String b) {
        char arra[] = a.toCharArray();
        char arrb[] = b.toCharArray();
        int lena = a.length() - 1;
        int lenb = b.length() - 1;
        int lenre = Math.max(lena, lenb) + 1;
        int result[] = new int[lenre+1];
        int na, nb;
        int carry = 0;
        
        while(lena >= 0 || lenb >= 0){
            na = 0;
            nb = 0;
            if(lena >= 0){
                na = Integer.parseInt(String.valueOf(arra[lena]));
            }
            if(lenb >= 0){
                nb = Integer.parseInt(String.valueOf(arrb[lenb]));
            }
            result[Math.max(lena, lenb)+1] = (na + nb + carry) % 2;
            carry = (na + nb + carry) / 2;
            lena--;
            lenb--;
        }
        
        int index;
        if(carry > 0){
            result[0] = carry;
            index = 0;
        }
        else{index = 1;}
        
        StringBuilder string = new StringBuilder();
        for(; index < result.length; index++){
            string.append(result[index]);
        }
        
        return string.toString();
    }
}