# Minimum integer with at most K bits set such that their bitwise AND with N is maximum

• Last Updated : 07 Apr, 2021

Given an integer N which can be represented in 32 bit, the task is to find another integer X that has at most K bits set in its binary representation and bitwise AND of X and N is maximum.

Examples:

Input: N = 5, K = 1
Output: X = 2
Explanation:
Binary representation of 5 is 101, the possible value of X such that it maximize the AND is 2
5 -> 101
2 -> 100
AND sum -> 100 (2)
4 is the maximum AND sum we can get with N and X.

Input: N = 10, K = 2
Output: X = 10
Explanation:
Binary representation of 10 is 1010, X = 10 possible integer to given maximum AND sum with N with atmost 2 bit set.
10 -> 1010
10 -> 1010
AND sum -> 1010 (10)
10 is the maximum AND sum we can get with N and X.

Naive Approach: A naive solution is to run a loop from 1 to N and take bitwise AND with N, and also check if the number of set bits is less than or equal to K. During each iteration maintain the maximum value of bitwise AND.
Time Complexity: O(N)

Efficient Approach: This problem can be solved efficiently by using a Greedy approach on bits. Since N can have at most 32 bits. So we will start traversing from the Most Significant bit and check if it is set(or 1) in N, if it is not set then there is no need to set this bit because AND operation will make it zero in the final answer, else we will set it in our required answer. Also, we will maintain the count of set bits in each iteration and check if it does not exceed K.
Time Complexity: O(32)

Below is the implementation of the above efficient approach :

## C++

 `// C++ program for the ` `// above approach ` `#include ` `using` `namespace` `std;`   `// Function to find` `// the integer with` `// maximum bitwise with N` `int` `find_max(``int` `n, ``int` `k)` `{` `  ``// Store answer in the bitset` `  ``// Initialized with 0` `  ``bitset<32> X(0);`   `  ``// To maintain the count` `  ``// of set bits that should` `  ``// exceed k` `  ``int` `cnt = 0;`   `  ``// Start traversing from the` `  ``// Most significantif that bit ` `  ``// is set in n then we will set ` `  ``// in our answer i.e in X` `  ``for` `(``int` `i = 31; i >= 0 && ` `           ``cnt != k; i--) ` `  ``{` `    ``// Checking if the ith bit` `    ``// is set in n or not` `    ``if` `(n & (1 << i)) ` `    ``{` `      ``X[i] = 1;` `      ``cnt++;` `    ``}` `  ``}`   `  ``// Converting into integer` `  ``return` `X.to_ulong();` `}`   `// Driver Code` `int` `main()` `{` `  ``int` `n = 10, k = 2;`   `  ``// Function Call` `  ``cout << find_max(n, k) << ` `          ``endl;`   `  ``return` `0;` `}`

## Java

 `// Java program for the ` `// above approach ` `import` `java.util.*;` `import` `java.lang.*;` `class` `GFG{`   `// Function to find` `// the integer with` `// maximum bitwise with N` `static` `int` `find_max(``int` `n, ` `                    ``int` `k)` `{` `  ``// Store answer in the ` `  ``// bitset Initialized ` `  ``// with 0` `  ``int``[] X = ``new` `int``[``32``];`   `  ``// To maintain the count` `  ``// of set bits that should` `  ``// exceed k` `  ``int` `cnt = ``0``;`   `  ``// Start traversing from the ` `  ``// Most significant if that bit ` `  ``// is set in n then we will set ` `  ``// in our answer i.e in X` `  ``for` `(``int` `i = ``31``; i >= ``0` `&& ` `           ``cnt != k; i--) ` `  ``{` `    ``// Checking if the ith bit` `    ``// is set in n or not` `    ``if` `((n & (``1` `<< i)) != ``0``) ` `    ``{` `      ``X[i] = ``1``;` `      ``cnt++;` `    ``}` `  ``}`   `  ``String s = ``""``;` `  ``for``(``int` `i = ``31``; i >= ``0``; i--)` `    ``s += X[i] == ``0` `? ``'0'` `: ``'1'``;`   `  ``// Converting into integer` `  ``return` `Integer.parseInt(s,``2``);` `}`   `// Driver function` `public` `static` `void` `main (String[] args) ` `{` `  ``int` `n = ``10``, k = ``2``;`   `  ``// Function Call` `  ``System.out.println(find_max(n, k));` `}` `}`   `// This code is contributed by offbeat`

## Python3

 `# Python3 program for the above approach `   `# Function to find the integer with` `# maximum bitwise with N` `def` `find_max(n, k):` `    `  `    ``# Store answer in the ` `    ``# bitset Initialized ` `    ``# with 0` `    ``X ``=` `[``0``] ``*` `32` `    `  `    ``# To maintain the count` `    ``# of set bits that should` `    ``# exceed k` `    ``cnt ``=` `0` `    `  `    ``# Start traversing from the ` `    ``# Most significant if that bit ` `    ``# is set in n then we will set ` `    ``# in our answer i.e in X` `    ``i ``=` `31` `    `  `    ``while` `(i >``=` `0` `and` `cnt !``=` `k):` `        `  `        ``# Checking if the ith bit` `        ``# is set in n or not` `        ``if` `((n & (``1` `<< i)) !``=` `0``):` `            ``X[i] ``=` `1` `            ``cnt ``+``=` `1` `            `  `        ``i ``-``=` `1` `    `  `    ``s ``=` `""` `    `  `    ``for` `i ``in` `range``(``31``, ``-``1``, ``-``1``):` `        ``if` `X[i] ``=``=` `0``:` `            ``s ``+``=` `'0'` `        ``else``:` `            ``s ``+``=` `'1'` `    `  `    ``# Converting into integer` `    ``return` `int``(s, ``2``)` `    `  `# Driver code` `n, k ``=` `10``, ``2`   `# Function Call` `print``(find_max(n, k))`   `# This code is contributed by divyeshrabadiya07`

## C#

 `// C# program for the above approach ` `using` `System;`   `class` `GFG{` `    `  `// Function to find the integer with` `// maximum bitwise with N` `static` `int` `find_max(``int` `n, ``int` `k)` `{` `    `  `    ``// Store answer in the ` `    ``// bitset Initialized ` `    ``// with 0` `    ``int``[] X = ``new` `int``;` `    `  `    ``// To maintain the count` `    ``// of set bits that should` `    ``// exceed k` `    ``int` `cnt = 0;` `    `  `    ``// Start traversing from the ` `    ``// Most significant if that bit ` `    ``// is set in n then we will set ` `    ``// in our answer i.e in X` `    ``for``(``int` `i = 31; i >= 0 && cnt != k; i--) ` `    ``{` `        `  `        ``// Checking if the ith bit` `        ``// is set in n or not` `        ``if` `((n & (1 << i)) != 0) ` `        ``{` `            ``X[i] = 1;` `            ``cnt++;` `        ``}` `    ``}` `    `  `    ``String s = ``""``;` `    `  `    ``for``(``int` `i = 31; i >= 0; i--)` `        ``s += X[i] == 0 ? ``'0'` `: ``'1'``;` `    `  `    ``// Converting into integer` `    ``return` `Convert.ToInt32(s, 2);` `}`   `// Driver code` `public` `static` `void` `Main(String[] args)` `{` `    ``int` `n = 10, k = 2;` `    `  `    ``// Function Call` `    ``Console.Write(find_max(n, k));` `}` `}`   `// This code is contributed by offbeat`

## Javascript

 ``

Output

`10`

Performance Analysis:

• Time complexity: O(32)
• Auxiliary Space: O(1

My Personal Notes arrow_drop_up
Recommended Articles
Page :