Add Binary - Practice Coding Problems

Add Binary - Problem

Binary Addition Made Simple!

Given two binary strings a and b, your task is to return their sum as a binary string. This is essentially performing addition in base-2 (binary) instead of our usual base-10 (decimal) system.

What you need to know:
• Binary uses only digits 0 and 1
• Addition rules: 0+0=0, 0+1=1, 1+0=1, 1+1=10 (carry the 1)
• Work from right to left, just like decimal addition

Example: "1010" + "1011" = "10101"

This problem tests your understanding of string manipulation, carry arithmetic, and binary number systems.

Input & Output

example_1.py — Basic Addition

$ Input: a = "11", b = "1"

› Output: "100"

💡 Note: 11 + 1 = 100 in binary (equivalent to 3 + 1 = 4 in decimal)

example_2.py — Equal Length Strings

$ Input: a = "1010", b = "1011"

› Output: "10101"

💡 Note: 1010 + 1011 = 10101 in binary (equivalent to 10 + 11 = 21 in decimal)

example_3.py — Single Digits

$ Input: a = "1", b = "1"

› Output: "10"

💡 Note: 1 + 1 = 10 in binary (equivalent to 1 + 1 = 2 in decimal) - demonstrates carry

Visualization

Tap to expand

Understanding the Visualization

Start from Right

Begin with the rightmost digits of both strings

Add with Carry

Add current digits plus any carry from previous step

Handle Overflow

If sum ≥ 2, write (sum%2) and carry (sum/2)

Move Left

Continue until all digits processed and no carry remains

Key Takeaway

🎯 Key Insight: Binary addition works exactly like decimal addition - process digits right to left with carry, but using only 0s and 1s!

Time & Space Complexity

Time Complexity

⏱️

O(max(n, m))

We process each digit exactly once, where n and m are lengths of input strings

✓ Linear Growth

Space Complexity

O(max(n, m))

Result string length is at most max(n, m) + 1

⚡ Linearithmic Space

Constraints

1 ≤ a.length, b.length ≤ 10⁴
a and b consist only of '0' or '1' characters
Each string does not contain leading zeros except for the zero itself
Follow up: How would you handle this if you cannot use built-in big integer libraries?

Asked in

f Meta 35 a Amazon 28 G Google 22 ⊞ Microsoft 18

The optimal approach uses digit-by-digit simulation mimicking elementary school addition. Process digits from right to left, maintaining a carry bit for overflow. Time complexity is O(max(n,m)) and works for arbitrarily large numbers without integer overflow concerns.

Common Approaches

Approach	Time	Space	Notes
✓ Digit-by-Digit Simulation (Optimal)	O(max(n, m))	O(max(n, m))	Simulate binary addition digit by digit from right to left with carry

Digit-by-Digit Simulation (Optimal) — Algorithm Steps

Initialize pointers at the end of both strings and carry = 0
While there are digits to process or carry exists
Get current digits (0 if pointer is out of bounds)
Calculate sum = digit1 + digit2 + carry
Append (sum % 2) to result and update carry = sum / 2
Move pointers leftward and repeat
Reverse the result string and return

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set pointers at the end of both strings, carry = 0

Add Digits

Add current digits plus carry: sum = a[i] + b[j] + carry

Store Result

Result digit = sum % 2, new carry = sum / 2

Continue

Move to next position until all digits processed

Code -

solution.c — C

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

char* addBinary(char* a, char* b) {
    int lenA = strlen(a);
    int lenB = strlen(b);
    int maxLen = (lenA > lenB ? lenA : lenB) + 2;
    char* result = malloc(maxLen);
    
    int carry = 0;
    int i = lenA - 1, j = lenB - 1;
    int pos = 0;
    
    // Process digits from right to left
    while (i >= 0 || j >= 0 || carry > 0) {
        int digitSum = carry;
        
        if (i >= 0) {
            digitSum += a[i] - '0';
            i--;
        }
        
        if (j >= 0) {
            digitSum += b[j] - '0';
            j--;
        }
        
        // Store current digit and update carry
        result[pos++] = '0' + (digitSum % 2);
        carry = digitSum / 2;
    }
    
    result[pos] = '\0';
    
    // Reverse the result
    for (int k = 0; k < pos / 2; k++) {
        char temp = result[k];
        result[k] = result[pos - 1 - k];
        result[pos - 1 - k] = temp;
    }
    
    return result;
}

int main() {
    char a[1000], b[1000];
    scanf("%s %s", a, b);
    printf("%s\n", addBinary(a, b));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(max(n, m))

We process each digit exactly once, where n and m are lengths of input strings

✓ Linear Growth

Space Complexity

O(max(n, m))

Result string length is at most max(n, m) + 1

⚡ Linearithmic Space

Constraints

1 ≤ a.length, b.length ≤ 10⁴
a and b consist only of '0' or '1' characters
Each string does not contain leading zeros except for the zero itself
Follow up: How would you handle this if you cannot use built-in big integer libraries?

38.2K Views

High Frequency

~18 min Avg. Time

1.9K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Digit-by-Digit Simulation (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler