Add Binary

Add Binary - Problem

Given two binary strings a and b, return their sum as a binary string.

A binary string contains only characters '0' and '1'. You need to perform binary addition following the same rules as decimal addition, but in base 2.

Binary Addition Rules:

0 + 0 = 0
0 + 1 = 1
1 + 0 = 1
1 + 1 = 10 (0 with carry 1)

Input & Output

Example 1 — Basic Addition

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

› Output: "100"

💡 Note: Binary addition: 11₂ + 1₂ = 100₂ (which is 3 + 1 = 4 in decimal)

Example 2 — Different Lengths

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

› Output: "10101"

💡 Note: Binary addition: 1010₂ + 1011₂ = 10101₂ (which is 10 + 11 = 21 in decimal)

Example 3 — Single Digit

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

› Output: "10"

💡 Note: Binary addition: 1₂ + 1₂ = 10₂ (which is 1 + 1 = 2 in decimal)

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

Visualization

Tap to expand

Asked in

f Facebook 15 G Google 12 a Amazon 8

The key insight is to simulate manual binary addition from right to left with carry propagation. The optimal approach uses bit-by-bit addition, handling different string lengths gracefully. Time: O(max(n,m)), Space: O(max(n,m))

Common Approaches

✓ Bit-by-Bit Addition with Carry

⏱️ Time: O(max(n,m)) Space: O(max(n,m))

Start from the rightmost bits of both strings and add them digit by digit, just like manual addition. Keep track of carry and propagate it to the next position.

Convert to Decimal

⏱️ Time: O(n) Space: O(1)

Parse each binary string as a decimal number using base conversion, perform regular addition, then convert the result back to binary string format.

Bit-by-Bit Addition with Carry — Algorithm Steps

Start from rightmost bits of both strings
Add current bits plus any carry from previous position
Record result bit (sum % 2) and new carry (sum / 2)
Move to next position left, continue until all bits processed

Visualization

Tap to expand

Step-by-Step Walkthrough

Align from Right

Start from rightmost bits of both strings

Add with Carry

Add current bits plus any carry from previous step

Build Result

Record result bit and propagate carry left

Code -

solution.c — C

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

char* solution(char* a, char* b) {
    int lenA = strlen(a);
    int lenB = strlen(b);
    int maxLen = lenA > lenB ? lenA : lenB;
    
    char* result = malloc((maxLen + 2) * sizeof(char)); // +1 for carry, +1 for null terminator
    int carry = 0;
    int i = lenA - 1, j = lenB - 1;
    int pos = 0;
    
    while (i >= 0 || j >= 0 || carry) {
        // Get current bits (0 if index out of bounds)
        int bitA = i >= 0 ? a[i] - '0' : 0;
        int bitB = j >= 0 ? b[j] - '0' : 0;
        
        // Calculate sum of current bits plus carry
        int total = bitA + bitB + carry;
        
        // Store result bit
        result[pos++] = '0' + (total % 2);
        carry = total / 2;
        
        // Move to next position
        i--;
        j--;
    }
    
    result[pos] = '\0';
    
    // Reverse the string
    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[10001], b[10001];
    fgets(a, sizeof(a), stdin);
    a[strcspn(a, "\n")] = 0;
    fgets(b, sizeof(b), stdin);
    b[strcspn(b, "\n")] = 0;
    
    char* result = solution(a, b);
    printf("%s\n", result);
    free(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(max(n,m))

Single pass through both strings, 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 for carry

⚡ Linearithmic Space

89.6K Views

Medium Frequency

~15 min Avg. Time

2.8K 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

Constraints

Visualization

Related Problems

Common Approaches

Bit-by-Bit Addition with Carry — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler