Add Binary Strings

Last Updated : 17 Oct, 2026

Given two binary strings s1 and s2 consisting of only 0s and 1s. Find the resultant string after adding the two Binary Strings.
Note: The input strings may contain leading zeros but the output string should not have any leading zeros.

Example:

Input: s1 = "1101", s2 = "111"
Output: "10100"
Explanation:
Input: s1 = "00100", s2 = "010"
Output: "110"

Try It Yourself

Bit-by-bit addition with carry - O(n + m) Time and O(1) Space

The idea is to follow simple math addition process from right to left.
Trim the leading zeros in the input strings.
Start from the last characters of the strings and compute the digit sum one by one.
If the sum becomes more than 1, then store carry for the next digits. Also consider this carry while calculating the digit sum.
After calculating the sum, if an additional carry is generated, prepend a '1' of the result.

C++

#include <iostream>
using namespace std;

// Function to trim leading zeros from a binary string
string trimLeadingZeros(const string &s) {
    
    // Find the position of the first '1'
    size_t firstOne = s.find('1');
    return (firstOne == string::npos) ? "0" : s.substr(firstOne);
}

string addBinary(string &s1, string &s2) {
  
    // Trim leading zeros
    s1 = trimLeadingZeros(s1);
    s2 = trimLeadingZeros(s2);
  
    int n = s1.size();  
    int m = s2.size(); 
    
    // swap the strings if s1 is of smaller length
    if (n < m) {
        return addBinary(s2, s1);
    }
    
    int j = m - 1;  
    int carry = 0; 
    
    // Traverse both strings from the end
    for (int i = n - 1; i >= 0; i--) {
      
      	// Current bit of s1
        int bit1 = s1[i] - '0';  
        int sum = bit1 + carry;
        
        // If there are remaining bits in s2, 
        // add them to the sum
        if (j >= 0) {
          	
          	// Current bit of s2
            int bit2 = s2[j] - '0';  
            sum += bit2;
            j--;
        }
        
        // Calculate the result bit and update carry
        int bit = sum % 2;
        carry = sum / 2;
        
        // Update the current bit in s1
        s1[i] = (char)(bit + '0');
    }
    
    // If there's any carry left, update s1
    if (carry > 0) {
        s1 = '1' + s1;
    }
    
    return s1;
}

int main() {
  
    string s1 = "1101", s2 = "111";
    cout << addBinary(s1, s2) << endl;
    return 0;
}

Java

class GFG {

    // Function to trim leading zeros from a binary string
    static String trimLeadingZeros(String s) {

        // Find the position of the first '1'
        int firstOne = s.indexOf('1');
        return (firstOne == -1) ? "0"
                                : s.substring(firstOne);
    }

    static String addBinary(String s1, String s2) {
      
        // Trim Leading Zeros
        s1 = trimLeadingZeros(s1);
        s2 = trimLeadingZeros(s2);
        
        int n = s1.length();
        int m = s2.length();

        // Swap the strings if s1 is of smaller length
        if (n < m) {
            return addBinary(s2, s1);
        }

        int j = m - 1;
        int carry = 0;
        StringBuilder result = new StringBuilder();

        // Traverse both strings from the end
        for (int i = n - 1; i >= 0; i--) {

            // Current bit of s1
            int bit1 = s1.charAt(i) - '0';
            int sum = bit1 + carry;

            // If there are remaining bits in s2, add them
            // to the sum
            if (j >= 0) {

                // Current bit of s2
                int bit2 = s2.charAt(j) - '0';
                sum += bit2;
                j--;
            }

            // Calculate the result bit and update carry
            int bit = sum % 2;
            carry = sum / 2;

            // Update the current bit in result
            result.append((char)(bit + '0'));
        }

        // If there's any carry left, update the result
        if (carry > 0)
            result.append('1');

        return result.reverse().toString();
    }

    public static void main(String[] args) {
        String s1 = "1101";
        String s2 = "111";

        System.out.println(addBinary(s1, s2));
    }
}

Python

def trimLeadingZeros(s):
    
    # Find the position of the first '1'
    firstOne = s.find('1')
    return s[firstOne:] if firstOne != -1 else "0"

def addBinary(s1, s2):
    
    # Trim Leading Zeros
    s1 = trimLeadingZeros(s1)
    s2 = trimLeadingZeros(s2)
    
    n = len(s1)
    m = len(s2)

    # Swap the strings if s1 is of smaller length
    if n < m:
        s1, s2 = s2, s1
        n, m = m, n

    j = m - 1
    carry = 0
    result = []

    # Traverse both strings from the end
    for i in range(n - 1, -1, -1):

        # Current bit of s1
        bit1 = int(s1[i])
        bitSum = bit1 + carry

        # If there are remaining bits in s2
        # add them to the bitSum
        if j >= 0:
            
            # Current bit of s2
            bit2 = int(s2[j])
            bitSum += bit2
            j -= 1

        # Calculate the result bit and update carry
        bit = bitSum % 2
        carry = bitSum // 2

        # Update the current bit in result
        result.append(str(bit))

    # If there's any carry left, prepend it to the result
    if carry > 0:
        result.append('1')

    return ''.join(result[::-1])


if __name__ == "__main__":
    s1 = "1101"
    s2 = "111"
    print(addBinary(s1, s2))

C#

using System;

class GFG {
  
    // Function to trim leading zeros from a binary string
    static string trimLeadingZeros(string s) {

        // Find the position of the first '1'
        int firstOne = s.IndexOf('1');
        return (firstOne == -1) ? "0" : s.Substring(firstOne);
    }

    static string addBinary(string s1, string s2) {
        
        // Trim leading zeros
        s1 = trimLeadingZeros(s1);
        s2 = trimLeadingZeros(s2);
      
        int n = s1.Length;
        int m = s2.Length;

        // Swap the strings if s1 is of smaller length
        if (n < m) {
            return addBinary(s2, s1);
        }

        int j = m - 1;
        int carry = 0;
        char[] result = new char[n];

        // Traverse both strings from the end
        for (int i = n - 1; i >= 0; i--) {

            // Current bit of s1
            int bit1 = s1[i] - '0';
            int sum = bit1 + carry;

            // If there are remaining bits in s2, add them to the sum
            if (j >= 0) {
              
                // Current bit of s2
                int bit2 = s2[j] - '0';
                sum += bit2;
                j--;
            }

            // Calculate the result bit and update carry
            int bit = sum % 2;
            carry = sum / 2;

            // Update the current bit in result
            result[i] = (char)(bit + '0');
        }

        // If there's any carry left
        // prepend it to the result
        if (carry > 0) {
            return '1' + new string(result);
        }

        return new string(result);
    }

    static void Main() {
        string s1 = "1101";
        string s2 = "111";
        Console.WriteLine(addBinary(s1, s2));
    }
}

JavaScript

// Function to trim leading zeros from a binary string
function trimLeadingZeros(s) {
    
    // Find the position of the first '1'
    let firstOne = s.indexOf('1');
    return (firstOne === -1) ? "0" : s.substring(firstOne);
}

function addBinary(s1, s2) {
	
    // Trim leading zeros
    s1 = trimLeadingZeros(s1);
    s2 = trimLeadingZeros(s2);

    let n = s1.length;
    let m = s2.length;

    // Swap the strings if s1 is of smaller length
    if (n < m) {
        return addBinary(s2, s1);
    }

    let j = m - 1;
    let carry = 0;
    let result = [];

    // Traverse both strings from the end
    for (let i = n - 1; i >= 0; i--) {

        // Current bit of s1
        let bit1 = s1[i] - '0';
        let sum = bit1 + carry;

        // If there are remaining bits in s2, add them to the sum
        if (j >= 0) {
            
            // Current bit of s2
            let bit2 = s2[j] - '0';
            sum += bit2;
            j--;
        }

        // Calculate the result bit and update carry
        let bit = sum % 2;
        carry = Math.floor(sum / 2);

        // Update the current bit in result
        result.push(bit);
    }

    // If there's any carry left, prepend it to the result
    if (carry > 0) {
        result.push(1);
    }

    return result.reverse().join('');
}

console.log(addBinary("1101", "111"));

Output

Related Articles:

Comment

Explore