why are we adding and subtracting '0' here?

Question

while solving a leetcode challange , I stumbled upon various solutions that were adding and subtracting '0' for successful submission and I have no idea why . any help? I mostly do linked list and array so this problem is quite new to me .

class Solution {
public:
string addBinary(string a, string b) {
    string result;
    int i=a.size()-1;
    int j=b.size()-1;
    int carry = 0;
    while(i>=0 || j>=0|| carry)
    {
        if(i>=0)
           { carry += a[i] - '0';//like here
            i--;}
         if(j>=0)
         { carry += a[j] - '0';//here 
          j--;
         }
        result += (carry%2 + '0'); //and here as well
        carry = carry/2;
    }
    reverse(result.begin(),result.end());
    return result;
}

};

Answer 1

In C++, '0' is a character literal.

The fundamental reason why/how a[i] - '0' works is through promotion. This is because:

arithmetic operators do not accept types smaller than int as arguments, and integral promotions are automatically applied after lvalue-to-rvalue conversion, if applicable

In particular when you wrote:

a[i]-'0'

This means

both a[i] and '0' will be promoted to an int. And so the result will be an int.

Let's looks at some example for more clarifications:

char c1 = 'E';
char c2 = 'F';

int result = c1 + c2;

Here both c1 and c2 will be promoted to an int. And the result will be an int. In particular, c1 will become(promoted to) 69 and c2 will become(promoted to) 70. And so result will be 69 + 70 which is the integer value 139.

This also makes the program more portable than using magic numbers.

Also note that the C++ Standard (2.3 Character sets) guarantees that:

---

3. ...In both the source and execution basic character sets, the value of each character after 0 in the above list of decimal digits shall be one greater than the value of the previous.

For example, say we have:

std::string str = "123";
int a = str[0] - '0'; //the result of str[0] - '0' is guaranteed to be the integer 1
int b = str[1] - '0'; //the result of str[1] - '0' is guaranteed to be the integer 2
int c = str[2] - '0'; //the result of str[2] - '0' is guaranteed to be the integer 3

Lets consider the statement int a = str[0] - '0';:

Here both str[0] and 0 will be promoted to int. And the final result that is used to initialize variable a on the left hand side will be the result of subtraction of those two promoted int values on the right hand side. Moreover, the result is guaranteed to be the integer 1.

Similarly, for statement int b = str[1] - '0';:

Here both str[1] and 0 will be promoted to int. And the final result that is used to initialize variable b on the left hand side will be the result of subtraction of those two promoted int values on the right hand side. Moreover, the result is guaranteed to be the integer 2.

And similarly for variable c.

Answer 2

It seems to be converting strings' characters to its numeric values. For instance, if you define "char c = '0';", you had indeed stored the ASCII code (or equivalent string encoding) of the char '0' in variable c, not the value zero itself. So to get the actual numeric value out of the ASCII code, you have to subtract by the ASCII code from the char '0'.

Remember that strings are a sequence of numeric values, i.e., integers representing characters, using the ASCII Table or equivalent, depending on the string encoding being used (Unicode, etc...).

Please note the actual characters' numeric values will depending on the actual encoding being used. The most known and basic Encoding is probably ASCII, which does not support languages other than the original english. For international purposes, the most common nowadays is UNICODE UTF-8, which uses basically the same codes used by ASCII for plain English usual characters, but other more complicated encodings exist.

And, as correctly noted by Anoop Rana in the other answer to this question, the C++ standard guarantees the numeric values will be in a sequence in any encoding. So, by using this technique, you avoid magic numbers that would make your code work just with specific encodings.

Here goes a didactic code that may help:

#include <iostream>
#include <string>

using namespace std;

int main()
{
    const string str = "5";
    cout << "char: " << str << endl;
    cout << "ASCII char's value: " << (int)str[0] << endl;
    cout << "ASCII char's value of the character '0' is: " << ((int)'0') << endl;
    cout << "Value represented by the ASCII code " << str[0] << 
        " is the binary value " << (int)str[0] << "-" << ((int)'0') <<
        "=" << (str[0] - '0') << endl;
    

    return 0;
}

The output is:

char: 5
ASCII char's value: 53
ASCII char's value of the character '0' is: 48
Value represented by the ASCII code 5 is the binary value 53-48=5

The ASCII table code can be consulted here: https://www.asciitable.com/

By the way, I think there may be a bug in your code, since parameter b is not being used. Maybe the second 'if' should be taking the value of b instead of a?