# Longest subsequence consisting of alternate vowels and consonants

Given a non-empty string S, the task is to print the longest subsequence from the string S which contains alternating vowels and consonants.
Note: If multiple such subsequences exist having the same length, print the subsequence having the maximum sum of ASCII values of its characters.
Examples:

Input: S = “geeksforgeeks”
Output: gesores
Explanation: “gekorek”, “gekores”, “gekogek”, “gekoges”, “gesorek”, “gesores”, “gesogek”, “gesoges”, “geforek”, “gefores”, “gefogek” and “gefoges” are the possible longest subsequences with alternating consonants and vowels. “gesores” is the subsequence with maximum sum of ASCII values of characters and hence it is the solution.

Input: S = “ababababab”
Output: ababababab
Explanation: “ababababab” is the longest possible subsequence containing alternating vowels and consonants.

Approach:
Follow the steps below to solve the problem:

• Store the ASCII value of the first character of S as the maximum of the current block (maxi) and type of the character in flag. If the character is consonant, set flag as 0 and 1 otherwise.
• Traverse through the rest of the string.
• For every character, check if it belongs to the same block as that of the previous character or not.
• If it belongs to same block, update maxi to max(maxi, ASCII value of ith character).
• Otherwise, append the character with ASCII value maxi to the answer. Store the ASCII value of current ith character as maxi. Update flag to (flag + 1)%2 to denote the type of the current character.
• After traversal of entire string, add the character with ASCII value maxi to the answer. Print the final string representing the subsequence.

