Saturday, December 28, 2024
Google search engine
HomeData Modelling & AILargest set with bitwise OR equal to n

Largest set with bitwise OR equal to n

Given an integer n, find the largest possible set of non-negative integers with bitwise OR equal to n.
Examples: 
 

Input : n = 5
Output : arr[] = [0, 1, 4, 5]
The bitwise OR of 0, 1, 4 and 5 equals 5. 
It is not possible to obtain a set larger than this.

Input : n = 8
Output : arr[] = [0, 8]

 

Prerequisite: Maximum subset with bitwise OR equal to k
The difference between the above-referenced article and this post is the number of elements to be checked. In the above-referenced article, we have an array of n numbers and in this post, we have the entire set of non-negative numbers.
Traversing an array was simple with the time complexity of O(N), but traversing the boundless set of non-negative numbers is not possible. So how do we limit ourselves to a smaller set of numbers?
The answer lies in the concept used. For any number, x greater than n, the bitwise OR of x and n will never be equal to n. 
Hence we only need to traverse from 0 to n to obtain our answer.
The second difference is that there will always be an answer to this question. On the other hand, there was no certainty in the existence of an answer in the above-referenced article. This is because we can always include n in the resulting set.
Algorithm: 
Traverse the numbers from 0 to n, checking its bitwise OR with n. If the bitwise OR equals n, then include that number in the resulting set.

1. declare a vector v of integer elements.

2. iterate through i=0 till n:

           *check if i bitwise or n is equal to n than push i in v.

3. iterate through i=0 till size of v:

           *print v[i].
 

C++




// CPP Program to find the largest set
// with bitwise OR equal to n
#include <bits/stdc++.h>
using namespace std;
 
// function to find the largest set with
// bitwise OR equal to n
void setBitwiseORk(int n)
{
    vector<int> v;
 
    for (int i = 0; i <= n; i++) {
 
        // If the bitwise OR of n and i
        // is equal to n, then include i
        // in the set
        if ((i | n) == n)
            v.push_back(i);
    }
 
    for (int i = 0; i < v.size(); i++)
        cout << v[i] << ' ';
}
 
// Driver Code
int main()
{
    int n = 5;
 
    setBitwiseORk(n);
    return 0;
}


Java




// Java Program to find the largest set
// with bitwise OR equal to n
import java.util.*;
 
class GFG
{
 
    // function to find the largest set with
    // bitwise OR equal to n
    static void setBitwiseORk(int n)
    {
        Vector<Integer> v = new Vector<Integer>();
 
        for (int i = 0; i <= n; i++)
        {
 
            // If the bitwise OR of n and i
            // is equal to n, then include i
            // in the set
            if ((i | n) == n)
            {
                v.add(i);
            }
        }
 
        for (int i = 0; i < v.size(); i++)
        {
            System.out.print(v.get(i) + " ");
        }
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        int n = 5;
 
        setBitwiseORk(n);
    }
}
 
/* This code contributed by PrinciRaj1992 */


Python3




# Python 3 Program to find the largest
# set with bitwise OR equal to n
 
# function to find the largest set
# with bitwise OR equal to n
def setBitwiseORk(n):
    v = []
 
    for i in range(0, n + 1, 1):
         
        # If the bitwise OR of n and i
        # is equal to n, then include i
        # in the set
        if ((i | n) == n):
            v.append(i)
 
    for i in range(0, len(v), 1):
        print(v[i], end = ' ')
 
# Driver Code
if __name__ == '__main__':
    n = 5
 
    setBitwiseORk(n)
 
# This code is contributed by
# Surendra_Gangwar


C#




// C# Program to find the largest set
// with bitwise OR equal to n
using System;
using System.Collections.Generic;
     
class GFG
{
 
    // function to find the largest set with
    // bitwise OR equal to n
    static void setBitwiseORk(int n)
    {
        List<int> v = new List<int>();
 
        for (int i = 0; i <= n; i++)
        {
 
            // If the bitwise OR of n and i
            // is equal to n, then include i
            // in the set
            if ((i | n) == n)
            {
                v.Add(i);
            }
        }
 
        for (int i = 0; i < v.Count; i++)
        {
            Console.Write(v[i] + " ");
        }
    }
 
    // Driver Code
    public static void Main(String[] args)
    {
        int n = 5;
 
        setBitwiseORk(n);
    }
}
 
// This code has been contributed by 29AjayKumar


Javascript




<script>
 
// JavaScript Program to find the largest set
// with bitwise OR equal to n
 
// function to find the largest set with
// bitwise OR equal to n
function setBitwiseORk(n)
{
    var v = [];
 
    for (var i = 0; i <= n; i++) {
 
        // If the bitwise OR of n and i
        // is equal to n, then include i
        // in the set
        if ((i | n) == n)
            v.push(i);
    }
 
    for (var i = 0; i < v.length; i++)
        document.write( v[i] + ' ');
}
 
// Driver Code
var n = 5;
setBitwiseORk(n);
 
</script>


Output:  

0 1 4 5

Time complexity: O(N)

Auxiliary Space:O(N)
 

Feeling lost in the world of random DSA topics, wasting time without progress? It’s time for a change! Join our DSA course, where we’ll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!

RELATED ARTICLES

Most Popular

Recent Comments