Skip to content
Related Articles

Related Articles

Save Article
Improve Article
Save Article
Like Article

Count of carry operations on adding two Binary numbers

  • Difficulty Level : Medium
  • Last Updated : 07 May, 2021

Given two decimal numbers num1 and num2, the task is to count the number of times carry operation is required while adding the two given numbers in binary form.

Examples:

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input: num1 = 15, num2 = 10
Output: 3
Explanation:
Give numbers are added as:
15 ->            1 1 1 1
10 ->            1 0 1 0
carry ->    1 1 1 – –
——————————
25 ->         1 1 0 0 1



Input:  num1 = 14  num2 = 4
Output: 2
Explanation:
Give numbers are added as:
14 ->           1 1 1 0
 4 ->            0 1 0 0
carry ->   1 1 – – –
——————————
18 ->       1 0 0 1 0
 

Naive Approach: The naive idea is to convert the numbers into binary and add a bit one by one starting from Least Significant Bit and check if carry is generated or not. Whenever a carry is generated then increase the count by 1. Print count of carry after all the steps.

Time Complexity: O(K), where K is a count of the number of digits in the binary representation of X.
Auxiliary Space: O(log N)

Efficient Approach: The idea is to use Bitwise XOR and AND. Below are the steps:

Below is the implementation of the above approach:

C++




// C++ Program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to count the number of carry
// operations to add two binary numbers
int carryCount(int num1, int num2)
{
    // To Store the carry count
    int count = 0;
 
    // Iterate till there is no carry
    while (num2 != 0) {
 
        // Carry now contains common
        // set bits of x and y
        int carry = num1 & num2;
 
        // Sum of bits of x and y where at
        // least one of the bits is not set
        num1 = num1 ^ num2;
 
        // Carry is shifted by one
        // so that adding it to x
        // gives the required sum
        num2 = carry << 1;
 
        // Adding number of 1's of
        // carry to final count
        count += __builtin_popcount(num2);
    }
 
    // Return the final count
    return count;
}
 
// Driver Code
int main()
{
    // Given two numbers
    int A = 15, B = 10;
 
    // Function Call
    cout << carryCount(15, 10);
 
    return 0;
}

Java




// Java program for the above approach
class GFG{
 
// Function to count the number of carry
// operations to add two binary numbers
static int carryCount(int num1, int num2)
{
     
    // To Store the carry count
    int count = 0;
 
    // Iterate till there is no carry
    while (num2 != 0)
    {
         
        // Carry now contains common
        // set bits of x and y
        int carry = num1 & num2;
 
        // Sum of bits of x and y where at
        // least one of the bits is not set
        num1 = num1 ^ num2;
 
        // Carry is shifted by one
        // so that adding it to x
        // gives the required sum
        num2 = carry << 1;
 
        // Adding number of 1's of
        // carry to final count
        count += Integer.bitCount(num2);
    }
 
    // Return the final count
    return count;
}
 
// Driver Code
public static void main(String[] args)
{
     
    // Given two numbers
    int A = 15, B = 10;
 
    // Function call
    System.out.print(carryCount(A, B));
}
}
 
// This code is contributed by Amit Katiyar

Python3




# Python3 program for the above approach
 
# Function to count the number of carry
# operations to add two binary numbers
def carryCount(num1, num2):
 
    # To Store the carry count
    count = 0
 
    # Iterate till there is no carry
    while(num2 != 0):
 
        # Carry now contains common
        # set bits of x and y
        carry = num1 & num2
 
        # Sum of bits of x and y where at
        # least one of the bits is not set
        num1 = num1 ^ num2
 
        # Carry is shifted by one
        # so that adding it to x
        # gives the required sum
        num2 = carry << 1
 
        # Adding number of 1's of
        # carry to final count
        count += bin(num2).count('1')
 
    # Return the final count
    return count
 
# Driver Code
 
# Given two numbers
A = 15
B = 10
 
# Function call
print(carryCount(A, B))
 
# This code is contributed by Shivam Singh

C#




// C# program for the above approach
using System;
class GFG{
   
static int countSetBits(int x)
{
    int setBits = 0;
    while (x != 0)
    {
        x = x & (x - 1);
        setBits++;
    }
    return setBits;
}
// Function to count the number of carry
// operations to add two binary numbers
static int carryCount(int num1, int num2)
{
     
    // To Store the carry count
    int count = 0;
 
    // Iterate till there is no carry
    while (num2 != 0)
    {
         
        // Carry now contains common
        // set bits of x and y
        int carry = num1 & num2;
 
        // Sum of bits of x and y where at
        // least one of the bits is not set
        num1 = num1 ^ num2;
 
        // Carry is shifted by one
        // so that adding it to x
        // gives the required sum
        num2 = carry << 1;
 
        // Adding number of 1's of
        // carry to readonly count
        count += countSetBits(num2);
    }
 
    // Return the readonly count
    return count;
}
 
// Driver Code
public static void Main(String[] args)
{
     
    // Given two numbers
    int A = 15, B = 10;
 
    // Function call
    Console.Write(carryCount(A, B));
}
}
 
// This code is contributed by Rohit_ranjan

Javascript




<script>
// JavaScript program for the
// above approach
  
function countSetBits(x)
{
    let setBits = 0;
    while (x != 0)
    {
        x = x & (x - 1);
        setBits++;
    }
    return setBits;
}
 
// Function to count the number of carry
// operations to add two binary numbers
function carryCount(num1, num2)
{
      
    // To Store the carry count
    let count = 0;
  
    // Iterate till there is no carry
    while (num2 != 0)
    {
          
        // Carry now contains common
        // set bits of x and y
        let carry = num1 & num2;
  
        // Sum of bits of x and y where at
        // least one of the bits is not set
        num1 = num1 ^ num2;
  
        // Carry is shifted by one
        // so that adding it to x
        // gives the required sum
        num2 = carry << 1;
  
        // Adding number of 1's of
        // carry to readonly count
        count += countSetBits(num2);
    }
  
    // Return the readonly count
    return count;
}
 
// Driver Code
 
     
    // Given two numbers
    let A = 15, B = 10;
  
    // Function call
    document.write(carryCount(A, B));
 
</script>
Output: 
3

 

Time Complexity: O(log2(N))
Auxiliary Space: O(1)




My Personal Notes arrow_drop_up
Recommended Articles
Page :