Related Articles

# Subsequences of given string consisting of non-repeating characters

• Last Updated : 30 Jul, 2021

Given a string str of length N, the task is to print all possible distinct subsequences of the string str which consists of non-repeating characters only.

Examples:

Input: str = “abac”
Output: a ab abc ac b ba bac bc c
Explanation:
All possible distinct subsequences of the strings are { a, aa, aac, ab, aba, abac, abc, ac, b, ba, bac, bc, c }
Therefore, the subsequences consisting non-repeating characters only are { a, ab, abc, ac, b, ba, bac, bc, c }

Input: str = “aaa”
Output: a

Approach: The problem can be solved using Backtracking technique using the following recurrence relation:

FindSub(str, res, i) = { FindSub(str, res, i + 1), FindSub(str, res + str[i], i + 1) }
res = subsequence of the string
i = index of a character in str

Follow the steps below to solve the problem:

• Initialize a Set, say sub, to store all possible subsequences consisting of non-repeating characters.
• Initialize another Set, say ch, to check if a character is present in the subsequence or not.
• Traverse the string and print all possible subsequences consisting of non-repeating characters only using the above recurrence relation.

Below is the implementation of the above approach:

## C++

 `// C++ program to implement``// the above approach` `#include ``using` `namespace` `std;` `// Function to find all the subsequences of``// the string with non-repeating characters``void` `FindSub(set& sub, set<``char``>& ch, string str,``             ``string res, ``int` `i)``{` `    ``// Base case``    ``if` `(i == str.length()) {` `        ``// Insert current subsequence``        ``sub.insert(res);``        ``return``;``    ``}` `    ``// If str[i] is not present``    ``// in the current subsequence``    ``if` `(!ch.count(str[i])) {` `        ``// Insert str[i] into the set``        ``ch.insert(str[i]);` `        ``// Insert str[i] into the``        ``// current subsequence``        ``res.push_back(str[i]);``        ``FindSub(sub, ch, str, res, i + 1);` `        ``// Remove str[i] from``        ``// current subsequence``        ``res.pop_back();` `        ``// Remove str[i] from the set``        ``ch.erase(str[i]);``    ``}` `    ``// Not including str[i] from``    ``// the current subsequence``    ``FindSub(sub, ch, str, res, i + 1);``}` `// Utility function to print all subsequences``// of string with non-repeating characters``void` `printSubwithUniqueChar(string str, ``int` `N)``{` `    ``// Stores all possible subsequences``    ``// with non-repeating characters``    ``set sub;` `    ``// Stores subsequence with``    ``// non-repeating characters``    ``set<``char``> ch;` `    ``FindSub(sub, ch, str, ``""``, 0);` `    ``// Traverse all possible subsequences``    ``// containing non-repeating characters``    ``for` `(``auto` `subString : sub) {` `        ``// Print subsequence``        ``cout << subString << ``" "``;``    ``}``}` `// Driver Code``int` `main()``{` `    ``string str = ``"abac"``;` `    ``int` `N = str.length();` `    ``printSubwithUniqueChar(str, N);` `    ``return` `0;``}`

## Java

 `// Javs program to implement``// the above approach` `import` `java.util.*;` `class` `GFG {` `    ``// Function to find all the subsequences of``    ``// the string with non-repeating characters``    ``public` `static` `void` `FindSub(HashSet sub,``                               ``HashSet ch,``                               ``String str, String res,``                               ``int` `i)``    ``{` `        ``// Base case``        ``if` `(i == str.length()) {` `            ``// Insert current subsequence``            ``sub.add(res);``            ``return``;``        ``}` `        ``// If str[i] is not present``        ``// in the current subsequence``        ``if` `(!ch.contains(str.charAt(i))) {` `            ``// Insert str[i] into the set``            ``ch.add(str.charAt(i));` `            ``// Insert str[i] into the``            ``// current subsequence``            ``FindSub(sub, ch, str, res + str.charAt(i),``                    ``i + ``1``);` `            ``// Remove str[i] from the set``            ``ch.remove(str.charAt(i));``        ``}``        ``// Not including str[i] from``        ``// the current subsequence``        ``FindSub(sub, ch, str, res, i + ``1``);``    ``}` `    ``// Utility function to print all subsequences``    ``// of string with non-repeating characters``    ``public` `static` `void` `printSubwithUniqueChar(String str,``                                              ``int` `N)``    ``{` `        ``// Stores all possible subsequences``        ``// with non-repeating characters``        ``HashSet sub = ``new` `HashSet<>();` `        ``// Stores subsequence with``        ``// non-repeating characters``        ``HashSet ch = ``new` `HashSet<>();` `        ``FindSub(sub, ch, str, ``""``, ``0``);` `        ``// Traverse all possible subsequences``        ``// containing non-repeating characters``        ``for` `(String subString : sub) {` `            ``// Print subsequence``            ``System.out.print(subString + ``" "``);``        ``}``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String args[])``    ``{` `        ``String str = ``"abac"``;` `        ``int` `N = str.length();` `        ``printSubwithUniqueChar(str, N);``    ``}``}`

