 Open in App
Not now

# Minimum given operations required to convert a given binary string to all 1’s

• Last Updated : 22 Dec, 2022

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:
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 ``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`

## Javascript

 ``

Output

`5`

Time Complexity: O(n), where n is the length of the given string.
Auxiliary Space: O(n)

My Personal Notes arrow_drop_up