Maximum number of removals of given subsequence from a string

Last Updated : 03 Oct, 2022

Given string str, the task is to count the maximum number of possible operations that can be performed on str. An operation consists of taking a sub-sequence 'gks' from the string and removing it from the string.

Examples:

Input: str = "ggkssk"
Output: 1
Explanation: After 1st operation: str = "gsk"
No further operation can be performed.

Input: str = "kgs"
Output: 0

Approach:

Take three variables g, gk, and gks which will store the occurrence of the sub-sequences 'g', 'gk', and 'gks' respectively.
Traverse the string character by character:
If str[i] = 'g' then update g = g + 1.
If str[i] = 'k' and g > 0 then update g = g - 1 and gk = gk + 1 as previously found 'g' now contributes to the sub-sequence 'gk' along with the current 'k'.
Similarly, if str[i] = 's' and gk > 0 then update gk = gk - 1 and gks = gks + 1.
Print the value of gks in the end.

Below is the implementation of the above approach:

C++

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;

// Function to return max possible operation
// of the given type that can be performed on str
int maxOperations(string str)
{
    int i, g, gk, gks;
    i = g = gk = gks = 0;
    for (i = 0; i < str.length(); i++) {
        if (str[i] == 'g') {

            // Increment count of sub-sequence 'g'
            g++;
        }
        else if (str[i] == 'k') {

            // Increment count of sub-sequence 'gk'
            // if 'g' is available
            if (g > 0) {
                g--;
                gk++;
            }
        }
        else if (str[i] == 's') {

            // Increment count of sub-sequence 'gks'
            // if sub-sequence 'gk' appeared previously
            if (gk > 0) {
                gk--;
                gks++;
            }
        }
    }

    // Return the count of sub-sequence 'gks'
    return gks;
}

// Driver code
int main()
{
    string a = "ggkssk";
    cout << maxOperations(a);
    return 0;
}

Java

// Java implementation of the approach

class GFG
{
// Function to return max possible 
// operation of the given type that 
// can be performed on str 
static int maxOperations(String str) 
{ 
    int i, g, gk, gks; 
    i = g = gk = gks = 0; 
    for (i = 0; i < str.length(); i++) 
    { 
        if (str.charAt(i) == 'g')
        { 

            // Increment count of sub-sequence 'g' 
            g++; 
        } 
        else if (str.charAt(i) == 'k') 
        { 

            // Increment count of sub-sequence 'gk' 
            // if 'g' is available 
            if (g > 0) { 
                g--; 
                gk++; 
            } 
        } 
        else if (str.charAt(i) == 's')
        { 

            // Increment count of sub-sequence 'gks' 
            // if sub-sequence 'gk' appeared previously 
            if (gk > 0) 
            { 
                gk--; 
                gks++; 
            } 
        } 
    } 

    // Return the count of sub-sequence 'gks' 
    return gks; 
} 

// Driver code 
public static void main(String args[]) 
{ 
    String a = "ggkssk"; 
    System.out.print(maxOperations(a));
} 
}

// This code is contributed 
// by Akanksha Rai

Python 3

# Python 3 implementation of the approach

# Function to return max possible operation
# of the given type that can be performed 
# on str
def maxOperations( str):

    i, g, gk, gks = 0, 0, 0, 0
    for i in range(len(str)) :
        if (str[i] == 'g') :

            # Increment count of sub-sequence 'g'
            g += 1
        
        elif (str[i] == 'k') :

            # Increment count of sub-sequence 
            # 'gk', if 'g' is available
            if (g > 0) :
                g -= 1
                gk += 1
            
        elif (str[i] == 's') :

            # Increment count of sub-sequence 'gks'
            # if sub-sequence 'gk' appeared previously
            if (gk > 0) :
                gk -= 1
                gks += 1

    # Return the count of sub-sequence 'gks'
    return gks

# Driver code
if __name__ == "__main__":
    
    a = "ggkssk"
    print(maxOperations(a))

# This code is contributed by ita_c

// C# implementation of the approach 
using System ;

public class GFG{
    // Function to return max possible operation 
    // of the given type that can be performed on str 
    static int maxOperations(string str) 
    { 
        int i, g, gk, gks; 
        i = g = gk = gks = 0; 
        for (i = 0; i < str.Length; i++) { 
            if (str[i] == 'g') { 
    
                // Increment count of sub-sequence 'g' 
                g++; 
            } 
            else if (str[i] == 'k') { 
    
                // Increment count of sub-sequence 'gk' 
                // if 'g' is available 
                if (g > 0) { 
                    g--; 
                    gk++; 
                } 
            } 
            else if (str[i] == 's') { 
    
                // Increment count of sub-sequence 'gks' 
                // if sub-sequence 'gk' appeared previously 
                if (gk > 0) { 
                    gk--; 
                    gks++; 
                } 
            } 
        } 
    
        // Return the count of sub-sequence 'gks' 
        return gks; 
    } 
    
    // Driver code 
    public static void Main() 
    { 
        string a = "ggkssk"; 
        Console.WriteLine(maxOperations(a)) ;
    
    } 
    
}

PHP

<?php
// PHP implementation of the approach

// Function to return max possible operation
// of the given type that can be performed on str
function maxOperations($str)
{
    $i = $g = $gk = $gks = 0;
    for ($i = 0; $i < strlen($str); $i++)
    {
        if ($str[$i] == 'g')
        {

            // Increment count of sub-sequence 'g'
            $g++;
        }
        else if ($str[$i] == 'k')
        {

            // Increment count of sub-sequence 'gk'
            // if 'g' is available
            if ($g > 0) 
            {
                $g--;
                $gk++;
            }
        }
        else if ($str[$i] == 's')
        {

            // Increment count of sub-sequence 'gks'
            // if sub-sequence 'gk' appeared previously
            if ($gk > 0)
            {
                $gk--;
                $gks++;
            }
        }
    }

    // Return the count of sub-sequence 'gks'
    return $gks;
}

// Driver code
$a = "ggkssk";
echo maxOperations($a);

// This code is contributed
// by Akanksha Rai
?>

JavaScript

<script>

// Javascript implementation of the approach

// Function to return max possible 
// operation of the given type that 
// can be performed on str 
function maxOperations(str)
{
    let i, g, gk, gks; 
    i = g = gk = gks = 0; 
    for (i = 0; i < str.length; i++) 
    { 
        if (str[i] == 'g')
        { 
  
            // Increment count of sub-sequence 'g' 
            g++; 
        } 
        else if (str[i] == 'k') 
        { 
  
            // Increment count of sub-sequence 'gk' 
            // if 'g' is available 
            if (g > 0) { 
                g--; 
                gk++; 
            } 
        } 
        else if (str[i] == 's')
        { 
  
            // Increment count of sub-sequence 'gks' 
            // if sub-sequence 'gk' appeared previously 
            if (gk > 0) 
            { 
                gk--; 
                gks++; 
            } 
        } 
    } 
  
    // Return the count of sub-sequence 'gks' 
    return gks; 
}

// Driver code 
let a = "ggkssk"; 
document.write(maxOperations(a));


// This code is contributed by avanitrachhadiya2155
</script>

Output

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

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

sahilshelangia

Improve

Article Tags :

Practice Tags :

Maximum number of removals of given subsequence from a string

Similar Reads

Thank You!

What kind of Experience do you want to share?