Interview: Adding two binary numbers given as strings [closed] - c++

Question

As it currently stands, this question is not a good fit for our Q&A format. We expect answers to be supported by facts, references, or expertise, but this question will likely solicit debate, arguments, polling, or extended discussion. If you feel that this question can be improved and possibly reopened, visit the help center for guidance.
Closed 9 years ago.
While looking through some interview questions at http://www.glassdoor.com/Interview/Facebook-Interview-Questions-E40772.htm I came across the following question:
Given two string representations of binary numbers (e.g. "1001", "10") write a function that adds them and returns the result as a string as well (e.g. "1011").
Here's some Python code that I started to write for the problem (it is incomplete right now), but I am not very sure if this is the best (or even correct) approach. I also thought about implementing the same in C++ first, but gave up considering the added complexities in string manipulations.
def add_binary(a,b):
temp = ""
carry = false
//i from len(a) to 1 and j from len(b) to 1
bit_sum = add_bit ((a[i],b[j])
if (bit_sum == "10"):
temp.append("0")
carry = true
elif carry:
temp.append(add_bit("1",bit_sum))
else:
temp.append(bit_sum)
return temp.reverse()
def add_bit(b1, b2):
if b1 == '0':
return b2
elif b2 == '0':
return b1
elif (b1 = '1' and b2 =='1'):
return "10"
else return None
a = "1001"
b = "10"
add_binary(a,b)

Answer 1

First, if the strings are short enough (less than 64 bits), I'd
probably just convert them to an internal integral type
(unsigned long long), do the addition there, and then
reconvert the results. Converting between binary strings and
internal format is really, really trivial.
Otherwise, I'd probably first normallize them so that they have
the maximum length of the results. Something like:
size_t size = std::max( lhs.size(), rhs.size() ) + 1;
lhs.insert( lhs.begin(), size - lhs.size(), '0' );
rhs.insert( rhs.begin(), size - rhs.size(), '0' );
I'd also create a results string of this size:
std::string results( size, '0' );
And a carry variable, initialized to '0':
char carry = '0';
I'd then loop over the three strings, using reverse iterators,
or more likely, just an index (which will ensure accessing the
same element of each string):
size_t current = size;
while ( current != 0 ) {
-- current;
// ...
}
With in the loop, you really only have four possibilities: I'd
just count the '1's (in lhs[current], rhs[current] and
carry), and do a switch on the results, setting
results[current] and carry appropriately:
int onesCount = 0;
if ( carry == '1' ) {
++ onesCount;
}
if ( lhs[current] == '1' ) {
++ onesCount;
}
if ( rhs[current] == '1' ) {
++ onesCount;
}
swith ( onesCount ) {
case 0:
carry = '0';
results[current] = '0';
break;
case 1:
carry = '0';
results[current] = '1';
break;
case 2:
carry = '1';
results[current] = '0';
break;
case 3:
carry = '1';
results[current] = '1';
break;
}
Personally, I think this is the simplest and the cleanest
solution, albeit a bit verbose. Alternatively, you can replace
the switch with something like:
results[current] = onesCount % 2 == 0 ? '0' : '1';
carry = onesCount < 2 ? '0' : '1';
Finally, if desired, you can suppress any leading zeros in the
results (there will be at most one), and maybe assert that
carry == '0' (because if it isn't, we've screwed up our
calculation of the size).

Answer 2

The most difficult part here is the fact that we need to process the strings from right to left. We can do this by either:
Reversing the strings (input and output).
In a recursive call, process the bits when "going back", i.e. first call a recursive add on the "next bits", then add the "current bit".
Use reverse iterators and construct the result from right to left. A problem will still be how to know the resulting length in advance (so you know where to start).
The recursive solution has problems when the numbers are large, i.e. the stack might overflow.
Reversing the strings is the easiest solution, yet not the most efficient one.
A combination of the first and third option would be to process the input strings in reverse using reverse iterators, but construct the result in reverse order (so you can simply append bits), then reverse the result.
This is more or less also your approach. Implement the loop counting i and j from the string length minus 1 (!) until 0, so this will walk through the input strings in reverse order. If carry was set to true, add one to the bit sum in the next iteration. Represent the bit sum of add_bit as an integer, not as a string again, so you can add the carry.
In C++, you have the possibility to iterate through any sequence in reverse order using rbegin() and rend().

Answer 3

in Python you can convert strings to integers with int, which also allows a base for conversion:
num = '111'
print int(num, 2)
prints 7.
For converting the result back to binary:
print "{:b}".format(4)
prints 100