# Find N distinct numbers whose bitwise Or is equal to K

Given two integers N and K, the task is to find N distinct integers whose bit-wise OR is equal to K. If there does not exist any possible answer then print -1.

Examples:

Input: N = 3, K = 5
Output: 5 0 1
5 OR 0 OR 1 = 5

Input: N = 10, K = 5
Output: -1
It is not possible to find any solution.

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

Approach:

1. We know that if bit-wise OR of a sequence of numbers is K then all the bit positions which are 0 in K must also be zero in all the numbers.
2. So, we only have those positions to change where bit is 1 in K. Say that count is Bit_K.
3. Now, we can form pow(2, Bit_K) distinct numbers with Bit_K bits. So if, we set one number to be K itself, then rest N – 1 numbers can be built by setting 0 all the bits in every number which are 0 in K and for other bit positions any permutation of Bit_K bits other than number K.
4. If pow(2, Bit_K) < N then we cannot find any possible answer.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach ` `#include ` `using` `namespace` `std; ` `#define ll long long int ` `#define MAX 32 ` ` `  `ll pow2[MAX]; ` `bool` `visited[MAX]; ` `vector<``int``> ans; ` ` `  `// Function to pre-calculate ` `// all the powers of 2 upto MAX ` `void` `power_2() ` `{ ` `    ``ll ans = 1; ` `    ``for` `(``int` `i = 0; i < MAX; i++) { ` `        ``pow2[i] = ans; ` `        ``ans *= 2; ` `    ``} ` `} ` ` `  `// Function to return the ` `// count of set bits in x ` `int` `countSetBits(ll x) ` `{ ` ` `  `    ``// To store the count ` `    ``// of set bits ` `    ``int` `setBits = 0; ` `    ``while` `(x != 0) { ` `        ``x = x & (x - 1); ` `        ``setBits++; ` `    ``} ` ` `  `    ``return` `setBits; ` `} ` ` `  `// Function to add num to the answer ` `// by setting all bit positions as 0 ` `// which are also 0 in K ` `void` `add(ll num) ` `{ ` `    ``int` `point = 0; ` `    ``ll value = 0; ` ` `  `    ``for` `(ll i = 0; i < MAX; i++) { ` ` `  `        ``// Bit i is 0 in K ` `        ``if` `(visited[i]) ` `            ``continue``; ` `        ``else` `{ ` `            ``if` `(num & 1) { ` `                ``value += (1 << i); ` `            ``} ` `            ``num /= 2; ` `        ``} ` `    ``} ` ` `  `    ``ans.push_back(value); ` `} ` ` `  `// Function to find and print N distinct ` `// numbers whose bitwise OR is K ` `void` `solve(ll n, ll k) ` `{ ` ` `  `    ``// Choosing K itself as one number ` `    ``ans.push_back(k); ` ` `  `    ``// Find the count of set bits in K ` `    ``int` `countk = countSetBits(k); ` ` `  `    ``// Impossible to get N ` `    ``// distinct integers ` `    ``if` `(pow2[countk] < n) { ` `        ``cout << -1; ` `        ``return``; ` `    ``} ` ` `  `    ``int` `count = 0; ` `    ``for` `(ll i = 0; i < pow2[countk] - 1; i++) { ` ` `  `        ``// Add i to the answer after ` `        ``// setting all the bits as 0 ` `        ``// which are 0 in K ` `        ``add(i); ` `        ``count++; ` ` `  `        ``// If N distinct numbers are generated ` `        ``if` `(count == n) ` `            ``break``; ` `    ``} ` ` `  `    ``// Print the generated numbers ` `    ``for` `(``int` `i = 0; i < n; i++) { ` `        ``cout << ans[i] << ``" "``; ` `    ``} ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``ll n = 3, k = 5; ` ` `  `    ``// Pre-calculate all ` `    ``// the powers of 2 ` `    ``power_2(); ` ` `  `    ``solve(n, k); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java implementation of the approach ` `import` `java.util.*; ` ` `  `class` `GFG  ` `{ ` `     `  `static` `final` `int` `MAX = ``32``; ` ` `  `static` `long` `[]pow2 = ``new` `long``[MAX]; ` `static` `boolean` `[]visited = ``new` `boolean``[MAX]; ` `static` `Vector ans = ``new` `Vector<>(); ` ` `  `// Function to pre-calculate ` `// all the powers of 2 upto MAX ` `static` `void` `power_2() ` `{ ` `    ``long` `ans = ``1``; ` `    ``for` `(``int` `i = ``0``; i < MAX; i++)  ` `    ``{ ` `        ``pow2[i] = ans; ` `        ``ans *= ``2``; ` `    ``} ` `} ` ` `  `// Function to return the ` `// count of set bits in x ` `static` `int` `countSetBits(``long` `x) ` `{ ` ` `  `    ``// To store the count ` `    ``// of set bits ` `    ``int` `setBits = ``0``; ` `    ``while` `(x != ``0``)  ` `    ``{ ` `        ``x = x & (x - ``1``); ` `        ``setBits++; ` `    ``} ` ` `  `    ``return` `setBits; ` `} ` ` `  `// Function to add num to the answer ` `// by setting all bit positions as 0 ` `// which are also 0 in K ` `static` `void` `add(``long` `num) ` `{ ` `    ``int` `point = ``0``; ` `    ``long` `value = ``0``; ` ` `  `    ``for` `(``int` `i = ``0``; i < MAX; i++)  ` `    ``{ ` ` `  `        ``// Bit i is 0 in K ` `        ``if` `(visited[i]) ` `            ``continue``; ` `        ``else`  `        ``{ ` `            ``if` `(num %``2``== ``1``) ` `            ``{ ` `                ``value += (``1` `<< i); ` `            ``} ` `            ``num /= ``2``; ` `        ``} ` `    ``} ` ` `  `    ``ans.add(value); ` `} ` ` `  `// Function to find and print N distinct ` `// numbers whose bitwise OR is K ` `static` `void` `solve(``long` `n, ``long` `k) ` `{ ` ` `  `    ``// Choosing K itself as one number ` `    ``ans.add(k); ` ` `  `    ``// Find the count of set bits in K ` `    ``int` `countk = countSetBits(k); ` ` `  `    ``// Impossible to get N ` `    ``// distinct integers ` `    ``if` `(pow2[countk] < n) ` `    ``{ ` `        ``System.out.print(-``1``); ` `        ``return``; ` `    ``} ` ` `  `    ``int` `count = ``0``; ` `    ``for` `(``long` `i = ``0``; i < pow2[countk] - ``1``; i++) ` `    ``{ ` ` `  `        ``// Add i to the answer after ` `        ``// setting all the bits as 0 ` `        ``// which are 0 in K ` `        ``add(i); ` `        ``count++; ` ` `  `        ``// If N distinct numbers are generated ` `        ``if` `(count == n) ` `            ``break``; ` `    ``} ` ` `  `    ``// Print the generated numbers ` `    ``for` `(``int` `i = ``0``; i < n; i++)  ` `    ``{ ` `        ``System.out.print(ans.get(i)+``" "``); ` `    ``} ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``long` `n = ``3``, k = ``5``; ` ` `  `    ``// Pre-calculate all ` `    ``// the powers of 2 ` `    ``power_2(); ` ` `  `    ``solve(n, k); ` `} ` `} ` ` `  `// This code has been contributed by 29AjayKumar `

