Given two strings s and t, return true if s is a subsequence of t, or false otherwise.
A subsequence of a string is a new string that is formed from the original string by deleting some (can be none) of the characters without disturbing the relative positions of the remaining characters. (i.e., "ace" is a subsequence of "abcde" while "aec" is not).
Example 1:
Input: s = "abc", t = "ahbgdc" Output: true
Example 2:
Input: s = "axc", t = "ahbgdc" Output: false
Constraints:
0 <= s.length <= 1000 <= t.length <= 104s and t consist only of lowercase English letters.Follow up: Suppose there are lots of incoming
s, say s1, s2, ..., sk where k >= 109, and you want to check one by one to see if t has its subsequence. In this scenario, how would you change your code?Problem Overview: Given two strings s and t, determine whether s is a subsequence of t. A subsequence keeps the relative order of characters but does not require them to be contiguous. The task is to scan t and verify that every character in s appears in order.
Approach 1: Two-Pointer Technique (O(n) time, O(1) space)
This is the standard solution using the two pointers pattern. Maintain one pointer for s and another for t. Iterate through t; whenever t[j] matches s[i], advance the pointer for s. Continue scanning until either all characters in s are matched or t is exhausted. The key insight: subsequence checking only requires preserving order, so a single pass through t is enough. This approach runs in O(|t|) time and O(1) space because it only uses two indices. It works well when you check a single pair of strings and is the most common interview solution for problems involving string traversal.
Approach 2: Preprocessing with Character Index Lists (O(n + m log n) time, O(n) space)
The follow-up version asks what happens if you must check billions of candidate strings s against the same t. Instead of scanning t every time, preprocess it by storing the indices of each character in a map. For example, build a dictionary where each character points to a sorted list of positions where it appears in t. For each character in s, use binary search to find the smallest index greater than the previously matched position. This converts repeated scanning into fast lookups. Preprocessing takes O(|t|) time and space. Each query string s then runs in O(|s| log |t|) due to binary search. This pattern appears in advanced dynamic programming and query optimization problems where the same dataset is reused.
Recommended for interviews: The two-pointer solution is what interviewers expect first. It shows you understand subsequence properties and can implement an efficient single-pass scan with O(n) time and constant space. Mentioning the preprocessing approach during follow-ups demonstrates deeper problem-solving skills and awareness of scaling when many queries share the same base string.
The Two-Pointer Technique involves maintaining two indices, one for each string (s and t). Start both pointers at the beginning of their respective strings. Move the pointer for 's' only when there's a match with the current character at 't'. This ensures that all characters in 's' appear in 't' with the correct order. If the pointer for 's' reaches the end of 's', then 's' is a subsequence of 't'.
This C solution employs a while loop with two pointers to check each character. The loop advances through 't', incrementing a pointer for 's' only when characters match. If 's' is fully traversed (indexS == lengthS), it confirms 's' as a subsequence of 't'.
Time Complexity: O(n) where n is the length of 't'.
Space Complexity: O(1) as no additional data structures are used.
For frequent 's' queries, preprocess 't' to build a map of character positions using a dictionary or hashmap structure. This allows for efficient binary search to determine if 's' is a subsequence, as only relevant sections of 't' need to be checked.
This Python solution uses a map to store positions of each character in 't'. For each character in 's', it performs a binary search using the 'bisect' module to locate the next valid position in 't'. This avoids full scans and enhances efficiency for large numbers of 's'.
Python
Preprocessing Time Complexity: O(n) for preparing the map where n is the length of 't'.
Checking Time Complexity: O(mlog(k)) for each 's', where m is the length of 's' and k is the average number of occurrences of each character in 't'.
Space Complexity: O(n) for the map storage.
We define two pointers i and j to point to the initial position of the string s and t respectively. Each time we compare the two characters pointed to by the two pointers, if they are the same, both pointers move right at the same time; if they are not the same, only j moves right. When the pointer i moves to the end of the string s, it means that s is the subsequence of t.
The time complexity is O(m + n), where m and n are the lengths of the strings s and t respectively. The space complexity is O(1).
| Approach | Complexity |
|---|---|
| Two-Pointer Technique | Time Complexity: O(n) where n is the length of 't'. |
| Follow-up: Using Preprocessing | Preprocessing Time Complexity: O(n) for preparing the map where n is the length of 't'. |
| Two Pointers | — |
| Approach | Time | Space | When to Use |
|---|---|---|---|
| Two-Pointer Technique | O(|t|) | O(1) | Best for single queries where you only need to check one pair of strings. |
| Preprocessing with Index Lists + Binary Search | O(|t|) preprocessing + O(|s| log |t|) per query | O(|t|) | Useful when many different strings must be checked against the same base string t. |
Is Subsequence - Leetcode 392 • NeetCode • 71,008 views views
Watch 9 more video solutions →Practice Is Subsequence with our built-in code editor and test cases.
Practice on FleetCode