# Minimum flips required to maximize a number with k set bits

Given two numbers n and k, we need to find the minimum number of flips required to maximize given number by flipping its bits such that the resulting number has exactly k set bits.
Note : K must be less than number of bits in n.

Examples :

```Input : n = 14, k = 2
Output : Min Flips = 1
Explanation :
Binary representation of 14 = 1110
Largest 4-digit Binary number with
2 set bit = 1100
Conversion from 1110 to 1100
requires 1 flipping

Input : n = 145, k = 4
Output : Min Flips = 3
Explanation :
Binary representation of 145 = 10010001
Largest 8-digit Binary number with
4 set bit = 11110000
Conversion from 10010001 to 11110000
requires 3 flipping
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

For the given number n and k find the largest number possible with k-set bits and having exactly same number of bits as n has as :

• size = log2(n) + 1 gives the number of bits of n.
• max = pow(2, k) – 1 gives largest possible number with k bits.
• max = max << (size – k) gives the largest number possible with k-set bits and having exactly same number of bits as n has
• Number of set bit in (n XOR max ) is our required number of flipping.

Illustration of above approach :

```let n = 145 (10010001), k = 4

size = log2(n) + 1 = log2(145) + 1
= 7 + 1 = 8

max = pow(2, k) -1 = pow(2, 4) - 1
= 16 - 1 = 15 (1111)

max = max << (size - k) = 15 << (8 - 4)
= 240 (11110000)

number of set bit in  =  no. of set bit in
(n XOR max )              (145 ^ 240 )
= 3```

## C++

 `// CPP for finding min flip ` `// for maximizing given n ` `#include ` `using` `namespace` `std; ` ` `  `// function for finding set bit ` `int` `setBit(``int` `xorValue) ` `{ ` `    ``int` `count = 0; ` `    ``while` `(xorValue) { ` `        ``if` `(xorValue % 2) ` `            ``count++; ` ` `  `        ``xorValue /= 2; ` `    ``} ` `     `  `    ``// return count of set bit ` `    ``return` `count; ` `} ` ` `  `// function for finding min flip ` `int` `minFlip(``int` `n, ``int` `k) ` `{    ` `    ``// number of bits in n ` `    ``int` `size = log2(n) + 1; ` `     `  `    ``// Find the largest number of ` `    ``// same size with k set bits ` `    ``int` `max = ``pow``(2, k) - 1;     ` `    ``max = max << (size - k); ` ` `  `    ``// Count bit differences to find ` `    ``// required flipping. ` `    ``int` `xorValue = (n ^ max); ` `    ``return` `(setBit(xorValue)); ` `} ` ` `  `// driver program ` `int` `main() ` `{ ` `    ``int` `n = 27, k = 3; ` `    ``cout << ``"Min Flips = "` `<< minFlip(n, k); ` `    ``return` `0; ` `} `

## Java

 `// JAVA Code to find Minimum flips required ` `// to maximize a number with k set bits ` `import` `java.util.*; ` ` `  `class` `GFG { ` `     `  `    ``// function for finding set bit ` `    ``static` `int` `setBit(``int` `xorValue) ` `    ``{ ` `        ``int` `count = ``0``; ` `        ``while` `(xorValue >= ``1``) { ` `            ``if` `(xorValue % ``2` `== ``1``) ` `                ``count++; ` `      `  `            ``xorValue /= ``2``; ` `        ``} ` `          `  `        ``// return count of set bit ` `        ``return` `count; ` `    ``} ` `      `  `    ``// function for finding min flip ` `    ``static` `int` `minFlip(``int` `n, ``int` `k) ` `    ``{    ` `        ``// number of bits in n ` `        ``int` `size = (``int``)(Math.log(n) /  ` `                         ``Math.log(``2``)) + ``1``; ` `          `  `        ``// Find the largest number of ` `        ``// same size with k set bits ` `        ``int` `max = (``int``)Math.pow(``2``, k) - ``1``;     ` `        ``max = max << (size - k); ` `      `  `        ``// Count bit differences to find ` `        ``// required flipping. ` `        ``int` `xorValue = (n ^ max); ` `        ``return` `(setBit(xorValue)); ` `    ``} ` `     `  `    ``/* Driver program to test above function */` `    ``public` `static` `void` `main(String[] args)  ` `    ``{ ` `         ``int` `n = ``27``, k = ``3``; ` `         ``System.out.println(``"Min Flips = "``+ ` `                             ``minFlip(n, k)); ` `    ``} ` `} ` ` `  `// This code is contributed by Arnav Kr. Mandal.     `

## Python 3

 `# Python3 for finding min flip ` `# for maximizing given n ` `import` `math ` ` `  `# function for finding set bit ` `def` `setBit(xorValue): ` ` `  `    ``count ``=` `0` `    ``while` `(xorValue): ` `        ``if` `(xorValue ``%` `2``): ` `            ``count ``+``=` `1` `         `  `        ``xorValue ``=` `int``(xorValue ``/` `2``) ` `         `  `    ``# return count  ` `    ``# of set bit ` `    ``return` `count ` ` `  `# function for  ` `# finding min flip ` `def` `minFlip(n, k): ` ` `  `    ``# number of bits in n ` `    ``size ``=` `int``(math.log(n) ``/`  `               ``math.log(``2``) ``+` `1``) ` `     `  `    ``# Find the largest number of ` `    ``# same size with k set bits ` `    ``max` `=` `pow``(``2``, k) ``-` `1` `    ``max` `=` `max` `<< (size ``-` `k) ` ` `  `    ``# Count bit differences to  ` `    ``# find required flipping. ` `    ``xorValue ``=` `(n ^ ``max``) ` `    ``return` `(setBit(xorValue)) ` ` `  `# Driver Code ` `n ``=` `27` `k ``=` `3` `print``(``"Min Flips = "` `,  ` `        ``minFlip(n, k)) ` ` `  `# This code is contributed ` `# by Smitha `

## C#

 `// C# Code to find Minimum flips required ` `// to maximize a number with k set bits ` `using` `System; ` ` `  `class` `GFG { ` `     `  `    ``// function for finding set bit ` `    ``static` `int` `setBit(``int` `xorValue) ` `    ``{ ` `        ``int` `count = 0; ` `        ``while` `(xorValue >= 1) { ` `            ``if` `(xorValue % 2 == 1) ` `                ``count++; ` `     `  `            ``xorValue /= 2; ` `        ``} ` `         `  `        ``// return count of set bit ` `        ``return` `count; ` `    ``} ` `     `  `    ``// function for finding min flip ` `    ``static` `int` `minFlip(``int` `n, ``int` `k) ` `    ``{  ` `        ``// number of bits in n ` `        ``int` `size = (``int``)(Math.Log(n) /  ` `                         ``Math.Log(2)) + 1; ` `         `  `        ``// Find the largest number of ` `        ``// same size with k set bits ` `        ``int` `max = (``int``)Math.Pow(2, k) - 1;  ` `        ``max = max << (size - k); ` `     `  `        ``// Count bit differences to find ` `        ``// required flipping. ` `        ``int` `xorValue = (n ^ max); ` `        ``return` `(setBit(xorValue)); ` `    ``} ` `     `  `    ``// Driver Code ` `    ``public` `static` `void` `Main()  ` `    ``{ ` `        ``int` `n = 27, k = 3; ` `        ``Console.Write(``"Min Flips = "``+ minFlip(n, k)); ` `    ``} ` `} ` ` `  `// This code is contributed by Nitin Mittal. `

## PHP

 ` `

Output :

```Min Flips = 3
```