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 i^th character).
• Otherwise, append the character with ASCII value maxi to the answer. Store the ASCII value of current i^th 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++

// C++ program to find the longest
// subsequence containing alternating
// vowels and consonants
#include <bits/stdc++.h>
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[0]) == 1)
        flag = 1;

    // Store the ASCII value
    int maxi = (int)str[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[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 character 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

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

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

// 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[0]) == 1)
        flag = 1;

    // Store the ASCII value
    int maxi = (int)str[0];

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

Javascript

<script>

// Javascript program to find the longest
// subsequence containing alternating
// vowels and consonants

// Function that return 1 or 0
// if the given character is
// vowel or consonant respectively
function isVowel(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
function Subsequence(str)
{

    // Store the length
    // of the string
    var n = str.length;

    // Assume first character
    // to be consonant
    var flag = 0;

    // If first character is vowel
    if (isVowel(str[0]) == 1)
        flag = 1;

    // Store the ASCII value
    var maxi = (str[0].charCodeAt(0));

    // Stores the final answer
    var ans = "";
    for(var 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, str[i].charCodeAt(0));
        }

        // Otherwise
        else
        {

            // Store the character with
            // maximum ASCII value from
            // the previous block
            ans += String.fromCharCode(maxi);

            // Store the ASCII of the
            // current character as the
            // maximum of the current block
            maxi = str[i].charCodeAt(0);

            // Switch the type of the
            // current block
            flag = (flag + 1) % 2;
        }
    }

    // Store the character with
    // maximum ASCII value
    // from the last block
    ans += String.fromCharCode(maxi);

    // Return the result
    return ans;
}

// Driver code
var str = "geeksforgeeks";
document.write(Subsequence(str));

// This code is contributed by rrrtnx.
</script>

Output

gesores

Time Complexity: O(N)
Auxiliary Space: O(N), where N is the length of the given string.