# Minimum removal of consecutive similar characters required to empty a Binary String

Last Updated : 20 Oct, 2023

Given a binary string S of length N, the task is to find the minimum number of removal of adjacent similar characters required to empty the given binary string.

Examples:

Input: S = â€œ1100011â€œ
Output: 2
Explanation:
Operation 1: Removal of all 0s modifies S to â€œ1111â€œ.
Operation 2: Removal of all remaining 1s makes S empty.
Therefore, the minimum number of operations required is 2.

Input: S = â€œ0010100â€œ
Output: 3
Explanation:
Operation 1: Removal of all 1s modifies S to â€œ000100â€œ.
Operation 2: Removal of all 1s modifies S = â€œ00000â€œ.
Operation 3: Removal of all remaining 0s makes S empty.
Therefore, the minimum number of operations required is 3.

Approach: The given problem can be solved using Greedy Approach. The idea is to delete the consecutive occurrences of the character with a higher frequency. Follow the steps below to solve the problem:

• Traverse the given string S and generate a new string, say newString, by removing consecutive occurrences of the character with higher frequency.
• Finally, print (sizeof(newString) + 1)/2 as the required answer

Explanation: The given string  eg : â€œ1100011â€œ changes 101 as we are skipping the multiple occurrence. After this we are returning  (sizeof(newString) + 1)/2 the size of are new string being  3 ,  101 -> we first delete the 0 which takes us 1 operation then the new string is 11  next we do just 1 more operation to delete the string 11 , taking a total of 2 operations.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach`   `#include ` `using` `namespace` `std;`   `// Function to find minimum steps` `// to make the string empty` `int` `minSteps(string S)` `{` `    ``// Stores the modified string` `    ``string new_str;`   `    ``// Size of string` `    ``int` `N = S.length();`   `    ``int` `i = 0;`   `    ``while` `(i < N) {`   `        ``new_str += S[i];`   `        ``// Removing substring of same` `        ``// character from modified string` `        ``int` `j = i;` `        ``while` `(i < N && S[i] == S[j])` `            ``++i;` `    ``}`   `    ``// Print the minimum steps required` `    ``cout << ``ceil``((new_str.size() + 1) / 2.0);` `}`   `// Driver Code` `int` `main()` `{` `    ``// Given string S` `    ``string S = ``"0010100"``;`   `    ``// Function Call` `    ``minSteps(S);`   `    ``return` `0;` `}`

## Java

 `// Java program for the above approach` `import` `java.util.*;`   `class` `GFG{`   `// Function to find minimum steps` `// to make the String empty` `static` `void` `minSteps(String S)` `{` `    `  `    ``// Stores the modified String` `    ``String new_str = ``""``;`   `    ``// Size of String` `    ``int` `N = S.length();`   `    ``int` `i = ``0``;`   `    ``while` `(i < N) ` `    ``{` `        ``new_str += S.charAt(i);` `        `  `        ``// Removing subString of same` `        ``// character from modified String` `        ``int` `j = i;` `        ``while` `(i < N && S.charAt(i) == S.charAt(j))` `            ``++i;` `    ``}`   `    ``// Print the minimum steps required` `    ``System.out.print((``int``)Math.ceil(` `        ``(new_str.length() + ``1``) / ``2.0``));` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `    `  `    ``// Given String S` `    ``String S = ``"0010100"``;`   `    ``// Function Call` `    ``minSteps(S);` `}` `}`   `// This code is contributed by Princi Singh`

## Python3

 `# Python3 program for the above approach` `from` `math ``import` `ceil`   `# Function to find minimum steps` `# to make the empty` `def` `minSteps(S):` `    `  `    ``# Stores the modified string` `    ``new_str ``=` `""`   `    ``# Size of string` `    ``N ``=` `len``(S)`   `    ``i ``=` `0`   `    ``while` `(i < N):` `        ``new_str ``+``=` `S[i]`   `        ``# Removing substring of same character` `        ``# from modified string` `        ``j ``=` `i` `        ``while` `(i < N ``and` `S[i] ``=``=` `S[j]):` `            ``i ``+``=` `1`   `    ``# Print the minimum steps required` `    ``print``(ceil((``len``(new_str) ``+` `1``) ``/` `2``))`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    `  `    ``# Given S` `    ``S ``=` `"0010100"`   `    ``# Function Call` `    ``minSteps(S)`   `# This code is contributed by mohit kumar 29`

## C#

 `// C# program for the above approach` `using` `System;`   `class` `GFG{`   `// Function to find minimum steps` `// to make the string empty` `static` `void` `minSteps(``string` `S)` `{` `    `  `    ``// Stores the modified string` `    ``string` `new_str = ``""``;` `    `  `    ``// Size of string` `    ``int` `N = S.Length;`   `    ``int` `i = 0;`   `    ``while` `(i < N) ` `    ``{` `        ``new_str += S[i];` `        `  `        ``// Removing substring of same` `        ``// character from modified string` `        ``int` `j = i;` `        `  `        ``while` `(i < N && S[i] == S[j])` `            ``++i;` `    ``}`   `    ``// Print the minimum steps required` `    ``Console.Write((``int``)Math.Ceiling(` `        ``(new_str.Length + 1) / 2.0));` `}`   `// Driver Code` `public` `static` `void` `Main()` `{` `    `  `    ``// Given string S` `    ``string` `S = ``"0010100"``;`   `    ``// Function Call` `    ``minSteps(S);` `}` `}`   `// This code is contributed by SURENDRA_GANGWAR`

## Javascript

 ``

Output

```3

```

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

Another Approach:

Count the no. of contiguous subgroups of 1 and 0 and return the minimun no. of subgroups after adding 1 to it.

