Skip to content
Related Articles

Related Articles

Minimum Count of Bit flips required to make a Binary String Palindromic
  • Last Updated : 18 Aug, 2020

Given an integer N, the task is to find the minimum number of bits required to be flipped to convert the binary representation of N into a palindrome.

Examples:

Input: N = 12 
Output:
Explanation: 
Binary String representing 12 = “1100”. 
To make “1100” a palindrome, convert the string to “0110”. 
Therefore, minimum bits required to be flipped is 2.
Input: N = 7 
Output:
Explanation: 
Binary String representing 7 = 111, which is already a palindrome. 
 

Naive Approach: The simplest way is to check for every possible subset that is a palindrome having the same number of bits.
Time Complexity: O(N)
Auxiliary Space: O(1)

Efficient Approach: The above approach can be optimized through these steps:

  1. At first check the length of the binary form of the given number.
  2. Take two pointers to one at the L.S.B and another to the M.S.B.
  3.  Now keep decrementing the first pointer and incrementing the second pointer.
  4. Check whether the bits at both the position of first and the second pointer is same or not. If not, increment the number of bits to change.

Below is the implementation of the above approach:

C++




// C++ Program to implement
// the above approach
#include <bits/stdc++.h>
using namespace std;
  
// Function to calculate the
// length of the binary string
int check_length(int n)
{
    // Length
    int ans = 0;
    while (n) {
  
        // Right shift of n
        n = n >> 1;
  
        // Increment the length
        ans++;
    }
  
    // Return the length
    return ans;
}
  
// Function to check if the bit present
// at i-th position is a set bit or not
int check_ith_bit(int n, int i)
{
    // Returns true if the bit is set
    return (n & (1 << (i - 1)))
               ? true
               : false;
}
  
// Function to count the minimum
// number of bit flips required
int no_of_flips(int n)
{
    // Length of the binary form
    int len = check_length(n);
  
    // Number of flips
    int ans = 0;
  
    // Pointer to the LSB
    int right = 1;
  
    // Pointer to the MSB
    int left = len;
  
    while (right < left) {
  
        // Check if the bits are equal
        if (check_ith_bit(n, right)
            != check_ith_bit(n, left))
            ans++;
  
        // Decrementing the
        // left pointer
        left--;
  
        // Incrementing the
        // right pointer
        right++;
    }
  
    // Returns the number of
    // bits to flip.
    return ans;
}
  
// Driver Code
int main()
{
  
    int n = 12;
  
    cout << no_of_flips(n);
  
    return 0;
}

Java




// Java program to implement
// the above approach
class GFG{
  
// Function to calculate the
// length of the binary string
static int check_length(int n)
{
      
    // Length
    int ans = 0;
      
    while (n != 0
    {
  
        // Right shift of n
        n = n >> 1;
  
        // Increment the length
        ans++;
    }
  
    // Return the length
    return ans;
}
  
// Function to check if the bit present
// at i-th position is a set bit or not
static boolean check_ith_bit(int n, int i)
{
      
    // Returns true if the bit is set
    return (n & (1<< (i - 1))) != 0 ? true : false;
}
  
// Function to count the minimum
// number of bit flips required
static int no_of_flips(int n) 
{
      
    // Length of the binary form
    int len = check_length(n);
  
    // Number of flips
    int ans = 0;
  
    // Pointer to the LSB
    int right = 1;
  
    // Pointer to the MSB
    int left = len;
  
    while (right < left)
    {
          
        // Check if the bits are equal
        if (check_ith_bit(n, right) !=
            check_ith_bit(n, left))
            ans++;
  
        // Decrementing the
        // left pointer
        left--;
  
        // Incrementing the
        // right pointer
        right++;
    }
  
    // Returns the number of
    // bits to flip.
    return ans;
}
  
// Driver Code
public static void main(String[] args)
{
    int n = 12;
  
    System.out.println(no_of_flips(n));
}
}
  
// This code is contributed by rutvik_56

Python3




# Python3 program to implement
# the above approach
  
# Function to calculate the
# length of the binary string
def check_length(n):
  
    # Length
    ans = 0
      
    while (n):
  
        # Right shift of n
        n = n >> 1
  
        # Increment the length
        ans += 1
  
    # Return the length
    return ans
  
# Function to check if the bit present
# at i-th position is a set bit or not
def check_ith_bit(n, i):
  
    # Returns true if the bit is set
    if (n & (1 << (i - 1))):
        return True 
    else
        return False
  
# Function to count the minimum
# number of bit flips required
def no_of_flips(n):
  
    # Length of the binary form
    ln = check_length(n)
  
    # Number of flips
    ans = 0
  
    # Pointer to the LSB
    right = 1
  
    # Pointer to the MSB
    left = ln
  
    while (right < left):
  
        # Check if the bits are equal
        if (check_ith_bit(n, right) !=
            check_ith_bit(n, left)):
            ans += 1
  
        # Decrementing the
        # left pointer
        left -= 1
  
        # Incrementing the
        # right pointer
        right += 1
  
    # Returns the number of
    # bits to flip. 
    return ans
  
# Driver Code
n = 12
  
print(no_of_flips(n))
  
# This code is contributed by Shivam Singh

C#




// C# program to implement
// the above approach
using System;
class GFG{
  
// Function to calculate the
// length of the binary string
static int check_length(int n)
{
      
    // Length
    int ans = 0;
      
    while (n != 0) 
    {
  
        // Right shift of n
        n = n >> 1;
  
        // Increment the length
        ans++;
    }
  
    // Return the length
    return ans;
}
  
// Function to check if the bit present
// at i-th position is a set bit or not
static bool check_ith_bit(int n, int i)
{
      
    // Returns true if the bit is set
    return (n & (1 << (i - 1))) != 0 ? 
                                true : false;
}
  
// Function to count the minimum
// number of bit flips required
static int no_of_flips(int n) 
{
      
    // Length of the binary form
    int len = check_length(n);
  
    // Number of flips
    int ans = 0;
  
    // Pointer to the LSB
    int right = 1;
  
    // Pointer to the MSB
    int left = len;
  
    while (right < left)
    {
          
        // Check if the bits are equal
        if (check_ith_bit(n, right) !=
            check_ith_bit(n, left))
            ans++;
  
        // Decrementing the
        // left pointer
        left--;
  
        // Incrementing the
        // right pointer
        right++;
    }
  
    // Returns the number of
    // bits to flip.
    return ans;
}
  
// Driver Code
public static void Main(String[] args)
{
    int n = 12;
  
    Console.WriteLine(no_of_flips(n));
}
}
  
// This code is contributed by sapnasingh4991
Output: 
2


 

Time Complexity: O(log N)
Auxiliary Space: O(1)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.




My Personal Notes arrow_drop_up
Recommended Articles
Page :