Python program to add two binary numbers

Last Updated : 11 May, 2023

Given two binary numbers, write a Python program to compute their sum.

Examples:

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

Input: a = "1101", b = "100"
Output: 10001```

Approach:

• Naive Approach: The idea is to start from the last characters of two strings and compute digit sum one by one. If the sum becomes more than 1, then store carry for the next digits.
• Using inbuilt function: Calculate the result by using the inbuilt bin() and int() function.

Method 1: Naive Approach:

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

Python3

 `# Python program to add two binary numbers.`   `# Driver code` `# Declaring the variables` `a ``=` `"1101"` `b ``=` `"100"` `max_len ``=` `max``(``len``(a), ``len``(b))` `a ``=` `a.zfill(max_len)` `b ``=` `b.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` `a[i] ``=``=` `'1'` `else` `0` `    ``r ``+``=` `1` `if` `b[i] ``=``=` `'1'` `else` `0` `    ``result ``=` `(``'1'` `if` `r ``%` `2` `=``=` `1` `else` `'0'``) ``+` `result`   `    ``# Compute the carry.` `    ``carry ``=` `0` `if` `r < ``2` `else` `1`   `if` `carry !``=` `0``:` `    ``result ``=` `'1'` `+` `result`   `print``(result.zfill(max_len))`

Output

`10001`

Time complexity : O(n)
Space Complexity : O(n)

Method 2: Using inbuilt functions:

We will first convert the binary string to a decimal using int() function in python. The int() function in Python and Python3 converts a number in the given base to decimal. Then we will add it and then again convert it into a binary number using bin() function.

Example 1:

Python3

 `# Python program to add two binary numbers.`   `# Driver code` `# Declaring the variables` `a ``=` `"1101"` `b ``=` `"100"`   `# Calculating binary value using function` `sum` `=` `bin``(``int``(a, ``2``) ``+` `int``(b, ``2``))`   `# Printing result` `print``(``sum``[``2``:])`

Output

`10001`

Time Complexity: O(n)
Auxiliary Space: O(n)

Example 2:

Python3

 `# Python program to add two binary numbers.`   `# Driver code` `if` `__name__ ``=``=` `"__main__"` `:`   `    ``# Declaring the variables` `    ``a ``=` `"1101"` `    ``b ``=` `"100"` `    `  `    ``# Calculating binary sum by using bin() and int()` `    ``binary_sum ``=` `lambda` `a,b : ``bin``(``int``(a, ``2``) ``+` `int``(b, ``2``))` `    `  `    ``# calling binary_sum lambda function` `    ``print``(binary_sum(a,b)[``2``:])` `    `  `    ``# This code is contributed by AnkThon`

Output

`10001`

Time complexity :  O(1)
Space Complexity : O(1)

Python3

 `from` `operator ``import``*` `num1``=``"1101"` `num2``=``"100"` `print``(``bin``(add(``int``(num1,``2``),``int``(num2,``2``))))`

Output

`0b10001`

Time complexity :  O(n)
Space Complexity : O(1)

METHOD 3:Using loop

APPROACH:

The given Python code takes two binary numbers as strings, ‘a’ and ‘b’, and returns their sum as a binary string ‘result’. The addition of two binary numbers is performed using the standard column-wise addition algorithm, in which digits are added from right to left with carrying over the digits when the sum exceeds 1. The algorithm continues until all digits of both numbers are added.

ALGORITHM:

1. Initialize an empty string ‘result’ and a carry variable to 0.
2. Set the index of the last digit of ‘a’ and ‘b’ strings to ‘i’ and ‘j’, respectively.
3. Repeat the following while loop until ‘i’ or ‘j’ is less than 0 or there is a carry:
a. Initialize the ‘total’ variable to ‘carry’
b. If ‘i’ is greater than or equal to 0, add the ‘i’-th digit of ‘a’ to ‘total’ and decrement ‘i’.
c. If ‘j’ is greater than or equal to 0, add the ‘j’-th digit of ‘b’ to ‘total’ and decrement ‘j’.
d. Calculate the value of the current digit in the result as ‘total % 2’ and add it to the left of ‘result’.
e. Update the value of the carry as ‘total // 2’.
4. If there is still a carry after the while loop, add it to the left of ‘result’.
5. Return the ‘result’ string.

Python3

 `a ``=` `"1101"` `b ``=` `"100"` `result ``=` `""` `carry ``=` `0` `i, j ``=` `len``(a)``-``1``, ``len``(b)``-``1` `while` `i >``=` `0` `or` `j >``=` `0` `or` `carry:` `    ``total ``=` `carry` `    ``if` `i >``=` `0``:` `        ``total ``+``=` `int``(a[i])` `        ``i ``-``=` `1` `    ``if` `j >``=` `0``:` `        ``total ``+``=` `int``(b[j])` `        ``j ``-``=` `1` `    ``result ``=` `str``(total ``%` `2``) ``+` `result` `    ``carry ``=` `total ``/``/` `2` `print``(result)`

Output

`10001`

Time Complexity:
The algorithm iterates over each digit of both numbers once, so the time complexity of the algorithm is O(n), where ‘n’ is the maximum length of the input strings.

Space Complexity:
The algorithm uses only a constant amount of extra space to store variables like ‘result’, ‘carry’, ‘i’, and ‘j’, so the space complexity of the algorithm is O(1).

Previous
Next