Steps that were to follow the above approach:

• Initialize two variables sub_of_1 and sub_of_0 with 0 to count the no. of contiguous subgroups of 1 and 0.
• Use a loop and start traversing the string from start to end.
• Check if str[i] = ‘1’ or str[i] = ‘0’, where i = 0,1,2,3….. length of the str-1.
• If str[i] = ‘1’, traverse the contiguous subgroup of 1 till str[i] != ‘0’ by incrementing i. After that increment variable sub_of_1 by 1 and decrement i, as you have reached one index ahead of the index where the subgroup of a is ending.
• If str[i] = ‘0’, traverse the contiguous subgroup of 0 till str[i] != ‘1’ by incrementing i. After that increment variable sub_of_0 by 1 and decrement i, as you have reached one index ahead of the index where the subgroup of 0 is ending.
• Last return the minimum number of subgroups ( min(sub_of_1,sub_of_0) ) after adding 1 to it.

Below is the code to implement the above steps:

## C++

 `#include ` `using` `namespace` `std;`   `int` `minSteps(string str) {`   `    ``int` `sub_of_1 = 0, sub_of_0 = 0;` `    ``for``(``int` `i = 0; i

## Java

 `public` `class` `MinSteps {`   `    ``public` `static` `int` `minSteps(String str) {` `        ``int` `sub_of_1 = ``0``, sub_of_0 = ``0``;`   `        ``for` `(``int` `i = ``0``; i < str.length(); i++) {` `            ``if` `(str.charAt(i) == ``'1'``) {` `                ``while` `(i < str.length() && str.charAt(i) == ``'1'``) {` `                    ``i++;` `                ``}` `                ``sub_of_1++;` `                ``i--; ``// Decrement to account for the next character in the loop.` `            ``} ``else` `{` `                ``while` `(i < str.length() && str.charAt(i) == ``'0'``) {` `                    ``i++;` `                ``}` `                ``sub_of_0++;` `                ``i--; ``// Decrement to account for the next character in the loop.` `            ``}` `        ``}`   `        ``return` `Math.min(sub_of_1, sub_of_0) + ``1``;` `    ``}`   `    ``public` `static` `void` `main(String[] args) {` `        ``String str = ``"110001101"``;` `        ``System.out.println(minSteps(str));` `    ``}` `}`

## Python3

 `def` `minSteps(s):` `    ``sub_of_1 ``=` `0` `    ``sub_of_0 ``=` `0` `    ``i ``=` `0` `    `  `    ``while` `i < ``len``(s):` `        ``if` `s[i] ``=``=` `'1'``:` `            ``# Count the consecutive '1's` `            ``while` `i < ``len``(s) ``and` `s[i] ``=``=` `'1'``:` `                ``i ``+``=` `1` `            ``sub_of_1 ``+``=` `1` `            ``i ``-``=` `1`  `# Move back to the last '1'` `        ``else``:` `            ``# Count the consecutive '0's` `            ``while` `i < ``len``(s) ``and` `s[i] ``=``=` `'0'``:` `                ``i ``+``=` `1` `            ``sub_of_0 ``+``=` `1` `            ``i ``-``=` `1`  `# Move back to the last '0'` `        `  `        ``i ``+``=` `1` `    `  `    ``# Return the minimum number of steps needed` `    ``return` `min``(sub_of_1, sub_of_0) ``+` `1`   `# Driver code` `if` `__name__ ``=``=` `"__main__"``:` `    ``str` `=` `"110001101"` `    ``print``(minSteps(``str``))`

## C#

 `using` `System;`   `class` `GFG` `{` `    ``static` `int` `Geek(``string` `str)` `    ``{` `        ``int` `subOf1 = 0, subOf0 = 0;` `        ``for` `(``int` `i = 0; i < str.Length; i++)` `        ``{` `            ``if` `(str[i] == ``'1'``)` `            ``{` `                ``while` `(i < str.Length && str[i] == ``'1'``)` `                ``{` `                    ``i++;` `                ``}` `                ``subOf1++;` `                ``i--;` `            ``}` `            ``else` `            ``{` `                ``while` `(i < str.Length && str[i] == ``'0'``)` `                ``{` `                    ``i++;` `                ``}` `                ``subOf0++;` `                ``i--;` `            ``}` `        ``}` `        ``return` `Math.Min(subOf1, subOf0) + 1;` `    ``}` `    ``static` `void` `Main(``string``[] args)` `    ``{` `        ``string` `str = ``"110001101"``;` `        ``Console.WriteLine(Geek(str));` `    ``}` `}`

## Javascript

 `// Function to find the minimum steps to group substrings of '1's or '0's` `function` `minSteps(str) {` `    ``let subOf1 = 0;` `    ``let subOf0 = 0;`   `    ``for` `(let i = 0; i < str.length; i++) {` `        ``if` `(str[i] === ``'1'``) {` `            ``// Count consecutive '1's` `            ``while` `(i < str.length && str[i] === ``'1'``) {` `                ``i++;` `            ``}` `            ``subOf1++;` `            ``i--; ``// Decrement to account for the next character in the loop.` `        ``} ``else` `{` `            ``// Count consecutive '0's` `            ``while` `(i < str.length && str[i] === ``'0'``) {` `                ``i++;` `            ``}` `            ``subOf0++;` `            ``i--; ``// Decrement to account for the next character in the loop.` `        ``}` `    ``}`   `    ``// Return the minimum of the two counts plus 1` `    ``return` `Math.min(subOf1, subOf0) + 1;` `}`   `// Main function` `function` `main() {` `    ``let str = ``"110001101"``;` `    ``console.log(minSteps(str));` `}`   `// Call the main function` `main();`

Output

```3

```

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