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++ 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 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 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# 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 |
<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;
}
// Print 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> |
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:
#include <bits/stdc++.h> using namespace std;
int minSteps(string str) {
int sub_of_1 = 0, sub_of_0 = 0;
for ( int i = 0; i<str.length(); i++){
if (str[i] == '1' ){
while (str[i] == '1' ){
i++;
}
sub_of_1++;
i--;
} else {
while (str[i] == '0' ){
i++;
}
sub_of_0++;
i--;
}
}
return min(sub_of_1,sub_of_0)+1;
} int main() {
string str = "110001101" ;
cout<<minSteps(str)<<endl;
return 0;
} |
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));
}
} |
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 ))
|
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));
}
} |
// 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(); |
3
Time Complexity: O(N)
Auxiliary Space: O(1)