#include <string.h>

static long double rolling_hash(long double hashval, long double val, char s, char e);
static long double hash(char *s, int m);

int string_index_4(char *s, int slen, char *p, int plen)
{
	int i;
	long double hsub, hs, pow;

	/* sanity check */
	if(!s || !p || plen <= 0)
		return -1;

	for(i = 1, pow = 1; i <= (plen-1); i++)
		pow = pow * 256;

	/* calculate hash for sub-string and string */
	hs = hash(s, plen);
	hsub = hash(p, plen);

	/* search sub-string */
	for(i = 0; i <= (slen - plen); i++)
	{
		if(hs == hsub)
			if(strncmp(&s[i], p, plen) == 0)
				return i+1;

		hs = rolling_hash(hs, pow, s[i], s[i+plen]);
	}

	return -1;
}

static long double hash(char *s, int m)
{
	int i;
	long double hashval;
	for(hashval = 0.0, i = 0; s[i] != '\0' && i < m; i++)
		hashval = 256 * hashval + s[i];

	return hashval;
}

static long double rolling_hash(long double hashval, long double val, char s, char e)
{
	hashval = hashval - s * val;
	hashval = hashval * 256 + e;
	return hashval;
}

import Data.Char
import Data.List

asciis :: String -> [Integer]
asciis = map (fromIntegral . ord)

hash :: Num a => [a] -> a
hash = sum . zipWith (*) (iterate (* 256) 1) . reverse

hashes :: Int -> String -> [Integer]
hashes p xs = scanl (\s (f,t) -> 256*s - 256^p*f + t) (hash $ take p ascs) .
              zip ascs $ drop p ascs where ascs = asciis xs

rabinKarp :: String -> Maybe Int -> String -> Maybe Int
rabinKarp p s = lookup (hash $ asciis p) . drop (maybe 0 id s) .
                flip zip [0..] . hashes (length p)