# Equal Sum and XOR of three Numbers

• Difficulty Level : Easy
• Last Updated : 17 Aug, 2021

Given an integer N. The task is to count the numbers of pairs of integers A and B such that A + B + N = A ^ B ^ N and A and B are less than N.
Examples:

Input: N = 2
Output:
Explanation:-
For N = 2
2 XOR 0 XOR 0 = 2+0+0
2 XOR 0 XOR 1 = 2+0+1
2 XOR 0 XOR 2 != 2+0+2
2 XOR 1 XOR 0 = 2+1+0
2 XOR 1 XOR 1 != 2+1+1
2 XOR 1 XOR 2 != 2+1+2
2 XOR 2 XOR 0 != 2+2+0
2 XOR 2 XOR 1 != 2+2+1
2 XOR 2 XOR 2 != 2+2+2
So (0, 0), (0, 1) and (1, 0) are the required pairs. So the output is 3.
Input: N = 4
Output:

Approach
To make the sum of three numbers equal to the xor of three number with one of the number given we can do following:-

1. Represent the fixed number in binary form.
2. Traverse the binary expansion of the fixed number.
• If you find a 1 there is only one condition i.e. you take the other two number’s binary bits as 0 and 0.
• If you find a 0 there will be three conditions i.e. either you can have binary bits as (0, 0), (1, 0)
or (0, 1).
3. The following triplets of bits will never go for a carry so they are valid.
4. So the answer will be 3^(number of zeros in binary representation).

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the above approach``#include ``using` `namespace` `std;` `// Defining ull to unsigned long long int``typedef` `unsigned ``long` `long` `int` `ull;` `// Function to calculate power of 3``ull calculate(``int` `bit_cnt)``{``    ``ull res = 1;``    ``while` `(bit_cnt--) {``        ``res = res * 3;``    ``}` `    ``return` `res;``}` `// Function to return the count of the``// unset bit ( zeros )``int` `unset_bit_count(ull n)``{``    ``int` `count = 0;``    ``while` `(n) {` `        ``// Check the bit is 0 or not``        ``if` `((n & 1) == 0)``            ``count++;``        ``// Right shifting ( dividing by 2 )``        ``n = n >> 1;``    ``}``    ``return` `count;``}` `// Driver Code``int` `main()``{``    ``ull n;``    ``n = 2;` `    ``int` `count = unset_bit_count(n);` `    ``ull ans = calculate(count);` `    ``cout << ans << endl;` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach``import` `java.util.*;` `class` `GFG``{` `// Function to calculate power of 3``static` `long` `calculate(``int` `bit_cnt)``{``    ``long` `res = ``1``;``    ``while` `(bit_cnt-- > ``0``)``    ``{``        ``res = res * ``3``;``    ``}` `    ``return` `res;``}` `// Function to return the count of the``// unset bit ( zeros )``static` `int` `unset_bit_count(``long` `n)``{``    ``int` `count = ``0``;``    ``while` `(n > ``0``)``    ``{` `        ``// Check the bit is 0 or not``        ``if` `((n & ``1``) == ``0``)``            ``count++;``            ` `        ``// Right shifting ( dividing by 2 )``        ``n = n >> ``1``;``    ``}``    ``return` `count;``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``long` `n;``    ``n = ``2``;` `    ``int` `count = unset_bit_count(n);` `    ``long` `ans = calculate(count);` `    ``System.out.println(ans);``}``}` `// This code is contributed by PrinciRaj1992`

## Python3

 `# Python3 implementation of the approach` `# Function to calculate power of 3``def` `calculate(bit_cnt):` `    ``res ``=` `1``;``    ``while` `(bit_cnt > ``0``):``        ``bit_cnt ``-``=` `1``;``        ``res ``=` `res ``*` `3``;``    ``return` `res;` `# Function to return the count of the``# unset bit ( zeros )``def` `unset_bit_count(n):` `    ``count ``=` `0``;``    ``while` `(n > ``0``):``        ` `        ``# Check the bit is 0 or not``        ``if` `((n & ``1``) ``=``=` `0``):``            ``count ``+``=` `1``;``            ` `        ``# Right shifting ( dividing by 2 )``        ``n ``=` `n >> ``1``;``    ` `    ``return` `count;` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:` `    ``n ``=` `2``;` `    ``count ``=` `unset_bit_count(n);` `    ``ans ``=` `calculate(count);` `    ``print``(ans);` `# This code contributed by Rajput-Ji`

## C#

 `// C# implementation of the approach``using` `System;` `class` `GFG``{` `// Function to calculate power of 3``static` `long` `calculate(``int` `bit_cnt)``{``    ``long` `res = 1;``    ``while` `(bit_cnt-- > 0)``    ``{``        ``res = res * 3;``    ``}` `    ``return` `res;``}` `// Function to return the count of the``// unset bit (zeros)``static` `int` `unset_bit_count(``long` `n)``{``    ``int` `count = 0;``    ``while` `(n > 0)``    ``{` `        ``// Check the bit is 0 or not``        ``if` `((n & 1) == 0)``            ``count++;``            ` `        ``// Right shifting ( dividing by 2 )``        ``n = n >> 1;``    ``}``    ``return` `count;``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ``long` `n;``    ``n = 2;` `    ``int` `count = unset_bit_count(n);` `    ``long` `ans = calculate(count);` `    ``Console.WriteLine(ans);``}``}` `// This code is contributed by 29AjayKumar`

## Javascript

 ``

Output:

`3`

Time Complexity: O(Number of unset_bits).
Auxiliary Space: O(1).

My Personal Notes arrow_drop_up