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

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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.    

chevron_right


Python 3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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.

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?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.
?>

chevron_right



Output :

Min Flips = 3

This article is contributed by Shivam Pradhan (anuj_charm). If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.



My Personal Notes arrow_drop_up



Article Tags :
Practice Tags :


Be the First to upvote.


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.