Maximum number of removals of given subsequence from a string

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:

1. Take three variables g, gk, and gks which will store the occurrence of the sub-sequences ‘g’, ‘gk’, and ‘gks’ respectively.
2. 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.
3. 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#

// 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

1

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