Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

Minimum removals required to place all 0s before 1s in a Binary String

  • Difficulty Level : Medium
  • Last Updated : 20 May, 2021

Given a binary string S, the task is to find the minimum number of characters required to be removed from S, such that all the 0s are placed before 1s.

Examples:

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 experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input: S = “001101”
Output: 1
Explanation: 
Removing S[4] (= ‘0’) modifies the string S to “00111”.
Therefore, minimum number of deletions required is 1.



Input: S = 01001
Output: 1
Explanation: 
Removing S[1] (= ‘1’) modifies the string S to “0001”.
Therefore, minimum number of deletions required is 1.

 

Approach: The problem can be solved by finding the minimum number of ‘0’s characters required to be deleted from the right, say right_0, and the minimum number of ‘1’s required to be deleted from the left, say left_1, to obtain the required string. The minimum sum of right_0 and left_0 obtained for any index gives the final result. 

Follow the steps below to solve the given problem:

  1. Initialize two counter variables, say right_0 and left_1.
  2. Store the count of ‘0’s in the string S in right_0 and set left_1 equal to 0.
  3. Initialize a variable, say res, to store the required answer.
  4. Iterate over the characters of the string S and for each character:
    • Check if s[i] is equal to ‘0’ or not.
      • If found to be true, then decrease right_0 by 1.
      • Otherwise, increase left_1 by 1.
    • Check if the sum right_0, left_1 is less than res or not. If found to be true, then update res equal to the minimum of res and right_0 + left_1.
  5. After complete traversal of the array, print res 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 count minimum removals
// required to arrange all 0s before 1s
int minimumDeletions(string s)
{
    // Count the occurences of 0 in s
    int right_0 = count(s.begin(), s.end(), '0');
 
    int left_1 = 0;
     
    // Size of the string
    int n = s.size();
     
    // Stores the minimum
    // number of removals required
    int res = INT_MAX;
     
    // Iterate over each of the
    // characters in the string s
    for (int i = 0; i < n; i++)
    {
        // If the i-th character
        // is found to be '0'
        if (s[i] == '0')
        {
            right_0 -= 1;
        }
        else
        {
            left_1 += 1;
        }
         
        // Store the minimum of res
        // and right_0 + left_1 in res
        res = min(res, right_0 + left_1);
    }
   
    // Return the final result
    return res;
}
 
 
// Driver Code
int main()
{
    string s = "001101";
    int count = minimumDeletions(s);
     
    cout << count;
    return 0;
}

Java




// Java program to implement
// the above approach
import java.util.*;
class GFG{
     
// Function to count minimum removals
// required to arrange all 0s before 1s
static int minimumDeletions(String s)
{
   
    // Count the occurences of 0 in s
    int right_0 = (int)(s.chars().filter(ch -> ch == '0').count());
    int left_1 = 0;
     
    // Size of the string
    int n = s.length();
     
    // Stores the minimum
    // number of removals required
    int res = Integer.MAX_VALUE;
     
    // Iterate over each of the
    // characters in the string s
    for (int i = 0; i < n; i++)
    {
        // If the i-th character
        // is found to be '0'
        if (s.charAt(i) == '0')
        {
            right_0 -= 1;
        }
        else
        {
            left_1 += 1;
        }
         
        // Store the minimum of res
        // and right_0 + left_1 in res
        res = Math.min(res, right_0 + left_1);
    }
   
    // Return the final result
    return res;
}
 
// Driver Code
public static void main(String[] args)
{
    String s = "001101";
    int count = minimumDeletions(s);
     
    System.out.print(count);
}
}
 
// This code is contributed by  sanjoy_62.

Python3




# Python3 program for the above approach
import sys
 
# Function to count minimum removals
# required to arrange all 0s before 1s
def minimumDeletions(s) :
     
    # Count the occurences of 0 in s
    right_0 = s.count('0')
 
    left_1 = 0
     
    # Size of the string
    n = len(s)
     
    # Stores the minimum
    # number of removals required
    res = sys.maxsize
     
    # Iterate over each of the
    # characters in the string s
    for i in range(n):
         
        # If the i-th character
        # is found to be '0'
        if (s[i] == '0') :
            right_0 -= 1
         
        else :
            left_1 += 1
         
        # Store the minimum of res
        # and right_0 + left_1 in res
        res = min(res, right_0 + left_1)
     
    # Return the final result
    return res
 
# Driver Code
s = "001101"
count = minimumDeletions(s)
     
print( count)
 
# This code is contributed by splevel62.

C#




// C# program for above approach
using System;
using System.Collections.Generic;
 
public class GFG
{
 
// Function to count minimum removals
// required to arrange all 0s before 1s
static int minimumDeletions(string s)
{
   
    // Count the occurences of 0 in s
    int right_0 = (int)s.Split('0').Length - 1;
    int left_1 = 0;
     
    // Size of the string
    int n = s.Length;
     
    // Stores the minimum
    // number of removals required
    int res = Int32.MaxValue;
     
    // Iterate over each of the
    // characters in the string s
    for (int i = 0; i < n; i++)
    {
        // If the i-th character
        // is found to be '0'
        if (s[i] == '0')
        {
            right_0 -= 1;
        }
        else
        {
            left_1 += 1;
        }
         
        // Store the minimum of res
        // and right_0 + left_1 in res
        res = Math.Min(res, right_0 + left_1);
    }
   
    // Return the final result
    return res;
}
 
// Driver code
public static void Main(String[] args)
{
    string s = "001101";
    int count = minimumDeletions(s);
     
    Console.WriteLine(count);
}
}
 
// This code is contributed by susmitakundugoaldanga.

Javascript




<script>
 
// JavaScript program for the above approach
 
// Function to count minimum removals
// required to arrange all 0s before 1s
function minimumDeletions(s)
{
    // Count the occurences of 0 in s
    var right_0 = 0;
    var i;
    for (i=0;i<s.length;i++){
        if(s[i]=='0')
            right_0++;
    }
    var left_1 = 0;
     
    // Size of the string
    var n = s.length;
     
    // Stores the minimum
    // number of removals required
    var res = 2147483647;
     
    // Iterate over each of the
    // characters in the string s
    for (i = 0; i < n; i++)
    {
        // If the i-th character
        // is found to be '0'
        if (s[i] == '0')
        {
            right_0 -= 1;
        }
        else
        {
            left_1 += 1;
        }
         
        // Store the minimum of res
        // and right_0 + left_1 in res
        res = Math.min(res, right_0 + left_1);
    }
   
    // Return the final result
    return res;
}
 
 
// Driver Code
    var s = "001101";
    var count = minimumDeletions(s);
    document.write(count);
 
</script>

 
 

Output: 
1

 

Time Complexity: O(|S|)
Auxiliary Space: O(1) 




My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!