# Print all Subsequences of String which Start with Vowel and End with Consonant.

Given a string return all possible subsequences which start with a vowel and end with a consonant. A String is a subsequence of a given String, that is generated by deleting some character of a given string without changing its order.

Examples:

`Input : 'abc'Output : ab, ac, abcInput : 'aab'Output : ab, aab`

Question Source: Yatra.com Interview Experience | Set 7

## BRUTE METHOD USING BIT MANIPULATION:

Intuition:

1. Declare a TreeSet<String> to store all the subsequences of string s.
2. we pass the string s to a function where the subsequences are calculated.
3. Then we check if first, the character of the string is a vowel and the last character is consonant or not.
4. If so, then we add it to the ans list.
5. At last, return the list.

Implementation:

## C++

 `// C++ Program to generate all the subsequence` `// starting with vowel and ending with consonant.` `#include ` `using` `namespace` `std;`   `set st;`   `// Function to find all the subsequences of a string` `void` `findSubsequences(string s) {` `  ``int` `n = s.length();` `  ``for` `(``int` `num = 0; num < (1 << n); num++) {` `    ``string sub = ``""``;` `    ``for` `(``int` `i = 0; i < n; i++) {` `      ``if` `((num & (1 << i)) != 0) {` `        ``sub += s[i];` `      ``}` `    ``}` `    ``if` `(sub.length() > 0) {` `      ``st.insert(sub);` `    ``}` `  ``}` `}`   `// Check if char c is vowel or not` `bool` `isVowel(``char` `c) {` `  ``return` `(c == ``'a'` `|| c == ``'e'` `|| c == ``'i'` `|| c == ``'o'` `          ``|| c == ``'u'``);` `}`   `// Check if char c is consonant or not` `bool` `isConsonant(``char` `c) {` `  ``return` `!(c == ``'a'` `|| c == ``'e'` `|| c == ``'i'` `           ``|| c == ``'o'` `|| c == ``'u'``);` `}`   `// Function to find all the subsequences starting with vowel and ending with consonant` `set allPossibleSubsequences(string s) {` `  ``findSubsequences(s);` `  ``set ans;` `  ``for` `(string i : st) {` `    ``if` `(isVowel(i[0]) && isConsonant(i[i.length() - 1])) {` `      ``ans.insert(i);` `    ``}` `  ``}` `  ``st.clear();` `  ``return` `ans;` `}`   `// Driver code` `int` `main() {` `  ``string s = ``"xabcef"``;` `  ``set result = allPossibleSubsequences(s);` `  ``for` `(string str : result) {` `    ``cout << str << ``" "``;` `  ``}` `  ``return` `0;` `}`   `// This code is contributed by Sundaram`

## Java

 `// Java Program to generate all the subsequence` `// starting with vowel and ending with consonant.`   `import` `java.io.*;` `import` `java.util.*;`   `class` `GFG {` `    ``static` `TreeSet st = ``new` `TreeSet();`   `    ``// Function to find the subsequence` `    ``static` `void` `findsubsequences(String s)` `    ``{` `        ``int` `n = s.length();` `        ``for` `(``int` `num = ``0``; num < (``1` `<< n); num++) {` `            ``String sub = ``""``;` `            ``for` `(``int` `i = ``0``; i < n; i++) {` `                ``if` `((num & (``1` `<< i)) != ``0``) {` `                    ``sub += s.charAt(i);` `                ``}` `            ``}` `            ``if` `(sub.length() > ``0``) {` `                ``st.add(sub);` `            ``}` `        ``}` `    ``}`   `    ``// Check if char c is vowel or not` `    ``static` `boolean` `isVowel(``char` `c)` `    ``{` `        ``return` `(c == ``'a'` `|| c == ``'e'` `|| c == ``'i'` `|| c == ``'o'` `                ``|| c == ``'u'``);` `    ``}`   `    ``// Check if char c is consonant or not` `    ``static` `boolean` `isConsonant(``char` `c)` `    ``{` `        ``return` `!(c == ``'a'` `|| c == ``'e'` `|| c == ``'i'` `                 ``|| c == ``'o'` `|| c == ``'u'``);` `    ``}` `    ``static` `TreeSet allPossibleSubsequences(String s)` `    ``{` `        ``findsubsequences(s);` `        ``TreeSet ans = ``new` `TreeSet();` `        ``for` `(String i : st) {` `            ``if` `(isVowel(i.charAt(``0``))` `                ``&& isConsonant(i.charAt(i.length() - ``1``)))` `                ``ans.add(i);` `        ``}` `        ``st.clear();` `        ``return` `ans;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``String s = ``"xabcef"``;` `        ``System.out.println(allPossibleSubsequences(s));` `    ``}` `}`

