**Problem : **
Give the best, average, and worst case efficiencies of both the brute-force
string search and Rabin-Karp string search.

**Problem : **
How does Rabin-Karp achieve an efficiency of
*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*)
.

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

Use the function prototype:long hash_str(hash_table_t *hashtable, int hash_len, char *start) { long hval; int i; /* If the string passed in is NULL, return 0 */ if (start == NULL) return 0; /* Multiply the old hash value by 257 and add the current character * for as long as the string */ hval = 0L; for(i=0; i < hash_len; i++) { hval = ((257 * hval) + start[i]) % hashtable->size; } /* Return the hash value */ return hval; }

long hash_update( long hval, /* old hash value */ char start, /* character to be removed */ char end, /* character to be added */ int hash_len, /* length of the string */ hash_table_t *hashtable ); /* the hash table */

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.

As every string hashes to the same number, Rabin-Karp will not save anything over Brute-force. Of course, this is a terrible hash function and you would never want to use it.int hash(hash_table_t *hashtable, char *str) { return 220; } int hash_update(hash_table_t *hashtable, char *str) { return 220; }