# Numbers whose bitwise OR and sum with N are equal

Given a non-negative integer N, the task is to find count of non-negative integers
less than or equal to N whose bitwise OR and sum with N are equal.
Examples :

```Input  : N = 3
Output : 1
0 is the only number in [0, 3]
that satisfies given property.
(0 + 3) = (0 | 3)

Input  : 10
Output : 4
(0 + 10) = (0 | 10) (Both are 10)
(1 + 10) = (1 | 10) (Both are 11)
(4 + 10) = (4 | 10) (Both are 14)
(5 + 10) = (5 | 10) (Both are 15)
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

A simple solution is to traverse all numbers from 0 to N and do bitwise OR and SUM with N, if both are equal increment counter.
Time complexity = O(N).

An efficient solution is to follow following steps.
1. Find count of zero bit in N.
2. Return pow(2,count).

The idea is based on the fact that bitwise OR and sum of a number x with N are equal, if and only if
bitwise AND of x with N will is 0

```Let, N=10 =10102.
Bitwise AND of a number with N will be 0, if number
contains zero bit with all respective set bit(s) of
N and either zero bit or set bit with all respective
zero bit(s) of N (because, 0&0=1&0=0).
e.g.
bit     : 1   0   1   0
position: 4   3   2   1
Bitwise AND of any number with N will be 0, if the number
has following bit pattern
1st position can be  either 0 or 1 (2 ways)
2nd position can be  1 (1 way)
3rd position can be  either 0 or 1 (2 ways)
4th position can be  1 (1 way)
Total count = 2*1*2*1 = 22 = 4.

```

## C++

 `// C++ program to count numbers whose bitwise ` `// OR and sum with N are equal ` `#include ` `using` `namespace` `std; ` ` `  `// Function to find total 0 bit in a number ` `unsigned ``int` `CountZeroBit(``int` `n) ` `{ ` `    ``unsigned ``int` `count = 0; ` `    ``while``(n) ` `    ``{  ` `       ``if` `(!(n & 1)) ` `           ``count++; ` `       ``n >>= 1; ` `    ``} ` `    ``return` `count; ` `} ` ` `  `// Function to find Count of non-negative numbers  ` `// less than or equal to N, whose bitwise OR and  ` `// SUM with N are equal. ` `int` `CountORandSumEqual(``int` `N ) ` `{ ` `    ``// count number of zero bit in N ` `    ``int` `count = CountZeroBit(N); ` ` `  `    ``// power of 2 to count ` `    ``return` `(1 << count); ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `   ``int` `N = 10; ` `   ``cout << CountORandSumEqual(N); ` `   ``return` `0; ` `}  `

## Java

 `// Java program to count numbers whose bitwise ` `// OR and sum with N are equal ` `class` `GFG { ` `     `  `    ``// Function to find total 0 bit in a number ` `    ``static` `int` `CountZeroBit(``int` `n) ` `    ``{ ` `        ``int` `count = ``0``; ` `         `  `        ``while``(n > ``0``) ` `        ``{  ` `            ``if` `((n & ``1``) != ``0``) ` `                ``count++; ` `                 `  `            ``n >>= ``1``; ` `        ``} ` `         `  `        ``return` `count; ` `    ``} ` `     `  `    ``// Function to find Count of non-negative  ` `    ``// numbers less than or equal to N, whose  ` `    ``// bitwise OR and SUM with N are equal. ` `    ``static` `int` `CountORandSumEqual(``int` `N ) ` `    ``{ ` `         `  `        ``// count number of zero bit in N ` `        ``int` `count = CountZeroBit(N); ` `     `  `        ``// power of 2 to count ` `        ``return` `(``1` `<< count); ` `    ``} ` `     `  `    ``//Driver code ` `    ``public` `static` `void` `main (String[] args) ` `    ``{ ` `         `  `        ``int` `N = ``10``; ` `         `  `        ``System.out.print(CountORandSumEqual(N)); ` `    ``} ` `} ` ` `  `// This code is contributed by Anant Agarwal. `

## Python3

 `# Python3 program to count numbers whose  ` `# bitwise OR and sum with N are equal ` ` `  `# Function to find total 0 bit in a number ` `def` `CountZeroBit(n): ` ` `  `    ``count ``=` `0` `    ``while``(n): ` `     `  `        ``if` `(``not``(n & ``1``)): ` `            ``count ``+``=` `1` `        ``n >>``=` `1` `     `  `    ``return` `count ` ` `  `# Function to find Count of non-negative   ` `# numbers less than or equal to N, whose ` `# bitwise OR and SUM with N are equal. ` `def` `CountORandSumEqual(N): ` ` `  `    ``# count number of zero bit in N ` `    ``count ``=` `CountZeroBit(N) ` ` `  `    ``# power of 2 to count ` `    ``return` `(``1` `<< count) ` ` `  `# Driver code ` `N ``=` `10` `print``(CountORandSumEqual(N)) ` ` `  `# This code is contributed by Anant Agarwal. `

## C#

 `// C# program to count numbers whose ` `// bitwise OR and sum with N are equal ` `using` `System; ` ` `  `class` `GFG ` `{ ` `     `  `    ``// Function to find total  ` `    ``// 0 bit in a number ` `    ``static` `int` `CountZeroBit(``int` `n) ` `    ``{ ` `        ``int` `count = 0; ` `        ``while``(n>0) ` `        ``{  ` `            ``if` `(n%2!=0) ` `            ``count++; ` `            ``n >>= 1; ` `        ``} ` `        ``return` `count; ` `    ``} ` `  `  `    ``// Function to find Count of non-negative  ` `    ``// numbers less than or equal to N, whose ` `    ``// bitwise OR and SUM with N are equal. ` `    ``static` `int` `CountORandSumEqual(``int` `N ) ` `    ``{ ` `         `  `    ``// count number of zero bit in N ` `    ``int` `count = CountZeroBit(N); ` `  `  `    ``// power of 2 to count ` `    ``return` `(1 << count); ` `    ``} ` `     `  `    ``//Driver code ` `    ``public` `static` `void` `Main() ` `    ``{ ` `        ``int` `N = 10; ` `        ``Console.Write(CountORandSumEqual(N)); ` `    ``} ` `} ` ` `  `// This code is contributed by Anant Agarwal. `

## PHP

 `>= 1; ` `    ``} ` `    ``return` `\$count``; ` `} ` ` `  `// Function to find Count of  ` `// non-negative numbers less  ` `// than or equal to N, whose  ` `// bitwise OR and SUM with N  ` `// are equal. ` ` `  `function` `CountORandSumEqual(``\$N` `) ` `{ ` `    ``// count number of  ` `    ``// zero bit in N ` `    ``\$count` `= CountZeroBit(``\$N``); ` ` `  `    ``// power of 2 to count ` `    ``return` `(1 << ``\$count``); ` `} ` ` `  `// Driver code ` `\$N` `= 10; ` `echo` `CountORandSumEqual(``\$N``); ` ` `  `// This code is contributed by Ajit ` `?> `

Output :

` 4`

Total time complexity of above solution will be O(log2(N)).

This article is contributed by Viranjan Kumar Akela. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

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.

My Personal Notes arrow_drop_up

Improved By : jit_t

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.