String Pattern Matching Naive in DSA Go - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the main idea behind the naive string pattern matching algorithm?

The naive algorithm checks for the pattern at every possible position in the text by comparing characters one by one until a match is found or all positions are checked.

beginner

What is the worst-case time complexity of the naive string pattern matching algorithm?

The worst-case time complexity is O(m * n), where m is the length of the pattern and n is the length of the text, because it may check every character of the text for each character of the pattern.

beginner

In the naive pattern matching algorithm, what happens when a mismatch occurs during comparison?

When a mismatch occurs, the algorithm shifts the pattern by one position to the right in the text and starts comparing again from the first character of the pattern.

intermediate

Why is the naive string pattern matching algorithm considered inefficient for large texts?

Because it checks every possible position in the text and compares characters one by one, it can do many repeated comparisons, leading to slow performance on large texts.

intermediate

How does the naive string pattern matching algorithm handle overlapping patterns?

It checks for the pattern at every position, including overlapping ones, so it can find multiple occurrences even if they overlap.

What does the naive string pattern matching algorithm do when it finds a mismatch?

A Skips multiple characters based on mismatch

B Shifts the pattern by one position and restarts comparison

C Stops searching immediately

D Reverses the text and pattern

The naive algorithm shifts the pattern by one position to the right and starts comparing again from the first character.

What is the time complexity of the naive string pattern matching algorithm in the worst case?

A O(n)

B O(m + n)

C O(m * n)

D O(log n)

The worst-case time complexity is O(m * n), where m is the pattern length and n is the text length.

Which of the following best describes the naive string pattern matching algorithm?

A Uses a prefix table to skip comparisons

B Builds a suffix tree for the text

C Uses hashing to find matches

D Checks pattern at every position in the text

The naive algorithm checks the pattern at every possible position in the text.

Can the naive string pattern matching algorithm find overlapping occurrences of a pattern?

A Yes, it checks every position including overlaps

B No, it skips overlapping matches

C Only if the pattern is a palindrome

D Only if the text is sorted

The naive algorithm checks every position, so it can find overlapping occurrences.

Why might the naive string pattern matching algorithm be slow on large texts?

A Because it compares characters repeatedly at many positions

B Because it sorts the text first

C Because it uses complex data structures

D Because it uses recursion

It can be slow because it compares characters repeatedly at many positions without skipping.

Explain how the naive string pattern matching algorithm works step-by-step.

Think about sliding the pattern over the text and checking each character.

Describe the main disadvantage of the naive string pattern matching algorithm and why it happens.

Consider how many times characters are compared in worst cases.

Practice

1. What is the main idea behind the naive string pattern matching algorithm?

easy

A. Check every possible position in the text for the pattern

B. Use a hash function to find the pattern quickly

C. Preprocess the pattern to skip some comparisons

D. Sort the text and pattern before matching

Solution

1. Step 1: Understand naive matching approach

   The naive algorithm tries to match the pattern starting at each position in the text one by one.

2. Step 2: Compare with other methods

   Other methods like hashing or preprocessing are not part of the naive approach.

3. Final Answer:

   Check every possible position in the text for the pattern -> Option A

4. Quick Check:

   Naive = Check all positions [OK]

Hint: Naive means try all positions one by one [OK]

Common Mistakes:

• Thinking naive uses hashing
• Assuming pattern preprocessing is done
• Believing text is sorted first

2. Which of the following Go code snippets correctly starts the outer loop for naive string pattern matching?

easy

A. for i := 0; i <= len(text)-len(pattern); i++ {

B. for i := 0; i < len(text); i++ {

C. for i := 1; i <= len(text); i++ {

D. for i := 0; i < len(pattern); i++ {

Solution

1. Step 1: Determine loop range for matching

   The outer loop must run from 0 to len(text)-len(pattern) to avoid out-of-range errors.

2. Step 2: Check each option

   for i := 0; i <= len(text)-len(pattern); i++ { correctly uses i <= len(text)-len(pattern). Others either go too far or use wrong limits.

3. Final Answer:

   for i := 0; i <= len(text)-len(pattern); i++ { -> Option A

4. Quick Check:

   Loop till text length minus pattern length [OK]

Hint: Loop till text length minus pattern length [OK]

Common Mistakes:

• Looping beyond valid start positions
• Starting loop from 1 instead of 0
• Using pattern length as loop limit

3. What will be the output of the following Go code snippet?

text := "banana"
pattern := "ana"
count := 0
for i := 0; i <= len(text)-len(pattern); i++ {
  j := 0
  for j < len(pattern) && text[i+j] == pattern[j] {
    j++
  }
  if j == len(pattern) {
    count++
  }
}
fmt.Println(count)

medium

A. 1

B. 3

C. 0

D. 2

Solution

1. Step 1: Identify pattern matches in text

   Check each position in "banana" for "ana": positions 1-3 and 3-5 match.

2. Step 2: Count matches

   Two matches found, so count is 2.

3. Final Answer:

   2 -> Option D

4. Quick Check:

   "ana" appears twice in "banana" [OK]

Hint: Count all exact matches sliding over text [OK]

Common Mistakes:

• Counting overlapping matches incorrectly
• Off-by-one errors in loop limits
• Assuming only first match counts

4. The following Go code tries to count pattern occurrences but has a bug. What is the bug?

text := "abcabcabc"
pattern := "abc"
count := 0
for i := 0; i < len(text)-len(pattern); i++ {
  j := 0
  for j < len(pattern) && text[i+j] == pattern[j] {
    j++
  }
  if j == len(pattern) {
    count++
  }
}
fmt.Println(count)

medium

A. The inner loop condition is wrong

B. The outer loop should use <= instead of <

C. The count variable is not initialized

D. The pattern length is not checked

Solution

1. Step 1: Analyze outer loop range

   The loop runs from 0 to len(text)-len(pattern)-1, missing last valid start index.

2. Step 2: Correct loop condition

   Changing < to <= includes last position, fixing missed matches.

3. Final Answer:

   The outer loop should use <= instead of < -> Option B

4. Quick Check:

   Loop must cover last valid start index [OK]

Hint: Use <= to include last possible start index [OK]

Common Mistakes:

• Using < instead of <= in outer loop
• Ignoring last possible match position
• Misunderstanding loop boundaries

5. Given the text "abracadabra" and pattern "abra", how many times will the naive algorithm find the pattern if overlapping matches are counted? Use the naive approach code below:

text := "abracadabra"
pattern := "abra"
count := 0
for i := 0; i <= len(text)-len(pattern); i++ {
  j := 0
  for j < len(pattern) && text[i+j] == pattern[j] {
    j++
  }
  if j == len(pattern) {
    count++
  }
}
fmt.Println(count)

hard

A. 3

B. 1

C. 2

D. 4

Solution

1. Step 1: Identify all pattern matches including overlaps

   "abra" appears at positions 0-3 and 7-10 in "abracadabra".

2. Step 2: Count total matches

   Two matches found, so count is 2.

3. Final Answer:

   2 -> Option C

4. Quick Check:

   "abra" occurs twice overlapping allowed [OK]

Hint: Check all positions including overlaps [OK]

Common Mistakes:

• Counting only first match
• Missing second overlapping match
• Confusing substring positions