Why Rabin Karp String Matching in DSA Java?

The Big Idea

What if you could find any sentence in a huge book almost instantly without reading every word?

The Scenario

Imagine you have a huge book and you want to find every place where a certain sentence appears. You try to read every word and compare it with your sentence manually.

The Problem

This manual way is very slow and tiring. You might miss some matches or get confused by similar words. Checking every word one by one wastes a lot of time, especially if the book is very long.

The Solution

Rabin Karp uses a clever math trick called hashing to quickly check if parts of the book might match your sentence. It turns the sentence and parts of the book into numbers and compares those numbers first, which is much faster than checking every letter.

Before vs After

✗ Before

for (int i = 0; i <= text.length() - pattern.length(); i++) {
  if (text.substring(i, i + pattern.length()).equals(pattern)) {
    System.out.println("Found at " + i);
  }
}

✓ After

int patternHash = hash(pattern);
int textHash = hash(text.substring(0, pattern.length()));
for (int i = 0; i <= text.length() - pattern.length(); i++) {
  if (patternHash == textHash && text.substring(i, i + pattern.length()).equals(pattern)) {
    System.out.println("Found at " + i);
  }
  if (i < text.length() - pattern.length()) {
    textHash = rollHash(textHash, text.charAt(i), text.charAt(i + pattern.length()));
  }
}

What It Enables

It makes searching for patterns in large texts fast and efficient, saving time and effort.

Real Life Example

Finding a specific word or phrase quickly in a large document, like searching for a name in a long report or a keyword in a book.

Key Takeaways

Manual search is slow and error-prone for large texts.

Rabin Karp uses hashing to speed up pattern matching.

This method quickly filters possible matches before checking characters.

Practice

1. What is the main idea behind the Rabin Karp String Matching algorithm?

easy

A. It sorts the text and pattern before matching

B. It compares each character one by one without hashing

C. It uses hashing to find pattern matches efficiently

D. It uses recursion to find the pattern

Solution

1. Step 1: Understand Rabin Karp's approach

   The algorithm uses a hash function to convert the pattern and text substrings into numbers.

2. Step 2: Use hashing for efficient matching

   By comparing hash values instead of characters, it quickly finds potential matches.

3. Final Answer:

   It uses hashing to find pattern matches efficiently -> Option C

4. Quick Check:

   Hashing = Efficient matching [OK]

Hint: Remember Rabin Karp uses hashing for fast pattern search [OK]

Common Mistakes:

• Thinking it compares characters directly without hashing
• Confusing it with brute force matching
• Assuming it sorts strings before matching

2. Which of the following is the correct way to calculate the rolling hash in Rabin Karp for the next substring?

easy

A. new_hash = (old_hash - old_char * high_base) * base + new_char

B. new_hash = old_hash + old_char + new_char

C. new_hash = old_hash * old_char - new_char

D. new_hash = old_hash / base + new_char * high_base

Solution

1. Step 1: Recall rolling hash formula

   Rolling hash removes the old char's contribution and adds the new char's value.

2. Step 2: Apply formula correctly

   It subtracts old_char * high_base, multiplies by base, then adds new_char.

3. Final Answer:

   new_hash = (old_hash - old_char * high_base) * base + new_char -> Option A

4. Quick Check:

   Rolling hash formula = new_hash = (old_hash - old_char * high_base) * base + new_char [OK]

Hint: Subtract old char, multiply, then add new char for rolling hash [OK]

Common Mistakes:

• Adding old_char instead of subtracting
• Dividing instead of multiplying by base
• Ignoring the high_base multiplier

3. What will be the output of the following Java code snippet using Rabin Karp to find pattern "abc" in text "ababc"?

String text = "ababc";
String pattern = "abc";
List<Integer> result = rabinKarpSearch(text, pattern);
System.out.println(result);

Assume rabinKarpSearch returns a list of starting indices where pattern matches.

medium

A. []

B. [0, 2]

C. [1]

D. [2]

Solution

1. Step 1: Identify pattern occurrences in text

   Text: "ababc"; pattern: "abc"; check substrings of length 3: "aba"(0), "bab"(1), "abc"(2).

2. Step 2: Find matching indices

   Only substring starting at index 2 matches "abc".

3. Final Answer:

   [2] -> Option D

4. Quick Check:

   Pattern found at index 2 only [OK]

Hint: Check substrings of pattern length for exact matches [OK]

Common Mistakes:

• Including partial matches like "aba" or "bab"
• Assuming multiple matches without checking substring
• Confusing indices starting at 1 instead of 0

4. Consider this buggy Java snippet for Rabin Karp pattern search:

int base = 256;
int prime = 101;
int highBase = (int) Math.pow(base, pattern.length());
// ... rest of code
// rolling hash update:
currentHash = (currentHash - text.charAt(i) * highBase) * base + text.charAt(i + pattern.length());
currentHash %= prime;

What is the main bug here?

medium

A. highBase should be base^(pattern.length() - 1), not base^pattern.length()

B. Modulo operation should be before subtraction

C. Rolling hash should add old char, not subtract

D. Base should be 128, not 256

Solution

1. Step 1: Check highBase calculation

   High base is used to remove the leftmost character's contribution, so it should be base^(pattern length - 1).

2. Step 2: Identify incorrect power usage

   Using base^(pattern length) removes too much, causing wrong hash updates.

3. Final Answer:

   highBase should be base^(pattern.length() - 1), not base^pattern.length() -> Option A

4. Quick Check:

   Correct highBase power fixes rolling hash [OK]

Hint: Use base^(pattern length - 1) for highBase in rolling hash [OK]

Common Mistakes:

• Using base^pattern.length() instead of base^(pattern.length()-1)
• Ignoring modulo after subtraction
• Confusing addition and subtraction in rolling hash

5. You want to find all occurrences of pattern "aaa" in text "aaaaaa" using Rabin Karp. How many matches will the algorithm find and why?

hard

A. 2, because it skips overlapping matches

B. 4, because overlapping matches are counted

C. 3, because it counts only non-overlapping matches

D. 1, because it stops after first match

Solution

1. Step 1: Identify all substrings of length 3

   Text "aaaaaa" has substrings: "aaa"(0), "aaa"(1), "aaa"(2), "aaa"(3).

2. Step 2: Count overlapping matches

   All these substrings match pattern "aaa", so 4 matches found including overlaps.

3. Final Answer:

   4, because overlapping matches are counted -> Option B

4. Quick Check:

   Overlapping matches count = 4 [OK]

Hint: Rabin Karp counts overlapping matches by sliding one char at a time [OK]

Common Mistakes:

• Assuming matches cannot overlap
• Stopping search after first match
• Counting only non-overlapping matches