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:2Explanation:

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:3Explanation:

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

Below is the implementation of the above approach:

## C++

`// C++ program for the above approach` `#include <bits/stdc++.h>` `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

`<script>` `// Javascript program to implement` `// the above approach` `// Function to find minimum steps` `// to make the string empty` `function` `minSteps(S)` `{` ` ` ` ` `// Stores the modified string` ` ` `let new_str = ` `""` `;` ` ` ` ` `// Size of string` ` ` `let N = S.length;` ` ` ` ` `let i = 0;` ` ` ` ` `while` `(i < N)` ` ` `{` ` ` `new_str += S[i];` ` ` ` ` `// Removing substring of same` ` ` `// character from modified string` ` ` `let j = i;` ` ` ` ` `while` `(i < N && S[i] == S[j])` ` ` `++i;` ` ` `}` ` ` ` ` `// Prlet the minimum steps required` ` ` `document.write(Math.ceil(` ` ` `(new_str.length + 1) / 2.0));` `}` ` ` `// Driver Code` ` ` ` ` `// Given string S` ` ` `let S = ` `"0010100"` `;` ` ` ` ` `// Function Call` ` ` `minSteps(S)` ` ` `</script>` |

**Output:**

3

**Time Complexity:** O(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. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**

In case you wish to attend live classes with industry experts, please refer **DSA Live Classes**