Below code is the implementation of the above approach:

 `// C++ program to find the longest` `// subsequence containing alternating` `// vowels and consonants` `#include ` `using` `namespace` `std;`   `// Function that return 1 or 0` `// if the given character is` `// vowel or consonant respectively` `int` `isVowel(``char` `c)` `{` `    `  `    ``// Returns 1 if c is vowel` `    ``if` `(c == ``'a'` `|| c == ``'e'` `||` `        ``c == ``'i'` `|| c == ``'o'` `||` `        ``c == ``'u'``)` `        ``return` `1;`   `    ``// Returns 0 if` `    ``// c is consonant` `    ``return` `0;` `}`   `// Function to find the longest` `// subsequence containing` `// alternate vowels and` `// consonants` `string Subsequence(string str)` `{` `    `  `    ``// Store the length` `    ``// of the string` `    ``int` `n = str.length();`   `    ``// Assume first character` `    ``// to be consonant` `    ``int` `flag = 0;` `    `  `    ``// If first character is vowel` `    ``if` `(isVowel(str) == 1)` `        ``flag = 1;` `        `  `    ``// Store the ASCII value` `    ``int` `maxi = (``int``)str;` `    `  `    ``// Stores the final answer` `    ``string ans = ``""``;` `    ``for``(``int` `i = 1; i < n; i++) ` `    ``{` `        `  `        ``// If the current character belongs` `        ``// to same category (Vowel / Consonant)` `        ``// as the previous character` `        ``if` `(isVowel(str[i]) == flag)` `        ``{` `            `  `            ``// Store the maximum ASCII value` `            ``maxi = max(maxi, (``int``)str[i]);` `        ``}` `        `  `        ``// Otherwise` `        ``else` `        ``{` `            `  `            ``// Store the character with` `            ``// maximum ASCII value from` `            ``// the previous block` `            ``ans += (``char``)(maxi);` `            `  `            ``// Store the ASCII of the` `            ``// current character as the` `            ``// maximum of the current block` `            ``maxi = (``int``)str[i];` `            `  `            ``// Switch the type of the` `            ``// current block` `            ``flag = (flag + 1) % 2;` `        ``}` `    ``}` `    `  `    ``// Store the chracter with` `    ``// maximum ASCII value` `    ``// from the last block` `    ``ans += (``char``)(maxi);`   `    ``// Return the result` `    ``return` `ans;` `}`   `// Driver code` `int` `main()` `{` `    ``string str = ``"geeksforgeeks"``;` `    `  `    ``cout << (Subsequence(str));` `}`   `// This code is contributed by chitranayal`

 `// Java program to find the longest ` `// subsequence containing alternating ` `// vowels and consonants ` `import` `java.util.*; ` `import` `java.lang.*; ` `import` `java.io.*; ` `import` `java.math.*; `   `class` `GFG { `   `    ``// Function that return 1 or 0 ` `    ``// if the given character is ` `    ``// vowel or consonant respectively ` `    ``static` `int` `isVowel(``char` `c) ` `    ``{ ` `        ``// Returns 1 if c is vowel ` `        ``if` `(c == ``'a'` `|| c == ``'e'` `            ``|| c == ``'i'` `|| c == ``'o'` `            ``|| c == ``'u'``) ` `            ``return` `1``; `   `        ``// Returns 0 if ` `        ``// c is consonant ` `        ``return` `0``; ` `    ``} `   `    ``// Function to find the longest ` `    ``// subsequence containing ` `    ``// alternate vowels and ` `    ``// consonants ` `    ``static` `String Subsequence(String str) ` `    ``{ ` `        ``// Store the length ` `        ``// of the string ` `        ``int` `n = str.length(); `   `        ``// Assume first character ` `        ``// to be consonant ` `        ``int` `flag = ``0``; ` `        ``// If first character is vowel ` `        ``if` `(isVowel(str.charAt(``0``)) == ``1``) ` `            ``flag = ``1``; ` `        ``// Store the ASCII value ` `        ``int` `maxi = (``int``)str.charAt(``0``); ` `        ``// Stores the final answer ` `        ``String ans = ``""``; ` `        ``for` `(``int` `i = ``1``; i < n; i++) { ` `            ``// If the current character belongs ` `            ``// to same category (Vowel / Consonant) ` `            ``// as the previous character ` `            ``if` `(isVowel(str.charAt(i)) == flag) { ` `                ``// Store the maximum ASCII value ` `                ``maxi = Math.max(maxi, ` `                                ``(``int``)str.charAt(i)); ` `            ``} ` `            ``// Otherwise ` `            ``else` `{ ` `                ``// Store the character with ` `                ``// maximum ASCII value from ` `                ``// the previous block ` `                ``ans += (``char``)(maxi); ` `                ``// Store the ASCII of the ` `                ``// current character as the ` `                ``// maximum of the current block ` `                ``maxi = (``int``)str.charAt(i); ` `                ``// Switch the type of the ` `                ``// current block ` `                ``flag = (flag + ``1``) % ``2``; ` `            ``} ` `        ``} ` `        ``// Store the chracter with ` `        ``// maximum ASCII value ` `        ``// from the last block ` `        ``ans += (``char``)(maxi); `   `        ``// Return the result ` `        ``return` `ans; ` `    ``} `   `    ``// Driver Program ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``String str = ``"geeksforgeeks"``; ` `        ``System.out.println(Subsequence(str)); ` `    ``} ` `} `

 `# Python3 program to find the longest` `# subsequence containing alternating` `# vowels and consonants`   `def` `isVowel(c):` `  `  `    ``# boolean function that check whether` `    ``# the given char is vowel or not` `    ``# and returns a boolean value respectively` `    ``vowels``=``[``'a'``,``'e'``,``'i'``,``'o'``,``'u'``]` `    ``if``(c ``in` `vowels):` `        ``return` `True` `    ``return` `False` `def` `Subsequence(``str``):` `  `  `    ``#string that stores the final result` `    ``ans``=``'' ` `    ``flag``=``(isVowel(``str``[``0``]))` `    `  `    ``#taking the first character ` `    ``#as the maximum ASCII valued char` `    ``maxi``=``ord``(``str``[``0``]) ` `    ``for` `i ``in` `range``(``1``,``len``(``str``)):` `      `  `        ``# If the current character belongs to ` `        ``# same category(Vowel / Consonant) as the ` `        ``# previous character` `        ``if` `(isVowel(``str``[i]) ``=``=` `flag):` `          `  `            ``# choosing a maximum ASCII valued char` `            ``maxi``=``max``(maxi,``ord``(``str``[i]))` `            `  `        ``#otherwise` `        ``else``:` `            ``ans``=``ans``+``chr``(maxi)` `            ``maxi``=``ord``(``str``[i])` `            `  `            ``#toggling the flag` `            ``flag``=``not``(flag) ` `            `  `    ``#adding the last char to the answer` `    ``ans``=``ans``+``chr``(maxi)` `    ``return` `ans` `  `  `#Driver program ` `if` `__name__ ``=``=` `"__main__"``:` `    ``input_string ``=``'geeksforgeeks'` `    ``print``(Subsequence(input_string))` `    `  `# Contributed by ` `# Nvss Maneesh Gupta`

 `// C# program to find the longest ` `// subsequence containing alternating ` `// vowels and consonants ` `using` `System; `   `class` `GFG{ `   `// Function that return 1 or 0 ` `// if the given character is ` `// vowel or consonant respectively ` `static` `int` `isVowel(``char` `c) ` `{ ` `    `  `    ``// Returns 1 if c is vowel ` `    ``if` `(c == ``'a'` `|| c == ``'e'` `|| ` `        ``c == ``'i'` `|| c == ``'o'` `|| ` `        ``c == ``'u'``) ` `        ``return` `1; `   `    ``// Returns 0 if ` `    ``// c is consonant ` `    ``return` `0; ` `} `   `// Function to find the longest ` `// subsequence containing ` `// alternate vowels and ` `// consonants ` `static` `String Subsequence(String str) ` `{ ` `    `  `    ``// Store the length ` `    ``// of the string ` `    ``int` `n = str.Length; `   `    ``// Assume first character ` `    ``// to be consonant ` `    ``int` `flag = 0; ` `    `  `    ``// If first character is vowel ` `    ``if` `(isVowel(str) == 1) ` `        ``flag = 1; ` `    `  `    ``// Store the ASCII value ` `    ``int` `maxi = (``int``)str; ` `    `  `    ``// Stores the readonly answer ` `    ``String ans = ``""``; ` `    `  `    ``for``(``int` `i = 1; i < n; i++) ` `    ``{ ` `        `  `    ``// If the current character belongs ` `    ``// to same category (Vowel / Consonant) ` `    ``// as the previous character ` `    ``if` `(isVowel(str[i]) == flag) ` `    ``{ ` `            `  `        ``// Store the maximum ASCII value ` `        ``maxi = Math.Max(maxi, (``int``)str[i]); ` `    ``} ` `        `  `    ``// Otherwise ` `    ``else` `    ``{ ` `            `  `        ``// Store the character with ` `        ``// maximum ASCII value from ` `        ``// the previous block ` `        ``ans += (``char``)(maxi); ` `            `  `        ``// Store the ASCII of the ` `        ``// current character as the ` `        ``// maximum of the current block ` `        ``maxi = (``int``)str[i]; ` `            `  `        ``// Switch the type of the ` `        ``// current block ` `        ``flag = (flag + 1) % 2; ` `    ``} ` `    ``} ` `    `  `    ``// Store the chracter with ` `    ``// maximum ASCII value ` `    ``// from the last block ` `    ``ans += (``char``)(maxi); `   `    ``// Return the result ` `    ``return` `ans; ` `} `   `// Driver code ` `public` `static` `void` `Main(String[] args) ` `{ ` `    ``String str = ``"geeksforgeeks"``; ` `    `  `    ``Console.WriteLine(Subsequence(str)); ` `} ` `} `   `// This code is contributed by 29AjayKumar `

Output
```gesores

```

Time Complexity: O(N)

Practice Tags :