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

• Difficulty Level : Basic
• Last Updated : 30 May, 2022

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

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

Time Complexity: O(MAX)

Auxiliary Space: O(MAX)

My Personal Notes arrow_drop_up