Is Subsequence - Practice Coding Problems

Is Subsequence - Problem

You are given two strings s and t. Your task is to determine whether s is a subsequence of t.

A subsequence is a sequence that can be derived from the original string by deleting some or no characters without changing the order of the remaining characters. Think of it as picking characters from left to right while maintaining their relative positions.

Examples:

"ace" is a subsequence of "abcde" ✅
"aec" is NOT a subsequence of "abcde" ❌ (wrong order)
"axc" is NOT a subsequence of "abcde" ❌ ('x' doesn't exist)

Goal: Return true if s is a subsequence of t, otherwise return false.

Input & Output

example_1.py — Basic Match

$ Input: s = "ace", t = "abcde"

› Output: true

💡 Note: We can find 'a' at position 0, 'c' at position 2, and 'e' at position 4, all in order.

example_2.py — Wrong Order

$ Input: s = "aec", t = "abcde"

› Output: false

💡 Note: While all characters exist in t, 'e' comes after 'c', so we can't form the subsequence "aec".

example_3.py — Empty String

$ Input: s = "", t = "abcde"

› Output: true

💡 Note: An empty string is always a subsequence of any string.

Visualization

Tap to expand

Understanding the Visualization

Start Journey

Begin at the start of both your map (s) and the terrain (t)

Find Landmarks

When you find a landmark from your map, mark it as found and look for the next one

Keep Moving

Always move forward through the terrain, never backtrack

Success Check

You succeed if you find all landmarks from your map in order

Key Takeaway

🎯 Key Insight: The two pointers approach works because we only need to maintain the relative order of characters, not their exact positions.

Time & Space Complexity

Time Complexity

⏱️

O(n)

We traverse each string at most once, where n is the length of the longer string

✓ Linear Growth

Space Complexity

O(1)

Only using two pointer variables, no additional data structures needed

✓ Linear Space

Constraints

0 ≤ s.length ≤ 100
0 ≤ t.length ≤ 10⁴
s and t consist only of lowercase English letters

Asked in

G Google 45 a Amazon 38 f Meta 29 ⊞ Microsoft 22 Apple 18

The optimal solution uses the two pointers technique with O(n) time and O(1) space. We maintain one pointer for each string and advance through the target string linearly, matching characters in order. This approach is elegant, efficient, and naturally handles all edge cases.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Optimal)	O(n)	O(1)	Use one pointer for each string, advance both when characters match
Brute Force (Recursive)	O(2^n)	O(n)	Try all possible ways to match characters using recursion

Two Pointers (Optimal) — Algorithm Steps

Initialize two pointers: i for string s, j for string t
While both pointers are within bounds:
If characters match, advance both pointers
If characters don't match, advance only the t pointer
Return true if we've matched all characters in s

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set both pointers to start of their respective strings

Compare

Check if characters at current positions match

Advance

Move both pointers if match, otherwise only t pointer

Complete

Success if all characters in s are matched

Code -

solution.c — C

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

bool isSubsequence(const char* s, const char* t) {
    int i = 0, j = 0;
    int sLen = strlen(s), tLen = strlen(t);
    
    while (i < sLen && j < tLen) {
        if (s[i] == t[j]) {
            i++;
        }
        j++;
    }
    
    return i == sLen;
}

int main() {
    char s[1001], t[50001];
    scanf("\"%1000[^\"]\"\n", s);
    scanf("\"%50000[^\"]\"\n", t);
    
    printf("%s\n", isSubsequence(s, t) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We traverse each string at most once, where n is the length of the longer string

✓ Linear Growth

Space Complexity

O(1)

Only using two pointer variables, no additional data structures needed

✓ Linear Space

Constraints

0 ≤ s.length ≤ 100
0 ≤ t.length ≤ 10⁴
s and t consist only of lowercase English letters

89.5K Views

High Frequency

~15 min Avg. Time

2.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Two Pointers (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler