# Program to add two binary strings

Given two binary strings, return their sum (also a binary string).

Example:

```Input:  a = "11", b = "1"
Output: "100" ```

We strongly recommend you to minimize your browser and try this yourself first

The idea is to start from the last characters of two strings and compute the digit sum one by one. If the sum becomes more than 1, then store carry for the next digits.

## C++

 `// C++ program to add two binary strings` `#include ` `using` `namespace` `std;`   `// This function adds two binary strings and return` `// result as a third string` `string addBinary(string A, string B)` `{` `    ``// If the length of string A is greater than the length` `    ``// of B then just swap the string by calling the` `    ``// same function and make sure to return the function` `    ``// otherwise recursion will occur which leads to` `    ``// calling the same function twice` `    ``if` `(A.length() > B.length())` `        ``return` `addBinary(B, A);`   `    ``// Calculating the difference between the length of the` `    ``// two strings.` `    ``int` `diff = B.length() - A.length();`   `    ``// Initialise the padding string which is used to store` `    ``// zeroes that should be added as prefix to the string` `    ``// which has length smaller than the other string.` `    ``string padding;` `    ``for` `(``int` `i = 0; i < diff; i++)` `        ``padding.push_back(``'0'``);`   `    ``A = padding + A;` `    ``string res;` `    ``char` `carry = ``'0'``;`   `    ``for` `(``int` `i = A.length() - 1; i >= 0; i--) {` `        ``// This if condition solves 110 111 possible cases` `        ``if` `(A[i] == ``'1'` `&& B[i] == ``'1'``) {` `            ``if` `(carry == ``'1'``)` `                ``res.push_back(``'1'``), carry = ``'1'``;` `            ``else` `                ``res.push_back(``'0'``), carry = ``'1'``;` `        ``}` `        ``// This if condition solves 000 001 possible cases` `        ``else` `if` `(A[i] == ``'0'` `&& B[i] == ``'0'``) {` `            ``if` `(carry == ``'1'``)` `                ``res.push_back(``'1'``), carry = ``'0'``;` `            ``else` `                ``res.push_back(``'0'``), carry = ``'0'``;` `        ``}` `        ``// This if condition solves 100 101 010 011 possible` `        ``// cases` `        ``else` `if` `(A[i] != B[i]) {` `            ``if` `(carry == ``'1'``)` `                ``res.push_back(``'0'``), carry = ``'1'``;` `            ``else` `                ``res.push_back(``'1'``), carry = ``'0'``;` `        ``}` `    ``}`   `    ``// If at the end there is carry then just add it to the` `    ``// result` `    ``if` `(carry == ``'1'``)` `        ``res.push_back(carry);` `    ``// reverse the result` `    ``reverse(res.begin(), res.end());`   `    ``// To remove leading zeroes` `    ``int` `index = 0;` `    ``while` `(index + 1 < res.length() && res[index] == ``'0'``)` `        ``index++;` `    ``return` `(res.substr(index));` `}`   `// Driver program` `int` `main()` `{` `    ``string a = ``"1101"``, b = ``"100"``;` `    ``cout << addBinary(a, b) << endl;` `    ``return` `0;` `}`

## Java

 `// java program to add` `// two binary strings`   `public` `class` `GFG {`   `    ``// This function adds two` `    ``// binary strings and return` `    ``// result as a third string` `    ``static` `String addBinary(String A, String B)` `    ``{   ` `        ``// initialize the ith index` `        ``int` `i = A.length()-``1``;` `        ``// initialize the jth index` `        ``int` `j = B.length()-``1``;` `        ``// initialize the carry ` `        ``int` `carry = ``0``;` `      ``// initialize the sum` `        ``int` `sum = ``0``;` `        ``StringBuilder result =  ``new` `StringBuilder();` `        ``while``(i>=``0` `|| j>=``0` `|| carry == ``1``){` `            ``sum = carry;` `            ``if``(i>=``0``) sum = sum+A.charAt(i)-``'0'``;` `            ``if``(j>=``0``) sum = sum+B.charAt(j)-``'0'``;` `            ``result.append((``char``)(sum%``2``+``'0'``));` `            ``carry = sum/``2``;` `            ``i--;` `            ``j--;` `        ``}` `        ``return` `result.reverse().toString();` `    ``}`   `    ``//Driver code` `    ``public` `static` `void` `main(String args[])` `    ``{` `        ``String a = ``"1101"``, b=``"100"``;` `        `  `        ``System.out.print(addBinary(a, b));` `    ``}` `}`   `// This code is contributed by Sam007.` `// A bit improvement by Mustak Ahmed`

