A substring of a string is another string that occurs in. For example, ver is a substring of stackoverflow. Not to be confused with subsequence because cover is a subsequence of the same string. In other words, any subset of consecutive letters in a string is a substring of the given string.
In Rabin-Karp algorithm, we'll generate a hash of our pattern that we are looking for & check if the rolling hash of our text matches the pattern or not. If it doesn't match, we can guarantee that the pattern doesn't exist in the text. However, if it does match, the pattern can be present in the text. Let's look at an example:
Let's say we have a text: yeminsajid and we want to find out if the pattern nsa exists in the text. To calculate the hash and rolling hash, we'll need to use a prime number. This can be any prime number. Let's take prime = 11 for this example. We'll determine hash value using this formula:
(1st letter) X (prime) + (2nd letter) X (prime)¹ + (3rd letter) X (prime)² X + ......
a -> 1 g -> 7 m -> 13 s -> 19 y -> 25 b -> 2 h -> 8 n -> 14 t -> 20 z -> 26 c -> 3 i -> 9 o -> 15 u -> 21 d -> 4 j -> 10 p -> 16 v -> 22 e -> 5 k -> 11 q -> 17 w -> 23 f -> 6 l -> 12 r -> 18 x -> 24
The hash value of nsa will be:
14 X 11⁰ + 19 X 11¹ + 1 X 11² = 344
Now we find the rolling-hash of our text. If the rolling hash matches with the hash value of our pattern, we'll check if the strings match or not. Since our pattern has 3 letters, we'll take 1st 3 letters yem from our text and calculate hash value. We get:
25 X 11⁰ + 5 X 11¹ + 13 X 11² = 1653
This value doesn't match with our pattern's hash value. So the string doesn't exists here. Now we need to consider the next step. To calculate the hash value of our next string emi. We can calculate this using our formula. But that would be rather trivial and cost us more. Instead, we use another technique.
1653 - 25 = 1628.
1628 / 11 = 148.
148 + 9 X 11² = 1237.
The new hash value is not equal to our patterns hash value. Moving on, for n we get:
Previous String: emi First Letter of Previous String: e(5) New Letter: n(14) New String: "min" 1237 - 5 = 1232 1232 / 11 = 112 112 + 14 X 11² = 1806
It doesn't match. After that, for s, we get:
Previous String: min First Letter of Previous String: m(13) New Letter: s(19) New String: "ins" 1806 - 13 = 1793 1793 / 11 = 163 163 + 19 X 11² = 2462
It doesn't match. Next, for a, we get:
Previous String: ins First Letter of Previous String: i(9) New Letter: a(1) New String: "nsa" 2462 - 9 = 2453 2453 / 11 = 223 223 + 1 X 11² = 344
It's a match! Now we compare our pattern with the current string. Since both the strings match, the substring exists in this string. And we return the starting position of our substring.
The pseudo-code will be:
Procedure Calculate-Hash(String, Prime, x): hash := 0 // Here x denotes the length to be considered for m from 1 to x // to find the hash value hash := hash + (Value of String[m])ᵐ⁻¹ end for Return hash
Procedure Recalculate-Hash(String, Curr, Prime, Hash): Hash := Hash - Value of String[Curr] //here Curr denotes First Letter of Previous String Hash := Hash / Prime m := String.length New := Curr + m - 1 Hash := Hash + (Value of String[New])ᵐ⁻¹ Return Hash
Procedure String-Match(Text, Pattern, m): for i from m to Pattern-length + m - 1 if Text[i] is not equal to Pattern[i] Return false end if end for Return true
Procedure Rabin-Karp(Text, Pattern, Prime): m := Pattern.Length HashValue := Calculate-Hash(Pattern, Prime, m) CurrValue := Calculate-Hash(Pattern, Prime, m) for i from 1 to Text.length - m if HashValue == CurrValue and String-Match(Text, Pattern, i) is true Return i end if CurrValue := Recalculate-Hash(String, i+1, Prime, CurrValue) end for Return -1
If the algorithm doesn't find any match, it simply returns -1.
This algorithm is used in detecting plagiarism. Given source material, the algorithm can rapidly search through a paper for instances of sentences from the source material, ignoring details such as case and punctuation. Because of the abundance of the sought strings, single-string searching algorithms are impractical here. Again, Knuth-Morris-Pratt algorithm or Boyer-Moore String Search algorithm is faster single pattern string searching algorithm, than Rabin-Karp. However, it is an algorithm of choice for multiple pattern search. If we want to find any of the large number, say k, fixed length patterns in a text, we can create a simple variant of the Rabin-Karp algorithm.
For text of length n and p patterns of combined length m, its average and best case running time is O(n+m) in space O(p), but its worst-case time is O(nm).