# Count integers less than A so that Bitwise AND of B with XOR of A and the number is 0

• Last Updated : 26 Sep, 2022

Given two positive integers A and B, the task is to find the number of integers X such that (AâŠ•X ) & B = 0 and 0 â‰¤ X < A where âŠ• is bitwise XOR and & is bitwise AND operator.

Examples:

Input: A = 3, B = 5
Output: 1
â€¨Explanation: Here A = 3, B = 5. So we need to find the number of X,
which satisfy 0â‰¤X<3, and (3âŠ•X)&5=0.
( 011 âŠ• 000 ) & 101 = 011 & 101 = 001 â‰  0
( 011 âŠ• 001 ) & 101 = 010 & 101 = 000
( 011 âŠ• 010 ) & 101 = 001 & 101 = 001 â‰  0
So,  X = 1 only satisfies the requirements. So the answer is 1.

Input: A = 8, B = 4
Output: 4

Approach: The idea to solve this problem is:

The bitwise and of AâŠ•X with B should be 0

• This means if a bit is set in B, it will be set in X if and only if it is set in A. In other words, if some bit of B is set, there is exactly one choice for such a bit in X.
• After this, we apply a classical technique when counting things that must be lexicographically smaller than something else. Iterate over the positions, and fix the one that is the first to be strictly less, then we have complete freedom in all following positions.
• That is, iterate bits from 30 down to 0. Suppose we are currently at the ith bit. We will assume that the bits from 30 to (i+1) of both A and X are equal, and the ith bit of X is strictly less than the ith bit of A (\this is only possible when the i-th bit of A is 1, and the ith bit of B is not 1).
• Now, bits 0 to iâˆ’1 are totally free (except for the restriction on set bits of B), and each of these have 2 choices. So, if there are c such free bits, add 2c to the answer.

Follow the given steps to solve the problem:

• Iterate from i = 30 to 1.
• If the ith bit is either set in B or not set in A, do nothing
• Otherwise, count the number of bits from 0 to iâˆ’1 that are not set in B. If this number is c, add 2c to the answer.

Below is the implementation of the above approach.

## C++

 `// C++ code to implement the approach` `#include "bits/stdc++.h"` `using` `namespace` `std;`   `// Function to find number of integers` `int` `numOfInteger(``int` `A, ``int` `B)` `{` `    ``int` `ans = 0;` `    ``int` `ct = 31 - __builtin_popcount(B);`   `    ``for` `(``int` `bit = 30; bit >= 0; --bit) {` `        ``if` `((B >> bit) & 1)` `            ``continue``;` `        ``--ct;` `        ``if` `((~A >> bit) & 1)` `            ``continue``;`   `        ``// Let this be the first bit that` `        ``// is strictly less than n` `        ``ans += 1 << ct;` `    ``}` `    ``return` `ans;` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `A = 3;` `    ``int` `B = 5;`   `    ``// Function call` `    ``cout << numOfInteger(A, B);` `    ``return` `0;` `}`

## Java

 `// Java code to implement the approach` `//include "bits/stdJava.h"` `class` `GFG{`   `  ``// Function to find number of integers` `  ``static` `int` `numOfInteger(``int` `A, ``int` `B)` `  ``{` `    ``int` `ans = ``0``;` `    ``int` `ct = ``31` `- Integer.bitCount(B);`   `    ``for` `(``int` `bit = ``30``; bit >= ``0``; --bit) {` `      ``if` `(((B >> bit) & ``1``)>``0``)` `        ``continue``;` `      ``--ct;` `      ``if` `(((~A >> bit) & ``1``)>``0``)` `        ``continue``;`   `      ``// Let this be the first bit that` `      ``// is strictly less than n` `      ``ans += ``1` `<< ct;` `    ``}` `    ``return` `ans;` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `main(String[] args)` `  ``{` `    ``int` `A = ``3``;` `    ``int` `B = ``5``;`   `    ``// Function call` `    ``System.out.print(numOfInteger(A, B));` `  ``}` `}`   `// This code is contributed by shikhasingrajput`

## Python3

 `# Python3 code to implement the approach`   `# Function to find number of integers` `def` `numOfInteger(A, B):` `    ``ans ``=` `0` `    ``p ``=` `0` `    ``for` `i ``in` `range``(``0``, ``30``):` `        ``if` `(~B & (``1` `<< i)):` `            ``if` `(A & (``1` `<< i)):` `                ``ans ``+``=` `(``1` `<< p)` `            ``p ``+``=` `1` `    ``return` `ans`   `   ``# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    ``A ``=` `3` `    ``B ``=` `5`   `    ``# Function call` `    ``print``(numOfInteger(A, B))`   `    ``# this code is contributed by aarohirai2616.`

## C#

 `// C# program for the above approach` `using` `System;` `using` `System.Collections.Generic;`   `public` `class` `GFG{` `    `  `    ``static` `int` `bitCount(``int` `n)` `    ``{` `        ``int` `count = 0;` `        ``while` `(n > 0) {` `            ``n &= (n - 1);` `            ``count++;` `        ``}` `        ``return` `count;` `    ``}`   `  ``// Function to find number of integers` `  ``static` `int` `numOfInteger(``int` `A, ``int` `B)` `  ``{` `    ``int` `ans = 0;` `    ``int` `ct = 31 - bitCount(B);`   `    ``for` `(``int` `bit = 30; bit >= 0; --bit) {` `      ``if` `(((B >> bit) & 1)>0)` `        ``continue``;` `      ``--ct;` `      ``if` `(((~A >> bit) & 1)>0)` `        ``continue``;`   `      ``// Let this be the first bit that` `      ``// is strictly less than n` `      ``ans += 1 << ct;` `    ``}` `    ``return` `ans;` `  ``}`     `static` `public` `void` `Main ()` `{` `    ``int` `A = 3;` `    ``int` `B = 5;`   `    ``// Function call` `    ``Console.Write(numOfInteger(A, B));` `}` `}`   `// This code is contributed by sanjoy_62.`

## Javascript

 ``

Output

`1`

Time Complexity: O(logN)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up
Related Articles