Check if one string is subsequence of other

Try it on GfG Practice

Given two strings s1 and s2, find if the first string is a Subsequence of the second string, i.e. if s1 is a subsequence of s2.  A subsequence is a sequence that can be derived from another sequence by deleting some elements without changing the order of the remaining elements.

Examples : 

Input: s1 = "AXY", s2 = "ADXCPY"
Output: true
All characters of s1 are in s2 in the same order

Input: s1 = "AXY", s2 = "YADXCP"
Output: false
All characters are present, but order is not same.

Input: s1 = "gksrek", s2 = "geeksforgeeks"
Output: true

[Approach 1] Using Recursion - O(n) Time and O(n) Space

We match last characters of the two strings s1 and s2 of lengths m and n

1. If the last characters match, we call for m-1 and n-1
2. Otherwise, we ignore the last character of s2 and therefore call for m and n-1.

Below is the Implementation of the above idea:

#include <iostream>
#include <string>
using namespace std;

bool isSubSeqRec(string& s1, string& s2, int m, int n){
    // Base Cases
    if (m == 0)
        return true;
    if (n == 0)
        return false;

    // If last characters match
    if (s1[m - 1] == s2[n - 1])
        return isSubSeqRec(s1, s2, m - 1, n - 1);

    // If last characters don't match
    return isSubSeqRec(s1, s2, m, n - 1);
}

bool isSubSeq(string& s1, string& s2){
    int m = s1.length();
    int n = s2.length();
    if (m > n) return false;
    return isSubSeqRec(s1, s2, m, n);
}

int main(){
    string s1 = "gksrek";
    string s2 = "geeksforgeeks";
    if (isSubSeq(s1, s2))
        cout << "true";
    else
        cout << "false";
    return 0;
}

#include <stdio.h>
#include <string.h>
#include <stdbool.h>

// Helper function that checks if s1 is a subsequence of s2
bool isSubSeqRec(char* s1, char* s2, int m, int n){
    // Base Cases
    if (m == 0)
        return true;
    if (n == 0)
        return false;

    // If last characters of two strings are matching
    if (s1[m - 1] == s2[n - 1])
        return isSubSeqRec(s1, s2, m - 1, n - 1);

    // If last characters are not matching
    return isSubSeqRec(s1, s2, m, n - 1);
}

// Wrapper function
bool isSubSeq(const char* s1, const char* s2){
    int m = strlen(s1);
    int n = strlen(s2);
    if (m > n) return false;
    return isSubSeqRec(s1, s2, m, n);
}

int main(){
    const char* s1 = "gksrek";
    const char* s2 = "geeksforgeeks";
    isSubSeq(s1, s2) ? printf("true\n") : printf("false\n");
    return 0;
}

import java.io.*;

class GfG {
    static boolean isSubSequence(String s1, String s2,
                                 int m, int n){
        // Base Cases
        if (m == 0)
            return true;
        if (n == 0)
            return false;

        // If last characters of two strings are matching
        if (s1.charAt(m - 1) == s2.charAt(n - 1))
            return isSubSequence(s1, s2, m - 1, n - 1);

        // If last characters are not matching
        return isSubSequence(s1, s2, m, n - 1);
    }

    public static void main(String[] args){
        String s1 = "gksrek";
        String s2 = "geeksforgeeks";
        int m = s1.length();
        int n = s2.length();
        boolean res = isSubSequence(s1, s2, m, n);
        if (res)
            System.out.println("true");
        else
            System.out.println("false");
    }
}

def isSubSequence(string1, string2, m, n):
    # Base Cases
    if m == 0:
        return True
    if n == 0:
        return False

    # If last characters of two
    # strings are matching
    if string1[m-1] == string2[n-1]:
        return isSubSequence(string1, string2, m-1, n-1)

    # If last characters are not matching
    return isSubSequence(string1, string2, m, n-1)


if __name__ == "__main__":
    string1 = "gksrek"
    string2 = "geeksforgeeks"

    if isSubSequence(string1, string2, len(string1), len(string2)):
        print("true")
    else:
        print("false")

using System;

class GFG {
    static bool isSubSequence(string s1, string s2,
                              int m, int n){

        // Base Cases
        if (m == 0)
            return true;
        if (n == 0)
            return false;

        // If last characters of two strings
        // are matching
        if (s1[m - 1] == s2[n - 1])
            return isSubSequence(s1, s2, m - 1, n - 1);

        // If last characters are not matching
        return isSubSequence(s1, s2, m, n - 1);
    }

