Substring Search Patterns in DSA Typescript

Mental Model

Find if a smaller string appears inside a bigger string by checking each possible position one by one.

Analogy: Like looking for a word in a book by scanning each line and checking if the word starts there.

Text: H E L L O   W O R L D
Pattern:   L L O
Positions to check: ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑

Dry Run Walkthrough

Input: text: "HELLO WORLD", pattern: "LLO"

Goal: Find the first position where pattern "LLO" appears in text "HELLO WORLD"

Step 1: Check text starting at index 0: compare 'HEL' with 'LLO'

Text: H E L L O   W O R L D
Index: 0 ↑
Pattern: L L O

Why: Start checking from the beginning of the text

Step 2: Mismatch at first character, move to index 1

Text: H E L L O   W O R L D
Index: 1 ↑
Pattern: L L O

Why: Pattern does not match at index 0, try next position

Step 3: Check text starting at index 2: compare 'LLO' with 'LLO'

Text: H E L L O   W O R L D
Index: 2 ↑
Pattern: L L O

Why: Check if pattern matches starting at index 2

Step 4: All characters match, pattern found at index 2

Text: H E L L O   W O R L D
Index: 2 ↑
Pattern: L L O

Why: Pattern matches fully at this position

Result:

Pattern found at index 2

Annotated Code

DSA Typescript

class SubstringSearch {
  static search(text: string, pattern: string): number {
    const n = text.length;
    const m = pattern.length;
    if (m === 0) return 0; // empty pattern found at start
    for (let i = 0; i <= n - m; i++) {
      let j = 0;
      while (j < m && text[i + j] === pattern[j]) {
        j++;
      }
      if (j === m) {
        return i; // pattern found at index i
      }
    }
    return -1; // pattern not found
  }
}

// Driver code
const text = "HELLO WORLD";
const pattern = "LLO";
const index = SubstringSearch.search(text, pattern);
if (index !== -1) {
  console.log(`Pattern found at index ${index}`);
} else {
  console.log("Pattern not found");
}

