Add Two Numbers without using '+' operator : C++

To perform addition using bitwise operators, you need to use a combination of bitwise AND, XOR, and shift operations. Here's a step-by-step explanation of how this works:

 Explanation

1. Bitwise XOR (`^`): This operation is used to add two bits without carrying. For example, `1 ^ 1 = 0` (with carry), and `0 ^ 1 = 1`.

2. Bitwise AND (`&`): This operation is used to determine which bits will need to be carried. For example, `1 & 1 = 1` (indicating a carry is needed), and `0 & 1 = 0` (no carry).

3. Left Shift (`<<`): This operation is used to shift the carry to the left by one position, so it can be added in the next higher bit position.

 Steps to Add Two Numbers

1. Calculate Partial Sum: Use XOR to get the partial sum without considering the carry.

2. Calculate Carry: Use AND and then shift left to find the carry for the next bit.

3. Repeat: Continue the process until there is no carry left.

 Example Code in Python

Here's a Python function to add two integers using bitwise operators:

```python
def add(a, b):
    while b != 0:
        # Calculate partial sum (a XOR b)
        carry = a & b
        a = a ^ b
        
        # Calculate the carry and shift it left
        b = carry << 1
        
    return a

# Example usage
result = add(15, 27)
print(result)  # Output: 42
```

 How It Works

1. Initial Addition:
   - `a ^ b` gives the sum of `a` and `b` without considering carry.
   - `a & b` gives the carry which needs to be added to the next higher bit position.

2. Updating Carry:
   - `carry << 1` shifts the carry left by one position to align it with the next higher bit.

3. Loop Until No Carry:
   - The loop continues until there is no carry left (i.e., `b` becomes 0).

This method effectively simulates the addition process at the bit level without using traditional arithmetic operators.

Comments

Post a Comment

Popular posts from this blog

Two Sum : of Array Element thats equal to target sume

Save the index of an element to a hashmap that if deduction from target is not equal to already substracted element. class Solution { public: vector<int> twoSum(vector<int>& nums, int target) { unordered_map<int, int> imap(nums.size()); for( int i=0; i<nums.size(); ++i) { if(imap.find(target-nums[i]) == imap.end()) { imap[nums[i]] = i; } else return {imap[target-nums[i]], i}; } return {0,0}; } };
Read more

From Zero to Production-Ready: Your Year-Long Journey to Mastering System Design

  Do you feel a gap between knowing system design concepts and actually building something that can support millions of users? You're not alone. Most courses teach you to   diagram   a system, but few teach you to   build   one. What if you could incrementally construct a complete, production-ready system over the next year, one practical task at a time? That’s the core of our mission. This course,  "Build a Production-Ready System in One Year,"  is a hands-on marathon designed to transform your theoretical knowledge into tangible, resume-worthy expertise. Why Take This Unique System Design Course? Forget about passive learning. This is a builder's course. Daily Hands-On Tasks:  Each day, you'll complete a concrete, practical task with a clear output. No fluff, just code and architecture. Incremental Expertise:  Start with the fundamentals and progressively layer on complexity. Your skills and your system will grow together, week by week. Mas...
Read more

LinkedList: Add Two Numbers - C++

Run main look till list1 and list2 both of them reaches end and carry of two digit some is zero. keep adding carry to the sum.  #code - cpp - C++ ```cpp [] /**  * Definition for singly-linked list.  * struct ListNode {  *     int val;  *     ListNode *next;  *     ListNode() : val(0), next(nullptr) {}  *     ListNode(int x) : val(x), next(nullptr) {}  *     ListNode(int x, ListNode *next) : val(x), next(next) {}  * };  */ class Solution { public:     int add(ListNode* l1, ListNode* l2, int&amp; carry){         int sum = carry;         if(l1)             sum += l1-&gt;val;         if(l2)              sum += l2-&gt;val;                  carry = sum / 10;       ...
Read more