Open In App

Minimum flips required to maximize a number with k set bits

Improve
Improve
Like Article
Like
Save
Share
Report

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++




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




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




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


Javascript




<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(log2n), where n represents the given integer.
Auxiliary Space: O(1), no extra space is required, so it is a constant.

 



Last Updated : 23 May, 2022
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads