Related Articles

# Maximum number of removals of given subsequence from a string

• Last Updated : 26 May, 2021

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

 ` 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

 ``
Output:
`1`

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.

My Personal Notes arrow_drop_up