## C#

 `// C# Program to generate all the subsequence` `// starting with vowel and ending with consonant.` `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG` `{` `    ``static` `SortedSet<``string``> st = ``new` `SortedSet<``string``>();`   `    ``// Function to find the subsequence` `    ``static` `void` `findsubsequences(``string` `s)` `    ``{` `        ``int` `n = s.Length;` `        ``for` `(``int` `num = 0; num < (1 << n); num++)` `        ``{` `            ``string` `sub = ``""``;` `            ``for` `(``int` `i = 0; i < n; i++)` `            ``{` `                ``if` `((num & (1 << i)) != 0)` `                ``{` `                    ``sub += s[i];` `                ``}` `            ``}` `            ``if` `(sub.Length > 0)` `            ``{` `                ``st.Add(sub);` `            ``}` `        ``}` `    ``}`   `    ``// Check if char c is vowel or not` `    ``static` `bool` `isVowel(``char` `c)` `    ``{` `        ``return` `(c == ``'a'` `|| c == ``'e'` `|| c == ``'i'` `|| c == ``'o'` `|| c == ``'u'``);` `    ``}`   `    ``// Check if char c is consonant or not` `    ``static` `bool` `isConsonant(``char` `c)` `    ``{` `        ``return` `!(c == ``'a'` `|| c == ``'e'` `|| c == ``'i'` `|| c == ``'o'` `|| c == ``'u'``);` `    ``}`   `    ``static` `SortedSet<``string``> allPossibleSubsequences(``string` `s)` `    ``{` `        ``findsubsequences(s);` `        ``SortedSet<``string``> ans = ``new` `SortedSet<``string``>();` `        ``foreach` `(``string` `i ``in` `st)` `        ``{` `            ``if` `(isVowel(i[0]) && isConsonant(i[i.Length - 1]))` `                ``ans.Add(i);` `        ``}` `        ``st.Clear();` `        ``return` `ans;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `Main(``string``[] args)` `    ``{` `        ``string` `s = ``"xabcef"``;` `        ``SortedSet<``string``> result = allPossibleSubsequences(s);` `        ``foreach` `(``string` `str ``in` `result)` `        ``{` `            ``Console.Write(str+``" "``);` `        ``}` `    ``}` `}`   `// This code is contributed by Utkarsh Kumar`

Output

```[ab, abc, abcef, abcf, abef, abf, ac, acef, acf, aef, af, ef]

```

Time Complexity: O(n* logn* (2^n))

Space Complexity: O(N) since we are using Tree Set.

Explanation of the Algorithm:

• Step 1: Iterate over the entire String
• Step 2: check if the ith character for vowel
• Step 3: If true iterate the string from the end,
if false move to next iteration
• Step 4: check the jth character for consonant
if false move to next iteration
if true perform the following
• Step 5: Add the substring starting at index i and ending at index j to the hashset.
• Step 6: Iterate over the substring drop each character  and recur to generate all its subString