## Python3

 `# Pyhton 3 implementation of the approach ` `MAX` `=` `32` ` `  `pow2 ``=` `[``0` `for` `i ``in` `range``(``MAX``)] ` `visited ``=` `[``False` `for` `i ``in` `range``(``MAX``)] ` `ans ``=` `[] ` ` `  `# Function to pre-calculate ` `# all the powers of 2 upto MAX ` `def` `power_2(): ` `    ``an ``=` `1` `    ``for` `i ``in` `range``(``MAX``): ` `        ``pow2[i] ``=` `an ` `        ``an ``*``=` `2` ` `  `# Function to return the ` `# count of set bits in x ` `def` `countSetBits(x): ` `    ``# To store the count ` `    ``# of set bits ` `    ``setBits ``=` `0` `    ``while` `(x !``=` `0``): ` `        ``x ``=` `x & (x ``-` `1``) ` `        ``setBits ``+``=` `1` `     `  `    ``return` `setBits ` ` `  `# Function to add num to the answer ` `# by setting all bit positions as 0 ` `# which are also 0 in K ` `def` `add(num): ` `    ``point ``=` `0` `    ``value ``=` `0` ` `  `    ``for` `i ``in` `range``(``MAX``): ` `        ``# Bit i is 0 in K ` `        ``if` `(visited[i]): ` `            ``continue` `        ``else``: ` `            ``if` `(num & ``1``): ` `                ``value ``+``=` `(``1` `<< i) ` `            ``num ``=` `num``/``/``2` ` `  `    ``ans.append(value) ` ` `  `# Function to find and print N distinct ` `# numbers whose bitwise OR is K ` `def` `solve(n, k): ` `    ``# Choosing K itself as one number ` `    ``ans.append(k) ` ` `  `    ``# Find the count of set bits in K ` `    ``countk ``=` `countSetBits(k) ` ` `  `    ``# Impossible to get N ` `    ``# distinct integers ` `    ``if` `(pow2[countk] < n): ` `        ``print``(``-``1``) ` `        ``return` ` `  `    ``count ``=` `0` `    ``for` `i ``in` `range``(pow2[countk] ``-` `1``): ` `        ``# Add i to the answer after ` `        ``# setting all the bits as 0 ` `        ``# which are 0 in K ` `        ``add(i) ` `        ``count ``+``=` `1` ` `  `        ``# If N distinct numbers are generated ` `        ``if` `(count ``=``=` `n): ` `            ``break` ` `  `    ``# Print the generated numbers ` `    ``for` `i ``in` `range``(n): ` `        ``print``(ans[i],end ``=` `" "``) ` ` `  `# Driver code ` `if` `__name__ ``=``=` `'__main__'``: ` `    ``n ``=` `3` `    ``k ``=` `5` ` `  `    ``# Pre-calculate all ` `    ``# the powers of 2 ` `    ``power_2() ` ` `  `    ``solve(n, k) ` `     `  `# This code is contributed by ` `# Surendra_Gangwar `

