AlgoExplained.dev

def addBinary(a: str, b: str) -> str:
Initializes the function `addBinary` which takes two binary strings `a` and `b` and returns their sum as a binary string.
    i, j = len(a) - 1, len(b) - 1
Sets pointers `i` and `j` to the last indices of strings `a` and `b` respectively (rightmost characters).
    carry = 0
Initializes `carry` to 0. This will store the overflow when adding two 1s (1 + 1 = 0 with carry 1).
    result = []
Creates an empty list to store result digits. Using a list is more efficient than string concatenation.
    while i >= 0 or j >= 0 or carry:
Continues while there are digits left in either string OR there's a carry remaining.
        total = carry
Starts the sum with the carry from the previous iteration.
        if i >= 0:
Checks if there are still digits left in string `a`.
            total += int(a[i])
Adds the current digit of `a` to the total (converts char '0' or '1' to int 0 or 1).
            i -= 1
Moves the pointer for `a` one position to the left.
        if j >= 0:
Checks if there are still digits left in string `b`.
            total += int(b[j])
Adds the current digit of `b` to the total.
            j -= 1
Moves the pointer for `b` one position to the left.
        result.append(str(total % 2))
Appends the current bit (total % 2) to result. This gives 0 for even totals, 1 for odd.
        carry = total // 2
Updates carry: 1 if total >= 2, else 0. This is integer division.
    return ''.join(reversed(result))
Reverses the result (we built it backwards) and joins into a string.

public String addBinary(String a, String b) {
Initializes the function `addBinary` which takes two binary strings and returns their sum.
    StringBuilder result = new StringBuilder();
Creates a StringBuilder for efficient string building.
    int i = a.length() - 1, j = b.length() - 1;
Sets pointers to the last indices of both strings.
    int carry = 0;
Initializes carry to 0.
    while (i >= 0 || j >= 0 || carry > 0) {
Continues while digits remain in either string OR there's a carry.
        int total = carry;
Starts the sum with the carry from previous iteration.
        if (i >= 0) total += a.charAt(i--) - '0';
Adds digit from `a` and decrements index. The `- '0'` converts char to int value.
        if (j >= 0) total += b.charAt(j--) - '0';
Adds digit from `b` and decrements index.
        result.append(total % 2);
Appends the current bit (0 or 1) to the result.
        carry = total / 2;
Updates carry: 1 if total >= 2, else 0.
    }
End of while loop.
    return result.reverse().toString();
Reverses the result (built backwards) and converts to string.
}
End of the function.

string addBinary(string a, string b) {
Initializes the function `addBinary` which takes two binary strings and returns their sum.
    string result = "";
Creates an empty string to store the result.
    int i = a.size() - 1, j = b.size() - 1;
Sets pointers to the last indices of both strings.
    int carry = 0;
Initializes carry to 0.
    while (i >= 0 || j >= 0 || carry) {
Continues while digits remain in either string OR there's a carry.
        int total = carry;
Starts the sum with the carry from previous iteration.
        if (i >= 0) total += a[i--] - '0';
Adds digit from `a` and decrements index. The `- '0'` converts char to int value.
        if (j >= 0) total += b[j--] - '0';
Adds digit from `b` and decrements index.
        result += to_string(total % 2);
Appends the current bit (0 or 1) to the result.
        carry = total / 2;
Updates carry: 1 if total >= 2, else 0.
    }
End of while loop.
    reverse(result.begin(), result.end());
Reverses the result string in-place (we built it backwards).
    return result;
Returns the final binary sum string.
}
End of the function.