## Python3

 `# Python 3 program to implement``# the above approach1` `# Function to find all the subsequences of``# the str1ing with non-repeating ch1aracters``def` `FindSub(sub, ch1, str1, res, i):``  ` `    ``# Base case``    ``if` `(i ``=``=` `len``(str1)):``      ` `        ``# Insert current subsequence``        ``sub.add(res)``        ``return` `    ``# If str1[i] is not present``    ``# in the current subsequence``    ``if` `(str1[i] ``not` `in` `ch1):``      ` `        ``# Insert str1[i] into the set``        ``ch1.add(str1[i])` `        ``# Insert str1[i] into the``        ``# current subsequence``        ``FindSub(sub, ch1, str1, res``+``str1[i], i ``+` `1``)``        ``res ``+``=` `str1[i]``        ` `        ``# Remove str1[i] from``        ``# current subsequence``        ``res ``=` `res[``0``:``len``(res) ``-` `1``]` `        ``# Remove str1[i] from the set``        ``ch1.remove(str1[i])` `    ``# Not including str1[i] from``    ``# the current subsequence``    ``FindSub(sub, ch1, str1, res, i ``+` `1``)` `# Utility function to print all subsequences``# of str1ing with non-repeating ch1aracters``def` `printSubwithUniquech1ar(str1, N):``  ` `    ``# Stores all possible subsequences``    ``# with non-repeating ch1aracters``    ``sub ``=` `set``()` `    ``# Stores subsequence with``    ``# non-repeating ch1aracters``    ``ch1 ``=` `set``()``    ``FindSub(sub, ch1, str1, "", ``0``)` `    ``# Traverse all possible subsequences``    ``# containing non-repeating ch1aracters``    ``temp ``=` `[]``    ``for` `substr1ing ``in` `sub:``      ``temp.append(substr1ing)``    ``temp.sort(reverse ``=` `False``)``    ``for` `x ``in` `temp:``      ` `      ``# Print subsequence``      ``print``(x, end ``=` `" "``)` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``str2 ``=` `"abac"``    ``N ``=` `len``(str2)``    ``printSubwithUniquech1ar(str2, N)``    ` `    ``# This code is contributed by bgangwar59.`

## C#

 `// C# program to implement``// the above approach``using` `System;``using` `System.Collections.Generic;``public` `class` `GFG``{` `    ``// Function to find all the subsequences of``    ``// the string with non-repeating characters``    ``public` `static` `void` `FindSub(HashSet sub,``                               ``HashSet<``char``> ch,``                               ``String str, String res,``                               ``int` `i)``    ``{` `        ``// Base case``        ``if` `(i == str.Length)``        ``{` `            ``// Insert current subsequence``            ``sub.Add(res);``            ``return``;``        ``}` `        ``// If str[i] is not present``        ``// in the current subsequence``        ``if` `(!ch.Contains(str[i]))``        ``{` `            ``// Insert str[i] into the set``            ``ch.Add(str[i]);` `            ``// Insert str[i] into the``            ``// current subsequence``            ``FindSub(sub, ch, str, res + str[i],``                    ``i + 1);` `            ``// Remove str[i] from the set``            ``ch.Remove(str[i]);``        ``}``      ` `        ``// Not including str[i] from``        ``// the current subsequence``        ``FindSub(sub, ch, str, res, i + 1);``    ``}` `    ``// Utility function to print all subsequences``    ``// of string with non-repeating characters``    ``public` `static` `void` `printSubwithUniqueChar(String str,``                                              ``int` `N)``    ``{` `        ``// Stores all possible subsequences``        ``// with non-repeating characters``        ``HashSet sub = ``new` `HashSet();` `        ``// Stores subsequence with``        ``// non-repeating characters``        ``HashSet<``char``> ch = ``new` `HashSet<``char``>();``        ``FindSub(sub, ch, str, ``""``, 0);` `        ``// Traverse all possible subsequences``        ``// containing non-repeating characters``        ``foreach` `(String subString ``in` `sub)``        ``{` `            ``// Print subsequence``            ``Console.Write(subString + ``" "``);``        ``}``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main(String []args)``    ``{``        ``String str = ``"abac"``;``        ``int` `N = str.Length;``        ``printSubwithUniqueChar(str, N);``    ``}``}` `// This code contributed by shikhasingrajput`

## Javascript

 ``
Output:
`a ab abc ac b ba bac bc c`

Time complexity: O(N * log(N) * 2N
Auxiliary Space O(N * 2N)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up