## C#

 `// C# implementation of the approach ` `using` `System; ` `using` `System.Collections.Generic; ` ` `  `class` `GFG  ` `{ ` `         `  `    ``static` `int` `MAX = 32; ` `     `  `    ``static` `long` `[] pow2 = ``new` `long``[MAX]; ` `    ``static` `bool` `[] visited = ``new` `bool``[MAX]; ` `    ``static` `List<``long``> ans = ``new` `List<``long``>(); ` `     `  `    ``// Function to pre-calculate ` `    ``// all the powers of 2 upto MAX ` `    ``static` `void` `power_2() ` `    ``{ ` `        ``long` `ans = 1; ` `        ``for` `(``int` `i = 0; i < MAX; i++)  ` `        ``{ ` `            ``pow2[i] = ans; ` `            ``ans *= 2; ` `        ``} ` `    ``} ` `     `  `    ``// Function to return the ` `    ``// count of set bits in x ` `    ``static` `int` `countSetBits(``long` `x) ` `    ``{ ` `     `  `        ``// To store the count ` `        ``// of set bits ` `        ``int` `setBits = 0; ` `        ``while` `(x != 0)  ` `        ``{ ` `            ``x = x & (x - 1); ` `            ``setBits++; ` `        ``} ` `     `  `        ``return` `setBits; ` `    ``} ` `     `  `    ``// Function to add num to the answer ` `    ``// by setting all bit positions as 0 ` `    ``// which are also 0 in K ` `    ``static` `void` `add(``long` `num) ` `    ``{ ` `         `  `        ``long` `value = 0; ` `     `  `        ``for` `(``int` `i = 0; i < MAX; i++)  ` `        ``{ ` `     `  `            ``// Bit i is 0 in K ` `            ``if` `(visited[i]) ` `                ``continue``; ` `            ``else` `            ``{ ` `                ``if` `(num %2== 1) ` `                ``{ ` `                    ``value += (1 << i); ` `                ``} ` `                ``num /= 2; ` `            ``} ` `        ``} ` `     `  `        ``ans.Add(value); ` `    ``} ` `     `  `    ``// Function to find and print N distinct ` `    ``// numbers whose bitwise OR is K ` `    ``static` `void` `solve(``long` `n, ``long` `k) ` `    ``{ ` `     `  `        ``// Choosing K itself as one number ` `        ``ans.Add(k); ` `     `  `        ``// Find the count of set bits in K ` `        ``int` `countk = countSetBits(k); ` `     `  `        ``// Impossible to get N ` `        ``// distinct integers ` `        ``if` `(pow2[countk] < n) ` `        ``{ ` `            ``Console.WriteLine(-1); ` `            ``return``; ` `        ``} ` `     `  `        ``int` `count = 0; ` `        ``for` `(``long` `i = 0; i < pow2[countk] - 1; i++) ` `        ``{ ` `     `  `            ``// Add i to the answer after ` `            ``// setting all the bits as 0 ` `            ``// which are 0 in K ` `            ``add(i); ` `            ``count++; ` `     `  `            ``// If N distinct numbers are generated ` `            ``if` `(count == n) ` `                ``break``; ` `        ``} ` `     `  `        ``// Print the generated numbers ` `        ``for` `(``int` `i = 0; i < n; i++)  ` `        ``{ ` `            ``Console.Write(ans[i]+ ``" "``); ` `        ``} ` `    ``} ` `     `  `    ``// Driver code ` `    ``public` `static` `void` `Main() ` `    ``{ ` `        ``long` `n = 3, k = 5; ` `     `  `        ``// Pre-calculate all ` `        ``// the powers of 2 ` `        ``power_2(); ` `     `  `        ``solve(n, k); ` `    ``} ` `} ` ` `  `// This code is contributed by ihritik `

Output:

```5 0 1
```

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

Check out this Author's contributed articles.

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.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.