Skip to content
Related Articles

Related Articles

Maximum count of “010..” subsequences that can be removed from given Binary String

View Discussion
Improve Article
Save Article
  • Last Updated : 15 Nov, 2021
View Discussion
Improve Article
Save Article

Given a binary string S consisting of size N, the task is to find the maximum number of binary subsequences of the form “010..” of length at least 2 that can be removed from the given string S.

Examples:

Input: S = “110011010”
Output: 3
Explanation:
Following are the subsequence removed:
Operation 1: Choose the subsequence as “01” of indices {2, 4}, and deleting it modifies the string S = “1101010”.
Operation 2: Choose the subsequence as “01” of indices {2, 3}, and deleting it modifies the string S = “11010”.
Operation 3: Choose the subsequence as “01” of indices {2, 3}, and deleting it modifies the string S = “110”.
From the above observations, the maximum number of times subsequence is removed is 3.

Input: S = “00111110011”
Output: 4

Approach: The given problem can be solved by removing the subsequence of type “01” every time to maximize the number of subsequences removed. Therefore, this can be maintained by keeping a variable that stores the count of the number of characters 0. Follow the steps below to solve the problem:

  • Initialize a variable, say cnt as 0 to store the count of the number of 0s that have occurred in the string.
  • Initialize variable, say ans as 0 to count the total number of removal operations performed.
  • Traverse the string, S using the variable i and perform the following steps:
    • If the value of S[i] is X then increment the value of cnt by 1.
    • Otherwise, if the value of cnt is greater than 0, then decrement the value of cnt and increment the value of ans by 1.
  • After completing the above steps, print the value of ans as the result.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
 
#include <iostream>
using namespace std;
 
// Function to count the maximum number
// of operations performed on the string
void countOperations(string S)
{
    // Size of the string
    int n = S.length();
 
    // Stores the maximum number of
    // operations performed
    int ans = 0;
 
    // Stores the count of 'X' occurred
    // so far
    int cnt = 0;
 
    // Traverse the string
    for (int i = 0; i < n; i++) {
 
        // Check if current char
        // is 'X'
        if (S[i] == '0') {
            cnt++;
        }
        else {
 
            // Check if the value of
            // cnt is greater than 0
            if (cnt > 0) {
 
                // Decrement the value
                // of cnt
                cnt--;
 
                // Increment the value
                // of ans
                ans++;
            }
        }
    }
 
    // Print the value of ans
    cout << ans;
}
 
// Driver Code
int main()
{
    string S = "110011010";
    countOperations(S);
 
    return 0;
}

Java




// Java program for the above approach
import java.io.*;
class GFG
{
   
    // Function to count the maximum number
    // of operations performed on the string
    public static void countOperations(String S)
    {
       
        // Size of the string
        int n = S.length();
     
        // Stores the maximum number of
        // operations performed
        int ans = 0;
     
        // Stores the count of 'X' occurred
        // so far
        int cnt = 0;
     
        // Traverse the string
        for (int i = 0; i < n; i++) {
     
            // Check if current char
            // is 'X'
            if (S.charAt(i) == '0') {
                cnt++;
            }
            else {
     
                // Check if the value of
                // cnt is greater than 0
                if (cnt > 0) {
     
                    // Decrement the value
                    // of cnt
                    cnt--;
     
                    // Increment the value
                    // of ans
                    ans++;
                }
            }
        }
     
        // Print the value of ans
        System.out.println(ans);
    }
   
    // Driver code
    public static void main (String[] args)
    {
        String S = "110011010";
        countOperations(S);
    }
}
 
// This code is contributed by Manu Pathria

Python3




# Python program for the above approach
 
# Function to count the maximum number
# of operations performed on the string
def countOperations(S):
    # Size of the string
    n = len(S)
 
    # Stores the maximum number of
    # operations performed
    ans = 0
 
    # Stores the count of 'X' occurred
    # so far
    cnt = 0
 
    # Traverse the string
    for i in range(n):
 
        # Check if current char
        # is 'X'
        if (S[i] == '0'):
            cnt+=1
        else:
            # Check if the value of
            # cnt is greater than 0
            if (cnt > 0):
 
                # Decrement the value
                # of cnt
                cnt-=1
 
                # Increment the value
                # of ans
                ans+=1
 
    # Print value of ans
    print (ans)
 
# Driver Code
if __name__ == '__main__':
    S = "110011010"
    countOperations(S)
 
# This code is contributed by mohit kumar 29.

C#




// C# program for the above approach
using System;
class GFG
{
   
    // Function to count the maximum number
    // of operations performed on the string
    public static void countOperations(string S)
    {
       
        // Size of the string
        int n = S.Length;
     
        // Stores the maximum number of
        // operations performed
        int ans = 0;
     
        // Stores the count of 'X' occurred
        // so far
        int cnt = 0;
     
        // Traverse the string
        for (int i = 0; i < n; i++) {
     
            // Check if current char
            // is 'X'
            if (S[i] == '0') {
                cnt++;
            }
            else {
     
                // Check if the value of
                // cnt is greater than 0
                if (cnt > 0) {
     
                    // Decrement the value
                    // of cnt
                    cnt--;
     
                    // Increment the value
                    // of ans
                    ans++;
                }
            }
        }
     
        // Print the value of ans
        Console.Write(ans);
    }
   
    // Driver code
    public static void Main (string[] args)
    {
        string S = "110011010";
        countOperations(S);
    }
}
 
// This code is contributed by ukasp.

Javascript




<script>
  
        // JavaScript Program for the above approach
 
        // Function to count the maximum number
        // of operations performed on the string
        function countOperations(S) {
            // Size of the string
            let n = S.length;
 
            // Stores the maximum number of
            // operations performed
            let ans = 0;
 
            // Stores the count of 'X' occurred
            // so far
            let cnt = 0;
 
            // Traverse the string
            for (let i = 0; i < n; i++) {
 
                // Check if current char
                // is 'X'
                if (S[i] == '0') {
                    cnt++;
                }
                else {
 
                    // Check if the value of
                    // cnt is greater than 0
                    if (cnt > 0) {
 
                        // Decrement the value
                        // of cnt
                        cnt--;
 
                        // Increment the value
                        // of ans
                        ans++;
                    }
                }
            }
 
            // Print the value of ans
            document.write(ans);
        }
 
        // Driver Code
 
        let S = "110011010";
        countOperations(S);
 
 
    // This code is contributed by Potta Lokesh
     
</script>

Output: 

3

 

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


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!