Rabin Karp String Matching in DSA Java - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to initialize the prime number used for hashing.

DSA Java

final int prime = [1];

Drag options to blanks, or click blank then click option'

A31

B256

C101

D1009

Attempts:

3 left

💡 Hint

Common Mistakes

Using a non-prime number like 256.

Choosing a very large prime unnecessarily.

The prime number 101 is commonly used in Rabin Karp for hashing to reduce collisions.

2fill in blank

medium

Complete the code to compute the initial hash value for the pattern string.

DSA Java

for (int i = 0; i < pattern.length(); i++) {
    patternHash = (patternHash * prime + pattern.charAt(i)) % [1];
}

Drag options to blanks, or click blank then click option'

Amodulus

Bprime

Cpattern.length()

Dtext.length()

Attempts:

3 left

💡 Hint

Common Mistakes

Using prime instead of modulus for modulo operation.

Using length of pattern or text incorrectly.

The modulus value is used to keep the hash value within integer limits and avoid overflow.

3fill in blank

hard

Fix the error in the rolling hash update inside the loop.

DSA Java

textHash = (prime * (textHash - text.charAt(i) * [1]) + text.charAt(i + pattern.length())) % modulus;

Drag options to blanks, or click blank then click option'

Apattern.length()

Bpower

Cprime

Dmodulus

Attempts:

3 left

💡 Hint

Common Mistakes

Using prime or modulus instead of power.

Using pattern.length() directly as a multiplier.

The variable 'power' holds prime^(pattern.length()-1) used to remove the leading character's contribution from the hash.

4fill in blank

hard

Fill both blanks to correctly check for a hash match and then verify the actual substring.

DSA Java

if (patternHash == textHash && text.substring(i, i + [1]).equals([2])) {
    result.add(i);
}

Drag options to blanks, or click blank then click option'

Apattern.length()

Bpattern

Ctext.length()

Dtext

Attempts:

3 left

💡 Hint

Common Mistakes

Using text.length() or text instead of pattern length or pattern.

Skipping substring comparison after hash match.

We compare substring length equal to pattern length and check if substring equals the pattern.

5fill in blank

hard

Fill all three blanks to complete the Rabin Karp search method header and return statement.

DSA Java

public static List<Integer> [1](String text, String [2]) {
    List<Integer> result = new ArrayList<>();
    // ... algorithm implementation ...
    return [3];
}

Drag options to blanks, or click blank then click option'

ArabinKarpSearch

Bpattern

Cresult

DsearchPattern

Attempts:

3 left

💡 Hint

Common Mistakes

Using inconsistent method names.

Returning wrong variable instead of result list.

The method is named rabinKarpSearch, takes pattern as parameter, and returns the result list.

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