Skip to content
Related Articles

Related Articles

Improve Article
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 <bits/stdc++.h>
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<Long> 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



<script>
// Javascript implementation of the approach
 
const MAX = 32;
 
let pow2 = new Array(MAX);
let visited = new Array(MAX);
let ans = [];
 
// Function to pre-calculate
// all the powers of 2 upto MAX
function power_2()
{
    let ans = 1;
    for (let i = 0; i < MAX; i++) {
        pow2[i] = ans;
        ans *= 2;
    }
}
 
// Function to return the
// count of set bits in x
function countSetBits(x)
{
 
    // To store the count
    // of set bits
    let 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
function add(num)
{
    let point = 0;
    let value = 0;
 
    for (let i = 0; i < MAX; i++) {
 
        // Bit i is 0 in K
        if (visited[i])
            continue;
        else {
            if (num & 1) {
                value += (1 << i);
            }
            num = parseInt(num / 2);
        }
    }
 
    ans.push(value);
}
 
// Function to find and print N distinct
// numbers whose bitwise OR is K
function solve(n, k)
{
 
    // Choosing K itself as one number
    ans.push(k);
 
    // Find the count of set bits in K
    let countk = countSetBits(k);
 
    // Impossible to get N
    // distinct integers
    if (pow2[countk] < n) {
        document.write(-1);
        return;
    }
 
    let count = 0;
    for (let 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 (let i = 0; i < n; i++) {
        document.write(ans[i] + " ");
    }
}
 
// Driver code
    let n = 3, k = 5;
 
    // Pre-calculate all
    // the powers of 2
    power_2();
 
    solve(n, k);
 
</script>
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
Previous
How to change the element id using jQuery ?
Next

How to check a function is defined in JavaScript ?
Recommended Articles
Page :
Find N distinct numbers whose Bitwise XOR is equal to K
10, Dec 20
Maximize count of pairs whose Bitwise AND exceeds Bitwise XOR by replacing such pairs with their Bitwise AND
22, Feb 21
Total pairs in an array such that the bitwise AND, bitwise OR and bitwise XOR of LSB is 1
07, May 19
Calculate Bitwise OR of two integers from their given Bitwise AND and Bitwise XOR values
02, Dec 20
Maximize count of pairs whose bitwise XOR is even by replacing such pairs with their Bitwise XOR
22, Feb 21
Count pairs whose Bitwise AND exceeds Bitwise XOR from a given array
18, Mar 21
Numbers whose bitwise OR and sum with N are equal
07, May 17
Bitwise XOR of first N natural numbers that are product of two distinct Prime Numbers
03, Jun 21
Count ways to generate pairs having Bitwise XOR and Bitwise AND equal to X and Y respectively
16, Sep 20
Count pairs with equal Bitwise AND and Bitwise OR value
29, Oct 20
Non-negative pairs with sum of Bitwise OR and Bitwise AND equal to N
09, Nov 20
Check if an array can be split into K non-overlapping subarrays whose Bitwise AND values are equal
13, Jan 21
Count values whose Bitwise OR with A is equal to B
14, Jun 21
Find the triplet from given Bitwise XOR and Bitwise AND values of all its pairs
10, Dec 20
Find subsequences with maximum Bitwise AND and Bitwise OR
12, Nov 18
Find all possible pairs with given Bitwise OR and Bitwise XOR values
31, May 21
Print all distinct even and odd prefix Bitwise XORs of first N natural numbers
07, May 21
Count all N-length arrays made up of distinct consecutive elements whose first and last elements are equal
06, Jan 21
Maximum number made up of distinct digits whose sum is equal to N
25, May 21
Count numbers whose maximum sum of distinct digit-sum is less than or equals M
30, Mar 20
Find two numbers whose difference of fourth power is equal to N
31, May 20
Minimum possible Bitwise OR of all Bitwise AND of pairs generated from two given arrays
17, Sep 20
Count pairs with bitwise XOR exceeding bitwise AND from a given array
04, Oct 20
Maximize sum of squares of array elements possible by replacing pairs with their Bitwise AND and Bitwise OR
12, Oct 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
krikti
@krikti
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox