Skip to content
Related Articles

Related Articles

Subsequences of given string consisting of non-repeating characters

View Discussion
Improve Article
Save Article
  • Last Updated : 29 Jan, 2022

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 <bits/stdc++.h>
using namespace std;
 
// Function to find all the subsequences of
// the string with non-repeating characters
void FindSub(set<string>& 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<string> 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<String> sub,
                               HashSet<Character> 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<String> sub = new HashSet<>();
 
        // Stores subsequence with
        // non-repeating characters
        HashSet<Character> 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 string with non-repeating characters
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 string with non-repeating characters
def printSubwithUniquech1ar(str1, N):
   
    # Stores all possible subsequences
    # with non-repeating characters
    sub = set()
 
    # Stores subsequence with
    # non-repeating characters
    ch1 = set()
    FindSub(sub, ch1, str1, "", 0)
 
    # Traverse all possible subsequences
    # containing non-repeating characters
    temp = []
    for substring in sub:
      temp.append(substring)
    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<String> 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<String> sub = new HashSet<String>();
 
        // 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



<script>
 
// JavaScript program to implement
// the above approach
 
// Stores all possible subsequences
// with non-repeating characters
var sub = new Set();
 
// Stores subsequence with
// non-repeating characters
var ch = new Set();
 
 
// Function to find all the subsequences of
// the string with non-repeating characters
function FindSub(str, res, i)
{
 
    // Base case
    if (i == str.length) {
 
        // Insert current subsequence
        sub.add(res.join(""));
        return;
    }
 
    // If str[i] is not present
    // in the current subsequence
    if (!ch.has(str[i])) {
 
        // Insert str[i] into the set
        ch.add(str[i]);
 
        // Insert str[i] into the
        // current subsequence
        res.push(str[i]);
        FindSub(str, res, i + 1);
        res.pop()
 
        // Remove str[i] from the set
        ch.delete(str[i]);
    }
 
    // Not including str[i] from
    // the current subsequence
    FindSub(str, res, i + 1);
}
 
// Utility function to print all subsequences
// of string with non-repeating characters
function printSubwithUniqueChar(str, N)
{
 
    FindSub(str, [], 0);
     
    var tmp = [...sub].sort();
 
    // Traverse all possible subsequences
    // containing non-repeating characters
    tmp.forEach(subString => {
        // Print subsequence
        document.write( subString + " ");
    });
}
 
// Driver Code
var str = "abac";
var N = str.length;
printSubwithUniqueChar(str, N);
 
</script>
Output: 
a ab abc ac b ba bac bc c
 
Time complexity: O(N * log(N) * 2N) 
Auxiliary Space O(N * 2N)

My Personal Notes
arrow_drop_up
Previous
Check if end of a sorted Array can be reached by repeated jumps of one more, one less or same number of indices as previous jump
Next

Minimum and maximum number of digits required to be removed to make a given number divisible by 3
Recommended Articles
Page :
Subsequences generated by including characters or ASCII value of characters of given string
02, Dec 20
Make all array elements equal to 0 by replacing minimum subsequences consisting of equal elements
13, Jan 21
Count of subsequences consisting of the same element
21, Jul 20
Split an array into equal length subsequences consisting of equal elements only
13, Jan 21
Generate a string consisting of characters 'a' and 'b' that satisfy the given conditions
08, Feb 19
Lexicographically largest string possible consisting of at most K consecutive similar characters
16, Nov 20
Count number of substrings of a string consisting of same characters
17, Sep 19
Modify a Binary String by flipping characters such that any pair of indices consisting of 1s are neither co-prime nor divisible by each other
02, Mar 21
Length of the smallest sub-string consisting of maximum distinct characters
30, Aug 17
Minimum removal of subsequences of distinct consecutive characters required to empty a given string
24, Nov 20
Modify characters of a string by adding integer values of same-indexed characters from another given string
01, Mar 21
Maximum count of sub-strings of length K consisting of same characters
31, Jan 19
Check if subsequences formed by given characters are same for Q queries
10, May 22
Smallest String consisting of a String S exactly K times as a Substring
12, Aug 20
Construct a string that has exactly K subsequences from given string
10, Jul 20
Divide given numeric string into at most two increasing subsequences which form an increasing string upon concatenation
03, Sep 21
Count subsequences 01 in string generated by concatenation of given numeric string K times
01, Oct 21
Check if a string can be made palindromic by swapping pairs of characters from indices having unequal characters in a Binary String
31, Mar 21
Longest Common Subsequence (LCS) by repeatedly swapping characters of a string with characters of another string
22, Mar 21
Find unique substrings consisting of only vowels from given String
27, Dec 21
Modify string by replacing all occurrences of given characters by specified replacing characters
14, Apr 21
Minimum characters to be replaced in given String to make all characters same
13, Jan 22
Check if a string can be obtained by appending subsequences of another string
27, Oct 20
Check if string S2 can be obtained by appending subsequences of string S1
03, Nov 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
saikumarkudikala
@saikumarkudikala
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!