Rabin Karp String Matching in DSA Java - Build from Scratch

Rabin Karp String Matching

📖 Scenario: Imagine you are building a simple search tool that finds a small word inside a big text. This tool uses a smart way called Rabin Karp to quickly find where the small word appears in the big text.

🎯 Goal: Build a Java program that uses the Rabin Karp algorithm to find all starting positions of a given pattern inside a given text.

📋 What You'll Learn

Create two strings called text and pattern with exact values

Create an integer variable prime to use as a modulus for hashing

Implement the Rabin Karp algorithm to find all starting indices where pattern appears in text

Print the list of starting indices as output

💡 Why This Matters

🌍 Real World

Rabin Karp is used in text editors and search engines to quickly find words or phrases inside large documents.

💼 Career

Understanding string matching algorithms like Rabin Karp is important for software developers working on search features, data processing, and text analysis.

1

Create the text and pattern strings

Create a string variable called text with the value "abracadabra" and a string variable called pattern with the value "abra".

DSA Java

// Your code here

Hint

Use String text = "abracadabra"; and String pattern = "abra";

2

Add the prime modulus variable

Add an integer variable called prime and set it to 101 to use as the modulus for hashing.

DSA Java

public class RabinKarp {
    public static void main(String[] args) {
        String text = "abracadabra";
        String pattern = "abra";
        // Your code here
    }
}

Hint

Use int prime = 101; to set the modulus.

3

Implement the Rabin Karp search logic

Write code to implement the Rabin Karp algorithm that finds all starting indices where pattern appears in text. Use variables text, pattern, and prime. Store the matching indices in an integer list called result.

DSA Java

public class RabinKarp {
    public static void main(String[] args) {
        String text = "abracadabra";
        String pattern = "abra";
        int prime = 101;
        // Your code here
    }
}

Hint

Use a loop from 0 to n - m and compare hashes. Add matching indices to result.

4

Print the matching indices

Print the result list to show all starting indices where pattern appears in text.

DSA Java

import java.util.ArrayList;
import java.util.List;

public class RabinKarp {
    public static void main(String[] args) {
        String text = "abracadabra";
        String pattern = "abra";
        int prime = 101;

        int m = pattern.length();
        int n = text.length();
        int base = 256;
        int patternHash = 0;
        int textHash = 0;
        int h = 1;

        List result = new ArrayList();

        for (int i = 0; i < m - 1; i++) {
            h = (h * base) % prime;
        }

        for (int i = 0; i < m; i++) {
            patternHash = (base * patternHash + pattern.charAt(i)) % prime;
            textHash = (base * textHash + text.charAt(i)) % prime;
        }

        for (int i = 0; i <= n - m; i++) {
            if (patternHash == textHash) {
                int j;
                for (j = 0; j < m; j++) {
                    if (text.charAt(i + j) != pattern.charAt(j)) {
                        break;
                    }
                }
                if (j == m) {
                    result.add(i);
                }
            }
            if (i < n - m) {
                textHash = (base * (textHash - text.charAt(i) * h) + text.charAt(i + m)) % prime;
                if (textHash < 0) {
                    textHash += prime;
                }
            }
        }
        // Print the result list below
    }
}

Hint

Use System.out.println(result); to print the list of indices.

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