## C++

 `// C++ program to generate all the subse-quence` `// starting with vowel and ending with consonant.` `#include ` `using` `namespace` `std;`   `// Set to store all the subsequences` `set st;`   `// Utility method to check vowel` `bool` `isVowel(``char` `c)` `{` `    ``return` `(c == ``'a'` `or c == ``'e'` `or` `            ``c == ``'i'` `or c == ``'o'` `or` `            ``c == ``'u'``);` `}`   `// Utility method to check consonant` `bool` `isConsonant(``char` `c)` `{` `    ``return` `!isVowel(c);` `}`   `// It computes all the possible substring that` `// starts with vowel and end with consonant` `void` `subsequence(string str)` `{` `    ``// iterate over the entire string` `    ``for` `(``int` `i = 0; i < str.length(); i++)` `    ``{` `        ``// test ith character for vowel` `        ``if` `(isVowel(str[i]))` `        ``{` `            ``// if the ith character is vowel` `            ``// iterate from end of the string` `            ``// and check for consonant.` `            ``for` `(``int` `j = str.length() - 1; j >= i; j--)` `            ``{` `                ``// test jth character for consonant.` `                ``if` `(isConsonant(str[j]))` `                ``{` `                    ``// once we get a consonant add it to` `                    ``// the hashset` `                    ``string str_sub = str.substr(i, j + 1);` `                    ``st.insert(str_sub);`   `                    ``// drop each character of the substring` `                    ``// and recur to generate all subsequence` `                    ``// of the substring` `                    ``for` `(``int` `k = 1; k < str_sub.length() - 1; k++)` `                    ``{` `                        ``string sb = str_sub;` `                        ``sb.erase(sb.begin() + k);` `                        ``subsequence(sb);` `                    ``}` `                ``}` `            ``}` `        ``}` `    ``}` `}`   `// Driver Code` `int` `main()` `{` `    ``string s = ``"xabcef"``;` `    ``subsequence(s);`   `    ``for` `(``auto` `i : st)` `        ``cout << i << ``" "``;` `    ``cout << endl;`   `    ``return` `0;` `}`   `// This code is contributed by` `// sanjeev2552`

## Java

 `// Java Program to generate all the subsequence` `// starting with vowel and ending with consonant.` `import` `java.util.HashSet;`   `public` `class` `Subsequence {`   `    ``// Set to store all the subsequences` `    ``static` `HashSet st = ``new` `HashSet<>();`   `    ``// It computes all the possible substring that` `    ``// starts with vowel and end with consonant` `    ``static` `void` `subsequence(String str)` `    ``{` `        ``// iterate over the entire string` `        ``for` `(``int` `i = ``0``; i < str.length(); i++) {` `        `  `            ``// test ith character for vowel` `            ``if` `(isVowel(str.charAt(i))) {` `        `  `                ``// if the ith character is vowel` `                ``// iterate from end of the string` `                ``// and check for consonant.` `                ``for` `(``int` `j = (str.length() - ``1``); j >= i; j--) {` `                    `  `                    ``// test jth character for consonant.` `                    ``if` `(isConsonant(str.charAt((j)))) {` `                    `  `                        ``// once we get a consonant add it to ` `                        ``// the hashset` `                        ``String str_sub = str.substring(i, j + ``1``);` `                        ``st.add(str_sub);`   `                        ``// drop each character of the substring` `                        ``// and recur to generate all subsequence` `                        ``// of the substring` `                        ``for` `(``int` `k = ``1``; k < str_sub.length() - ``1``; k++) {` `                            ``StringBuffer sb = ``new` `StringBuffer(str_sub);` `                            ``sb.deleteCharAt(k);` `                            ``subsequence(sb.toString());` `                        ``}` `                    ``}` `                ``}` `            ``}` `        ``}` `    ``}`   `    ``// Utility method to check vowel` `    ``static` `boolean` `isVowel(``char` `c)` `    ``{` `        ``return` `(c == ``'a'` `|| c == ``'e'` `|| c == ``'i'` `|| c == ``'o'` `                                              ``|| c == ``'u'``);` `    ``}`   `    ``// Utility method to check consonant` `    ``static` `boolean` `isConsonant(``char` `c)` `    ``{` `        ``return` `!isVowel(c);` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``String s = ``"xabcef"``;` `        ``subsequence(s);` `        ``System.out.println(st);` `    ``}` `}`

## Python3

 `# Python program to generate all the subse-quence` `# starting with vowel and ending with consonant.`   `# Set to store all the subsequences` `st ``=` `set``()`   `# Utility method to check vowel` `def` `isVowel(c):`   `    ``return` `(c ``=``=` `'a'` `or` `c ``=``=` `'e'` `or` `            ``c ``=``=` `'i'` `or` `c ``=``=` `'o'` `or` `            ``c ``=``=` `'u'``)`   `# Utility method to check consonant` `def` `isConsonant(c):`   `    ``return` `not` `isVowel(c)`   `# It computes all the possible substring that` `# starts with vowel and end with consonant` `def` `subsequence(``Str``):`   `    ``global` `st`   `    ``# iterate over the entire string` `    ``for` `i ``in` `range``(``len``(``Str``)):`   `        ``# test ith character for vowel` `        ``if` `(isVowel(``Str``[i])):` `        `  `            ``# if the ith character is vowel` `            ``# iterate from end of the string` `            ``# and check for consonant.` `            ``for` `j ``in` `range``(``len``(``Str``) ``-` `1``,i``-``1``,``-``1``):` `            `  `                ``# test jth character for consonant.` `                ``if` `(isConsonant(``Str``[j])):` `                `  `                    ``# once we get a consonant add it to` `                    ``# the hashset` `                    ``str_sub ``=` `Str``[i : i ``+` `j ``+` `1``]` `                    ``st.add(str_sub)`   `                    ``# drop each character of the substring` `                    ``# and recur to generate all subsequence` `                    ``# of the substring` `                    ``for` `k ``in` `range``(``1``,``len``(str_sub)):` `                    `  `                        ``sb ``=` `str_sub` `                        ``sb ``=` `sb.replace(sb[k],"")` `                        ``subsequence(sb)`   `# Driver Code` `s ``=` `"xabcef"` `subsequence(s)`   `for` `i ``in` `st:` `    ``print``(i,end ``=` `" "``)` `print``()`   `# This code is contributed by shinjanpatra`

