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

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

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

Article Tags :

Competitive Programming

Greedy

Strings

Infosys-InfyTQ

Infosys-interview-experience

Practice Tags :