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

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

// CPP for finding min flip
// for maximizing given n
#include <bits/stdc++.h>
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 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.    

# 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# 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
// PHP for finding min flip
// for maximizing given n

// function for finding set bit
function setBit($xorValue)
{
    $count = 0;
    while ($xorValue) 
    {
        if ($xorValue % 2)
            $count++;

        $xorValue /= 2;
    }
    
    // return count of set bit
    return $count;
}

// function for finding min flip
function minFlip($n, $k)
{ 
    // number of bits in n
    $size = log($n) + 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;
echo "Min Flips = " , minFlip($n, $k);

// This code is contributed by vt_m.
?>

<script>
// Javascript for finding min flip
// for maximizing given n

// function for finding set bit
function setBit( xorValue)
{
    var count = 0;
    while (xorValue) {
        if (xorValue % 2)
            count++;

        xorValue = parseInt(xorValue / 2);
    }
    
    // return count of set bit
    return count;
}

// function for finding min flip
function minFlip(n, k)
{   

    // number of bits in n
    var size = Math.log2(n) + 1;
    
    // Find the largest number of
    // same size with k set bits
    var max = Math.pow(2, k) - 1;    
    max = (max << (size - k));

    // Count bit differences to find
    // required flipping.
    var xorValue = (n ^ max);
    return (setBit(xorValue));
}

// driver program
var n = 27, k = 3;
document.write( "Min Flips = " + minFlip(n, k));

// This code is contributed by itsok.
</script> 

Output : 
 

Min Flips = 3

Time Complexity: O(log₂n), where n represents the given integer.
Auxiliary Space: O(1), no extra space is required, so it is a constant.