String Subsequence and Substring in Python

Subsequence and Substring both are parts of the given String with some differences between them. Both of them are made using the characters in the given String only. The difference between them is that the Substring is the contiguous part of the string and the Subsequence is the non-contiguous part of the string . Although Subsequence is a non-contiguous part but it preserves the order of characters as in the original string. In this article, we will learn about the Substring and Subsequence of the given String in detail.

Substring of a String

A substring of the given string is the contiguous part of the original String. A substring can start at any index of the String and can end at any index. The only condition for the part of the String to be a Substring is that it should be the contiguous part of the String. Note - A string itself is also the Substring of the given String.

Example:

Input: "abc"
Output: "a", "b", "c", "ab", "bc", "abc" .
Explanation: The strings given in the output are the contiguous parts of the given String.

Input: "ac"
Output: "a", "c", "ac" .
Explanation: The strings given in the output are the contiguous parts of the given String.

Algorithm :

1. Start a while loop from first to last index of the string.
2. Take another nested for loop which will run from the index in outer loop to the end of the string.
3. At each iteration of the inner loop store the current substring which will start from the index in outer loop and end at the index in inner loop.
4. Move to the next iteration.
5. Print all the substrings.

Below is the implementation of above algorithm:

# Python program to generate all substrings of a given string

def substrings(s):
    all_substrings = []
    n = len(s)  # Length of the string

    # Set the starting index of the substring
    for i in range(n):
        # Set the ending index of the substring
        for j in range(i + 1, n + 1):
            # Append the substring s[i:j] to the list
            all_substrings.append(s[i:j])

    return all_substrings


if __name__ == "__main__":
    input_string = "abc"

    # Get all substrings
    substrings_list = substrings(input_string)

    # Print all the substrings
    print("All substrings:")
    for substring in substrings_list:
        print(substring, end = " ")

All substrings:
a ab abc b bc c 

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

Subsequence of the String

Subsequence is the non-contiguous part of the given string. Although it is non-contiguous but the order of the characters should say same as the original String. Basically Subsequence of the String can be generated by deleting some number of characters form the given String. While deleting characters we should keep in mind that we can also delete zero characters which means that the String itself is the subsequence of the given string. Also we can delete all the characters which indicated that an empty String is also Subsequence of the given String.

Example:

Input: "abc"
Output: "" , "a" , "b" , "c" , "ab" , "ac" , "bc" , "abc".
Explanation: The strings given in the output are the non- contiguous parts of the given String.

Input: "ac"
Output: "" , "a" , "c" , "ac" .
Explanation: The strings given in the output are the non- contiguous parts of the given String.

Algorithm:

As we have discussed that we can get the Subsequences by deleting any number of characters which also mean that we can take and leave any character. For every character we have two options , either we can take the character or leave it. We will use this approach to get all the Subsequences of the given String.

Step-By-Step explanation of above approach :

1. Initialize a array to store all the Subsequences .
2. Make a function , say printSubSequences.
3. The base case is if we reach at the index which is greater than of equal to size of string then we will store the current string in the array and return.
4. In first call we will include the character at the current index and then move to next index.
5. In second call we will move to next index without including character at current index in the string.
6. Print all the subsequences formed.

Below is the implementation of above algorithm:

# Python program to print all subsequences of a string


def print_subsequences(s, subseq="", index=0):
    # Function to print all subsequences of a string.

    if index == len(s):
        # Print the current subsequence
        print(subseq, end=" ")
        return

    # Include the character at the current index 
    # in the subsequence
    print_subsequences(s, subseq + s[index], index + 1)

    # Exclude the character at the current index 
    # from the subsequence
    print_subsequences(s, subseq, index + 1)


if __name__ == "__main__":
    print("All Subsequences:")
    input_string = "abc"
    print_subsequences(input_string)

All Subsequences:
abc ab ac a bc b c  

Time complexity: O(2^n) because we have two options, include or exclude
Auxiliary space: O(n)

Related articles:

• Print the Substring in Python.
• Print the Subsequences in Python