GeeksforGeeks App
Open App
Browser
Continue

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

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

Output

`3`

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

My Personal Notes arrow_drop_up