    public static void Main(){
        string s1 = "gksrek";
        string s2 = "geeksforgeeks";
        int m = s1.Length;
        int n = s2.Length;
        bool res = isSubSequence(s1, s2, m, n);

        if (res)
            Console.Write("true");
        else
            Console.Write("false");
    }
}

function isSubSequence(s1, s2, m, n) {
    // Base Cases
    if (m == 0)
        return true;
    if (n == 0)
        return false;

    // If last characters of two strings
    // are matching
    if (s1[m - 1] == s2[n - 1])
        return isSubSequence(s1, s2, m - 1, n - 1);

    // If last characters are not matching
    return isSubSequence(s1, s2, m, n - 1);
}

// Driver code
let s1 = "gksrek";
let s2 = "geeksforgeeks";
let m = s1.length;
let n = s2.length;
let res = isSubSequence(s1, s2, m, n);

if (res)
    console.log("true");
else
    console.log("false"); 

true

Time Complexity: O(n), The recursion will call at most n times.
Auxiliary Space: O(n) for recursion call stack.

[Approach 2] Iterative Way - O(n)Time and O(1) Space

The idea is to use two pointers, one pointer will start from start of s1 and another will start from start of s2. If current character on both the indexes are same then increment both pointers otherwise increment the pointer which is pointing s2.

Follow the steps below to solve the problem:

• Initialize the pointers i and j with zero, where i is the pointer to s1 and j is the pointer to s2.
• If s1[i] = s2[j] then increment both i and j by 1.
• Otherwise, increment only j by 1.
• If i reaches the end of s1 then return true else return false.

Below is the implementation of the above approach

#include <iostream>
using namespace std;


bool isSubSeq(const string& s1, const string& s2){
    int m = s1.length(), n = s2.length();
  
    // For s1 to be subsequence, its length must
    // smaller than s2
    if (m > n) return false;
  
    int i = 0, j = 0;
    while (i < m && j < n) {
        if (s1[i] == s2[j])
            i++;
        j++;
    }
  
    return i == m;
}

int main(){
    string s1 = "gksrek";
    string s2 = "geeksforgeeks";
    isSubSeq(s1, s2) ? cout << "true" : cout << "false";
    return 0;
}

import java.io.*;

class GFG {

    static boolean issubsequence(String s1, String s2){
        int n = s1.length(), m = s2.length();
        int i = 0, j = 0;
        while (i < n && j < m) {
            if (s1.charAt(i) == s2.charAt(j))
                i++;
            j++;
        }
        /*If i reaches end of s1,that mean we found all
        characters of s1 in s2,
        so s1 is subsequence of s2, else not*/
        return i == n;
    }

    public static void main(String args[]){
        String s1 = "gksrek";
        String s2 = "geeksforgeeks";
        if (issubsequence(s1, s2))
            System.out.println(
                "true");
        else
            System.out.println(
                "false");
    }
}

def issubsequence(s1, s2):

    n, m = len(s1), len(s2)
    i, j = 0, 0
    while (i < n and j < m):
        if (s1[i] == s2[j]):
            i += 1
        j += 1

    # If i reaches end of s1,that mean we found all
    # characters of s1 in s2,
    # so s1 is subsequence of s2, else not
    return i == n

if __name__ == "__main__":
    s1 = "gksrek"
    s2 = "geeksforgeeks"
    if (issubsequence(s1, s2)):
        print("true")
    else:
        print("false")

using System;

class GFG {

    // Returns true if s1 is subsequence of s2
    static bool issubsequence(string s1, string s2){
        int n = s1.Length, m = s2.Length;
        int i = 0, j = 0;
        while (i < n && j < m) {
            if (s1[i] == s2[j])
                i++;
            j++;
        }
        // If i reaches end of s1,that mean we found all
        // characters of s1 in s2,
        // so s1 is subsequence of s2, else not
        return i == n;
    }

    public static void Main(string[] args){
        string s1 = "gksrek";
        string s2 = "geeksforgeeks";
        if (issubsequence(s1, s2))
            Console.WriteLine("true");
        else
            Console.WriteLine(
               "false");
    }
}

function issubsequence(s1, s2) {
    let n = s1.length, m = s2.length;
    let i = 0, j = 0;
    
    while (i < n && j < m) {
        if (s1[i] == s2[j])
            i++;
        j++;
    }
    
    // If i reaches end of s1, that means we found all
    //   characters of s1 in s2, so s1 is a subsequence of s2 
    return i == n;
}

// Driver code
let s1 = "gksrek";
let s2 = "geeksforgeeks";

if (issubsequence(s1, s2))
    console.log("true");
else
    console.log("false");

true

Time Complexity: O(n)
Auxiliary Space: O(1)