The intial hash is O(N). After that, each update is O(1), and there
are O(N) updates. Sometimes we need to do O(M) work when the hash
values match, but we can ignore as a good hash function will not cause
many collisions. So O(M) + O(1)*O(N) = O(M) + O(N) = O(M + N).

Problem :
Using the hash() and hash_update() functions given in this section, give
an example of a pattern string and text string that will reduce Rabin-Karp
back to brute-force search, decreasing its efficiency back to O(MN).

Pattern string = "aabb"
Text string = "abababababababababaabb"
Because the hash function we're using only sums the letters, this pattern
will match the hash at almost every location in the text string as almost
every position has two a's and two b's.

Problem :
Challenge problem: Create a hash_update() function to go along with this
hash() function:

long hash_update(
long hval,
char start,
char end,
int hash_len,
hash_table_t *hashtable )
{
/* Based on the length of the string, compute how many times the far
* left character (the one being removed) was multiplied by 257.
* NOTE: In a real implementation of this, you would want to do this as
* a precomputational step so that you wouldn't have to do it every time
* this function was called
*/
long mul_fac = 1;
for(i=0; i<hash_len; i++) {
mul_fac = (mul_fac * 257) % hashtable->size;
}
/* Determine the value of the oldest character after it was multiplied */
long oldest = (mul_fac * start) % hashtable->size;
/* Subtract it from the current hash value to remove it */
long oldest_removed = ((hval + hashtable->size) - oldest)
% hashtable->size;
/* Add in the new character as you would in the normal hash function */
hval = ((257 * oldest_removed) + end) % hashtable->size;
/* Return the new hash value */
return hval;
}

Problem :
Give a hash function and a hash update function that will always reduce
Rabin-Karp to O(MN) efficiency.