Introduction

The best way to check whether one sequence is in another depends on what "in" means. If you mean a contiguous block, you are solving a substring or subarray problem. If you mean the smaller sequence appears in order but not necessarily contiguously, that is a subsequence problem. Those two problems use different algorithms, so the first step is to choose the right definition.

Case 1: Contiguous Sequence Containment

If you want to know whether small appears as one uninterrupted block inside large, use a sliding comparison.

1def contains_contiguous(large, small):
2    m = len(small)
3    if m == 0:
4        return True
5    for i in range(len(large) - m + 1):
6        if large[i:i + m] == small:
7            return True
8    return False
9
10
11print(contains_contiguous([1, 2, 3, 4, 5], [3, 4]))

This is the direct subarray or substring-style interpretation.

For strings, many languages already provide efficient built-in search.

print("needle" in "find the needle here")

Case 2: Subsequence Containment

If the elements only need to appear in order, not contiguously, use the classic two-pointer scan.

1def is_subsequence(large, small):
2    j = 0
3    for value in large:
4        if j < len(small) and value == small[j]:
5            j += 1
6    return j == len(small)
7
8
9print(is_subsequence([1, 2, 3, 4, 5], [2, 4]))

This returns True because 2 and 4 appear in order, even though they are not adjacent.

This algorithm runs in linear time with respect to the larger sequence.

When Built-Ins Are Best

For strings and bytes, built-in search functions are often the best answer because they are well-tested and optimized.

For example, in Python:

text = "abcde"
pattern = "bcd"
print(text.find(pattern) != -1)

There is usually no reason to reimplement string search manually unless you are studying algorithms or handling a special constraint.

When Pattern Matching Gets Large

If you will search the same pattern in many large sequences, more advanced contiguous-search algorithms such as KMP or Boyer-Moore can make sense. They reduce wasted comparisons and are especially relevant in repeated-search workloads.

For a one-off list or string membership check, the simpler methods are usually enough.

So the best algorithm is workload-dependent, not just theory-dependent.

Clarify the Data Type Too

The answer also depends on whether the sequence is:

• a string
• a list of numbers
• a stream you can scan only once
• a very large dataset that must be processed incrementally

The subsequence two-pointer method works nicely for streams because it only needs one pass. Contiguous matching often needs a small rolling window or random access.

Common Pitfalls

The biggest mistake is not deciding whether the smaller sequence must be contiguous.

Another mistake is reimplementing string search manually when the language already provides a good built-in solution.

A third issue is choosing an advanced pattern-matching algorithm before confirming that the simpler linear approach is actually too slow for the real workload.

Summary

• First decide whether you mean contiguous containment or subsequence containment
• For contiguous matching, use slicing, a sliding window, or a built-in search function
• For subsequence matching, use the two-pointer scan
• Built-in string search is usually the best answer for ordinary text problems
• Match the algorithm to the actual definition of "in" before optimizing