# 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++ 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 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 `

 `# 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# 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.

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.

Article Tags :
Practice Tags :