Rolling Hash
Concept of Rolling Hash
Rolling Hash is an algorithmic technique often used for pattern matching or substring searching. The primary idea is to use a hash function that allows for efficient recalculation when moving from one substring to the next. This is accomplished by “rolling” through the string, updating the hash value incrementally instead of recomputing it from scratch.
In many applications, like the RabinKarp algorithm for string matching, Rolling Hash enables us to achieve a time complexity better than a naive approach would allow. It is particularly useful when dealing with large strings or multiple queries.
Example Code
Java


C++


Python


Key Takeaways
Incremental Update: Rolling Hash allows for efficient recalculation of hash values as you slide through substrings.
Modular Arithmetic: The use of a modulo operation ensures that the hash value stays within a certain range, avoiding overflow.
Versatility: Rolling Hash is an essential part of algorithms like RabinKarp and can be applied in various string processing problems.
Constants: The
BASE
andMOD
constants can be chosen according to the needs of the problem. Common choices are powers of 256 forBASE
and large prime numbers forMOD
.
The Rolling Hash technique simplifies complex string operations, making it a valuable tool in algorithmic problemsolving.
A rolling hash is a technique to efficiently calculate hash codes for sliding windows in a sequence. As the window slides, the hash is updated in O(1) time.
Some applications are:
 String matching
 Plagiarism detection
 Data stream processing
Java example:


C++ example:


Python example:


Rolling hashes efficiently compute and update hash codes for sliding windows.
The rolling hash is an efficient string matching algorithm used to find duplicate substrings or patterns in a continuously changing stream of text.
The key ideas behind a rolling hash are:
 It represents a string as a numerical value called a hash.
 It can compute the new hash of a string after appending or removing a character in O(1) time by doing simple math on the current hash.
 By comparing hash values, it can detect if two strings are identical without comparing character by character.
Some example pseudocode:
prime = large prime number
window_size = length of substring to match
init_hash = 0
for i = 0 to window_size:
init_hash += s[i] * prime^i
for i = window_size to end:
// Remove oldest char from hash
curr_hash = curr_hash  s[i  window_size] * prime^(window_size1)
// Add newest char
curr_hash = curr_hash * prime + s[i]
if curr_hash == init_hash:
print "Match found"
The key steps are:
 Initialize hash based on first substring
 Update hash by removing oldest char and adding newest char
 Compare current hash to target to check for match
This avoids needing to compare strings directly each time. Overall time complexity is O(n) for string of length n.
Rolling hashes are useful for plagiarism detection, DNA sequence analysis, and other applications requiring efficient string matching.