Skip to content
Related Articles

Related Articles

Minimum given operations required to convert a given binary string to all 1’s
  • Last Updated : 17 Sep, 2019

Given a binary number as a string str of length L. The task is to find the minimum number of operations needed so that the number becomes 2L-1, that is a string consisting of only 1’s of the length L.
In each operation, the number N can be replaced by N xor (N + 1).

Examples:

Input: str = “10010111”
Output: 5
N = 10010111, N + 1 = 10011000, so N xor (N + 1) = 00001111
N = 00001111, N + 1 = 00010000, so N xor (N + 1) = 00011111
N = 00011111, N + 1 = 00100000, so N xor (N + 1) = 00111111
N = 00111111, N + 1 = 01000000, so N xor (N + 1) = 01111111
N = 01111111, N + 1 = 10000000, so N xor (N + 1) = 11111111

Input: str = “101000100101011101”
Output: 17

Approach: After performing the given operation, it can be observed that in order to get the required number, in the end, the number of operations will be:



Number of Operations = length of the string (after removing leading 0s) – count of consecutive 1’s form the end (starting from the least significant bit)

Below is the implementation of the above approach:

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
  
// Function to return the number
// of operations required
int changeToOnes(string str)
{
  
    // ctr will store the number of
    // consecutive ones at the end
    // of the given binary string
    int i, l, ctr = 0;
    l = str.length();
  
    // Loop to find number of 1s
    // at the end of the string
    for (i = l - 1; i >= 0; i--) {
  
        // If the current character is 1
        if (str[i] == '1')
            ctr++;
  
        // If we encounter the first 0
        // from the LSB position then
        // we'll break the loop
        else
            break;
    }
  
    // Number of operations
    // required is (l - ctr)
    return l - ctr;
}
  
// Function to remove leading
// zeroes from the string
string removeZeroesFromFront(string str)
{
    string s;
  
    int i = 0;
  
    // Loop until s[i] becomes
    // not equal to 1
    while (i < str.length() && str[i] == '0')
        i++;
  
    // If we reach the end of
    // the string, it means that
    // string contains only 0's
    if (i == str.length())
        s = "0";
  
    // Return the string without
    // leading zeros
    else
        s = str.substr(i, str.length() - i);
    return s;
}
  
// Driver code
int main()
{
    string str = "10010111";
  
    // Removing the leading zeroes
    str = removeZeroesFromFront(str);
  
    cout << changeToOnes(str);
  
    return 0;
}

Java




// Java implementation of the approach
class GFG 
{
  
// Function to return the number
// of operations required
static int changeToOnes(String str)
{
  
    // ctr will store the number of
    // consecutive ones at the end
    // of the given binary string
    int i, l, ctr = 0;
    l = str.length();
  
    // Loop to find number of 1s
    // at the end of the string
    for (i = l - 1; i >= 0; i--) 
    {
  
        // If the current character is 1
        if (str.charAt(i) == '1')
            ctr++;
  
        // If we encounter the first 0
        // from the LSB position then
        // we'll break the loop
        else
            break;
    }
  
    // Number of operations
    // required is (l - ctr)
    return l - ctr;
}
  
// Function to remove leading
// zeroes from the string
static String removeZeroesFromFront(String str)
{
    String s;
  
    int i = 0;
  
    // Loop until s[i] becomes
    // not equal to 1
    while (i < str.length() &&
               str.charAt(i) == '0')
        i++;
  
    // If we reach the end of
    // the string, it means that
    // string contains only 0's
    if (i == str.length())
        s = "0";
  
    // Return the string without
    // leading zeros
    else
        s = str.substring(i, str.length() - i);
    return s;
}
  
// Driver code
public static void main(String[] args) 
{
    String str = "10010111";
  
    // Removing the leading zeroes
    str = removeZeroesFromFront(str);
  
    System.out.println(changeToOnes(str));
}
  
// This code is contributed by 29AjayKumar

Python3




# Python3 implementation of the approach 
  
# Function to return the number 
# of operations required 
def changeToOnes(string) : 
  
    # ctr will store the number of 
    # consecutive ones at the end 
    # of the given binary string 
    ctr = 0
    l = len(string); 
  
    # Loop to find number of 1s 
    # at the end of the string 
    for i in range(l - 1, -1, -1) : 
  
        # If the current character is 1 
        if (string[i] == '1') :
            ctr += 1
  
        # If we encounter the first 0 
        # from the LSB position then 
        # we'll break the loop 
        else :
            break
  
    # Number of operations 
    # required is (l - ctr) 
    return l - ctr; 
  
# Function to remove leading 
# zeroes from the string 
def removeZeroesFromFront(string) : 
  
    s = ""; 
  
    i = 0
  
    # Loop until s[i] becomes 
    # not equal to 1 
    while (i < len(string) and 
                   string[i] == '0') :
        i += 1
  
    # If we reach the end of 
    # the string, it means that 
    # string contains only 0's 
    if (i == len(string)) :
        s = "0"
  
    # Return the string without 
    # leading zeros 
    else :
        s = string[i: len(string) - i]; 
          
    return s; 
  
# Driver code 
if __name__ == "__main__"
  
    string = "10010111"
  
    # Removing the leading zeroes 
    string = removeZeroesFromFront(string); 
  
    print(changeToOnes(string)); 
  
# This code is contributed by AnkitRai01

C#




// C# implementation of the approach
using System;
  
class GFG 
{
  
// Function to return the number
// of operations required
static int changeToOnes(String str)
{
  
    // ctr will store the number of
    // consecutive ones at the end
    // of the given binary string
    int i, l, ctr = 0;
    l = str.Length;
  
    // Loop to find number of 1s
    // at the end of the string
    for (i = l - 1; i >= 0; i--) 
    {
  
        // If the current character is 1
        if (str[i] == '1')
            ctr++;
  
        // If we encounter the first 0
        // from the LSB position then
        // we'll break the loop
        else
            break;
    }
  
    // Number of operations
    // required is (l - ctr)
    return l - ctr;
}
  
// Function to remove leading
// zeroes from the string
static String removeZeroesFromFront(String str)
{
    String s;
  
    int i = 0;
  
    // Loop until s[i] becomes
    // not equal to 1
    while (i < str.Length &&
               str[i] == '0')
        i++;
  
    // If we reach the end of
    // the string, it means that
    // string contains only 0's
    if (i == str.Length)
        s = "0";
  
    // Return the string without
    // leading zeros
    else
        s = str.Substring(i, str.Length - i);
    return s;
}
  
// Driver code
public static void Main(String[] args) 
{
    String str = "10010111";
  
    // Removing the leading zeroes
    str = removeZeroesFromFront(str);
  
    Console.WriteLine(changeToOnes(str));
}
}
  
// This code is contributed by 29AjayKumar
Output:
5

Time Complexity: O(n)

My Personal Notes arrow_drop_up
Recommended Articles
Page :