 Open in App
Not now

# 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:

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`

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

My Personal Notes arrow_drop_up