## C#

 `// C# Program to generate all the subsequence` `// starting with vowel and ending with consonant.` `using` `System;` `using` `System.Collections.Generic;` `using` `System.Text;`   `class` `Subsequence` `{`   `    ``// Set to store all the subsequences` `    ``static` `HashSet st = ``new` `HashSet();`   `    ``// It computes all the possible substring that` `    ``// starts with vowel and end with consonant` `    ``static` `void` `subsequence(String str)` `    ``{` `        ``// iterate over the entire string` `        ``for` `(``int` `i = 0; i < str.Length; i++)` `        ``{` `        `  `            ``// test ith character for vowel` `            ``if` `(isVowel(str[i]))` `            ``{` `        `  `                ``// if the ith character is vowel` `                ``// iterate from end of the string` `                ``// and check for consonant.` `                ``for` `(``int` `j = (str.Length - 1); j >= i; j--)` `                ``{` `                    `  `                    ``// test jth character for consonant.` `                    ``if` `(isConsonant(str[j]))` `                    ``{` `                    `  `                        ``// once we get a consonant add it to ` `                        ``// the hashset` `                        ``String str_sub = str.Substring(i, j -i + 1);` `                        ``st.Add(str_sub);`   `                        ``// drop each character of the substring` `                        ``// and recur to generate all subsequence` `                        ``// of the substring` `                        ``for` `(``int` `k = 1; k < str_sub.Length - 1; k++)` `                        ``{` `                            ``StringBuilder sb = ``new` `StringBuilder(str_sub);` `                            ``sb.Remove(k, 1);` `                            ``subsequence(sb.ToString());` `                        ``}` `                    ``}` `                ``}` `            ``}` `        ``}` `    ``}`   `    ``// Utility method to check vowel` `    ``static` `bool` `isVowel(``char` `c)` `    ``{` `        ``return` `(c == ``'a'` `|| c == ``'e'` `|| c == ``'i'` `|| c == ``'o'` `                                            ``|| c == ``'u'``);` `    ``}`   `    ``// Utility method to check consonant` `    ``static` `bool` `isConsonant(``char` `c)` `    ``{` `        ``return` `!isVowel(c);` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `Main(String[] args)` `    ``{` `        ``String s = ``"xabcef"``;` `        ``subsequence(s);` `        ``foreach``(String str ``in` `st)` `            ``Console.Write(str + ``", "``);` `    ``}` `}`   `// This code is contributed by Rajput-Ji`

## Javascript

 ``

Output

```ab abc abce abcef abcf abef abf ac acef acf aef af ef

```

Time complexity: O(2^n) where n is the length of the string
Auxiliary space: O(2^n)

If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!