for (let i = 0; i <= n - m; i++) {

Check each possible start position in text where pattern can fit

while (j < m && text[i + j] === pattern[j]) {

Compare characters one by one to check for pattern match

if (j === m) {

If all characters matched, pattern found at index i

Output

Pattern found at index 2

Complexity Analysis

Time: O(n*m) because in worst case we check each position in text and compare up to m characters

Space: O(1) because we only use a few variables, no extra storage proportional to input size

vs Alternative: Naive search is simple but slow; advanced algorithms like KMP improve to O(n) by skipping unnecessary checks

Edge Cases

Empty pattern string

Returns 0 immediately since empty pattern is found at start

DSA Typescript

if (m === 0) return 0;

Pattern longer than text

Returns -1 immediately because pattern cannot fit

DSA Typescript

for (let i = 0; i <= n - m; i++) {

Pattern not present in text

Returns -1 after checking all positions

DSA Typescript

return -1; // pattern not found

When to Use This Pattern

When you need to find if one string appears inside another, try substring search patterns starting with naive approach before optimizing.

Common Mistakes

Mistake: Not stopping character comparison when mismatch occurs
Fix: Use a while loop that breaks immediately on mismatch

Mistake: Checking positions beyond where pattern can fit
Fix: Limit start index to n - m to avoid out-of-bound errors

Summary

Find if a smaller string appears inside a bigger string by checking each possible position.

Use when you want to locate a pattern inside text simply and clearly.

The key is to compare characters one by one and stop early on mismatch.

Practice

1. What is the main goal of substring search algorithms in strings?

easy

A. To sort all characters in a string alphabetically

B. To find if a smaller string exists inside a larger string

C. To reverse the entire string

D. To count the total number of vowels in a string

Solution

1. Step 1: Understand substring search purpose

   Substring search algorithms check if a smaller string (pattern) appears inside a bigger string (text).

2. Step 2: Compare options with substring search definition

   Only To find if a smaller string exists inside a larger string matches this goal. Sorting, reversing, or counting vowels are different tasks.

3. Final Answer:

   To find if a smaller string exists inside a larger string -> Option B

4. Quick Check:

   Substring search = find smaller string inside larger [OK]

Hint: Substring search means finding a smaller string inside a bigger one [OK]

Common Mistakes:

• Confusing substring search with sorting or reversing strings
• Thinking substring search counts characters
• Mixing substring search with string length calculation

2. Which of the following is the correct TypeScript syntax to check if string text contains substring pattern?

easy

A. text.includes(pattern)

B. text.contains(pattern)

C. text.has(pattern)

D. text.find(pattern)

Solution

1. Step 1: Recall TypeScript string methods

   TypeScript strings have a method called includes to check substring presence.

2. Step 2: Verify method names

   Only includes is valid. contains, has, and find are not string methods in TypeScript.

3. Final Answer:

   text.includes(pattern) -> Option A

4. Quick Check:

   Use includes() to check substring presence [OK]

Hint: Use includes() method to check substring in TypeScript [OK]

Common Mistakes:

• Using non-existent methods like contains() or has()
• Confusing includes() with find() which is for arrays
• Forgetting parentheses after method name

3. What will be the output of the following TypeScript code?

const text = "hello world";
const pattern = "wor";
console.log(text.indexOf(pattern));

medium

A. 6

B. -1

C. 3

D. 0

Solution

1. Step 1: Understand indexOf method

   indexOf returns the starting index of the substring if found, else -1.

2. Step 2: Find substring position in text

   In "hello world", substring "wor" starts at index 6 (0-based counting: h=0, e=1, l=2, l=3, o=4, space=5, w=6).

3. Final Answer:

   6 -> Option A

4. Quick Check:

   indexOf("wor") = 6 [OK]

Hint: indexOf returns start index or -1 if not found [OK]

Common Mistakes:

• Counting index starting from 1 instead of 0
• Confusing indexOf with includes (which returns boolean)
• Assuming indexOf returns substring length

4. Identify the error in the following TypeScript code snippet for substring search:

const text = "typescript";
const pattern = "script";
if (text.find(pattern)) {
  console.log("Found");
} else {
  console.log("Not Found");
}

medium

A. Using if statement without parentheses

B. Missing semicolon after console.log statements

C. Pattern variable is not declared

D. Using find() method on string which does not exist

Solution

1. Step 1: Check string methods in TypeScript

   Strings do not have a find() method. The correct method to check substring is includes() or indexOf().

2. Step 2: Verify other code parts

   Semicolons are optional in TypeScript, pattern is declared, and if statement syntax is correct.

3. Final Answer:

   Using find() method on string which does not exist -> Option D

4. Quick Check:

   Strings have includes(), not find() [OK]

Hint: Use includes() or indexOf(), not find() on strings [OK]

Common Mistakes:

• Assuming find() works on strings like arrays
• Thinking semicolons are mandatory causing errors
• Misreading if statement syntax

5. You want to find all starting indices of substring pattern in string text. Which approach correctly finds multiple occurrences in TypeScript?

hard

A. Use text.indexOf(pattern) once and return that single index

B. Use text.includes(pattern) repeatedly without changing index

C. Use a loop with indexOf(pattern, startIndex) updating startIndex after each find

D. Use text.findAll(pattern) method to get all indices

Solution

1. Step 1: Understand multiple substring search

   To find all occurrences, you must repeatedly search starting after the last found index.

2. Step 2: Analyze each option

   Use a loop with indexOf(pattern, startIndex) updating startIndex after each find uses a loop with indexOf and updates start index, which is correct. Use text.includes(pattern) repeatedly without changing index does not update index, so it loops infinitely or finds only once. Use text.indexOf(pattern) once and return that single index finds only one occurrence. Use text.findAll(pattern) method to get all indices uses a non-existent method.

3. Final Answer:

   Use a loop with indexOf(pattern, startIndex) updating startIndex after each find -> Option C

4. Quick Check:

   Loop with indexOf and updated start index finds all [OK]

Hint: Loop with indexOf and update start index to find all [OK]

Common Mistakes:

• Not updating start index causing infinite loops
• Using includes() which returns boolean, not index
• Expecting findAll() method which does not exist