Skip to content
Related Articles
Find N distinct numbers whose bitwise Or is equal to K
• Last Updated : 19 May, 2021

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.

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`

## Javascript

 ``
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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer Geeks Classes Live

My Personal Notes arrow_drop_up