## Python3

 `# Python Solution for above problem:`   `# This function adds two binary ` `# strings return the resulting string` `def` `add_binary_nums(x, y):` `        ``max_len ``=` `max``(``len``(x), ``len``(y))`   `        ``x ``=` `x.zfill(max_len)` `        ``y ``=` `y.zfill(max_len)` `        `  `        ``# initialize the result` `        ``result ``=` `''` `        `  `        ``# initialize the carry` `        ``carry ``=` `0`   `        ``# Traverse the string` `        ``for` `i ``in` `range``(max_len ``-` `1``, ``-``1``, ``-``1``):` `            ``r ``=` `carry` `            ``r ``+``=` `1` `if` `x[i] ``=``=` `'1'` `else` `0` `            ``r ``+``=` `1` `if` `y[i] ``=``=` `'1'` `else` `0` `            ``result ``=` `(``'1'` `if` `r ``%` `2` `=``=` `1` `else` `'0'``) ``+` `result` `            ``carry ``=` `0` `if` `r < ``2` `else` `1`     `# Compute the carry.` `        `  `        ``if` `carry !``=``0` `: result ``=` `'1'` `+` `result`   `        ``return` `result.zfill(max_len)`   `# Driver code ` `print``(add_binary_nums(``'1101'``, ``'100'``))`   `# This code is contributed ` `# by Anand Khatri`

## C#

 `// C# program to add ` `// two binary strings` `using` `System;`   `class` `GFG {` `    `  `    ``// This function adds two ` `    ``// binary strings and return` `    ``// result as a third string` `    ``static` `string` `addBinary(``string` `a, ` `                            ``string` `b)` `    ``{` `        `  `        ``// Initialize result` `        ``string` `result = ``""``; ` `        `  `        ``// Initialize digit sum` `        ``int` `s = 0;         `   `        ``// Traverse both strings starting ` `        ``// from last characters` `        ``int` `i = a.Length - 1, j = b.Length - 1;` `        ``while` `(i >= 0 || j >= 0 || s == 1)` `        ``{` `            `  `            ``// Comput sum of last ` `            ``// digits and carry` `            ``s += ((i >= 0)? a[i] - ``'0'``: 0);` `            ``s += ((j >= 0)? b[j] - ``'0'``: 0);`   `            ``// If current digit sum is ` `            ``// 1 or 3, add 1 to result` `            ``result = (``char``)(s % 2 + ``'0'``) + result;`   `            ``// Compute carry` `            ``s /= 2;`   `            ``// Move to next digits` `            ``i--; j--;` `        ``}` `    ``return` `result;` `    ``}` `    `  `// Driver Code    ` `public` `static` `void` `Main()` `{` `    ``string` `a = ``"1101"``, b=``"100"``;` `    ``Console.Write( addBinary(a, b));` `}` `}`   `// This code is contributed by Sam007`

## PHP

 `= 0 || ``\$j` `>= 0 || ``\$s` `== 1)` `    ``{` `        ``// Comput sum of last digits and carry` `        ``\$s` `+= ((``\$i` `>= 0)? ord(``\$a``[``\$i``]) - ` `                          ``ord(``'0'``): 0);` `        ``\$s` `+= ((``\$j` `>= 0)? ord(``\$b``[``\$j``]) - ` `                          ``ord(``'0'``): 0);`   `        ``// If current digit sum is 1 or 3, ` `        ``// add 1 to result` `        ``\$result` `= ``chr``(``\$s` `% 2 + ord(``'0'``)) . ``\$result``;`   `        ``// Compute carry` `        ``\$s` `= (int)(``\$s` `/ 2);`   `        ``// Move to next digits` `        ``\$i``--; ``\$j``--;` `    ``}` `    ``return` `\$result``;` `}`   `// Driver Code` `\$a` `= ``"1101"``;` `\$b` `= ``"100"``;` `echo` `addBinary(``\$a``, ``\$b``);`   `// This code is contributed by mits` `?>`

## Javascript

 ``

Output

```10001
```

Time Complexity: O(max(L1, L2)), where L1 and L2 are the lengths of strings a and b respectively.
Auxiliary Space: O(max(L1, L2)), where L1 and L2 are the lengths of strings a and b respectively.

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!