diff --git a/src/algorithms/string/rabin-karp/__test__/rabinKarp.test.js b/src/algorithms/string/rabin-karp/__test__/rabinKarp.test.js
index 5edefb955e..489149b322 100644
--- a/src/algorithms/string/rabin-karp/__test__/rabinKarp.test.js
+++ b/src/algorithms/string/rabin-karp/__test__/rabinKarp.test.js
@@ -1,24 +1,20 @@
-import { rabinKarp, hashWord, reHashWord } from '../rabinKarp';
+import rabinKarp from '../rabinKarp';
describe('rabinKarp', () => {
- it('should correctly calculates hash and re-hash', () => {
- expect(hashWord('a')).toBe(97);
- expect(hashWord('b')).toBe(98);
- expect(hashWord('abc')).toBe(941094);
- expect(hashWord('bcd')).toBe(950601);
- expect(reHashWord(hashWord('abc'), 'abc', 'bcd')).toBe(950601);
- expect(reHashWord(hashWord('abc'), 'abc', 'bcd')).toBe(hashWord('bcd'));
- });
-
it('should find substring in a string', () => {
expect(rabinKarp('', '')).toBe(0);
expect(rabinKarp('a', '')).toBe(0);
expect(rabinKarp('a', 'a')).toBe(0);
+ expect(rabinKarp('ab', 'b')).toBe(1);
expect(rabinKarp('abcbcglx', 'abca')).toBe(-1);
expect(rabinKarp('abcbcglx', 'bcgl')).toBe(3);
expect(rabinKarp('abcxabcdabxabcdabcdabcy', 'abcdabcy')).toBe(15);
expect(rabinKarp('abcxabcdabxabcdabcdabcy', 'abcdabca')).toBe(-1);
expect(rabinKarp('abcxabcdabxaabcdabcabcdabcdabcy', 'abcdabca')).toBe(12);
expect(rabinKarp('abcxabcdabxaabaabaaaabcdabcdabcy', 'aabaabaaa')).toBe(11);
+ expect(rabinKarp('^ !/\'#\'pp', ' !/\'#\'pp')).toBe(1);
+ expect(rabinKarp('a\u{ffff}', '\u{ffff}')).toBe(1);
+ expect(rabinKarp('a\u{10000}', '\u{10000}')).toBe(1);
+ expect(rabinKarp('\u0000耀\u0000', '耀\u0000')).toBe(1);
});
});
diff --git a/src/algorithms/string/rabin-karp/rabinKarp.js b/src/algorithms/string/rabin-karp/rabinKarp.js
index e6c544facb..378e5acb12 100644
--- a/src/algorithms/string/rabin-karp/rabinKarp.js
+++ b/src/algorithms/string/rabin-karp/rabinKarp.js
@@ -1,88 +1,33 @@
-/**
- * A prime number used to create
- * the hash representation of a word
- *
- * Bigger the prime number,
- * bigger the hash value
- */
-const PRIME = 97;
-
-/**
- * Function that creates hash representation of the word.
- *
- * @param {string} word
- * @return {number}
- */
-export function hashWord(word) {
- let hash = 0;
-
- for (let charIndex = 0; charIndex < word.length; charIndex += 1) {
- hash += word[charIndex].charCodeAt(0) * (PRIME ** charIndex);
- }
-
- return hash;
-}
-
-/**
- * Function that creates hash representation of the word
- * based on previous word (shifted by one character left) hash value.
- *
- * Recalculates the hash representation of a word so that it isn't
- * necessary to traverse the whole word again
- *
- * @param {number} prevHash
- * @param {string} prevWord
- * @param {string} newWord
- * @return {number}
- */
-export function reHashWord(prevHash, prevWord, newWord) {
- const newWordLastIndex = newWord.length - 1;
- let newHash = prevHash - prevWord[0].charCodeAt(0);
- newHash /= PRIME;
- newHash += newWord[newWordLastIndex].charCodeAt(0) * (PRIME ** newWordLastIndex);
-
- return newHash;
-}
+import RabinFingerprint from '../../../utils/hash/rolling/Rabin_Fingerprint';
/**
* @param {string} text
* @param {string} word
* @return {number}
*/
-export function rabinKarp(text, word) {
- // Calculate word hash that we will use for comparison with other substring hashes.
- const wordHash = hashWord(word);
-
- let prevSegment = null;
- let currentSegmentHash = null;
-
- // Go through all substring of the text that may match
- for (let charIndex = 0; charIndex <= text.length - word.length; charIndex += 1) {
- const currentSegment = text.substring(charIndex, charIndex + word.length);
-
- // Calculate the hash of current substring.
- if (currentSegmentHash === null) {
- currentSegmentHash = hashWord(currentSegment);
- } else {
- currentSegmentHash = reHashWord(currentSegmentHash, prevSegment, currentSegment);
- }
-
- prevSegment = currentSegment;
-
- // Compare the hash of current substring and seeking string.
- if (wordHash === currentSegmentHash) {
- // In case if hashes match let's check substring char by char.
- let numberOfMatches = 0;
-
- for (let deepCharIndex = 0; deepCharIndex < word.length; deepCharIndex += 1) {
- if (word[deepCharIndex] === text[charIndex + deepCharIndex]) {
- numberOfMatches += 1;
- }
- }
+export default function rabinKarp(text, word) {
+ const toNum = function toNum(character) {
+ const surrogate = character.codePointAt(1);
+ return ((surrogate === undefined) ? 0 : surrogate) + (character.codePointAt(0) * (2 ** 16));
+ };
+ const arrEq = (a1, a2) => ((a1.length === a2.length) && a1.every((val, idx) => val === a2[idx]));
+
+ const wordArr = [...word].map(toNum);
+ const textArr = [...text].map(toNum);
+
+ // The prime generation function could depend on the inputs for collision guarantees.
+ const hasher = new RabinFingerprint(() => 229);
+ const cmpVal = hasher.init(wordArr);
+
+ let currHash = hasher.init(textArr.slice(0, wordArr.length));
+ if ((currHash === cmpVal) && arrEq(wordArr, textArr.slice(0, wordArr.length))) {
+ return 0;
+ }
- if (numberOfMatches === word.length) {
- return charIndex;
- }
+ for (let i = 0; i < (textArr.length - wordArr.length); i += 1) {
+ currHash = hasher.roll(textArr[i], textArr[i + wordArr.length]);
+ if ((currHash === cmpVal) && arrEq(wordArr, textArr.slice(i + 1, i + wordArr.length + 1))) {
+ return i + 1;
}
}
diff --git a/src/utils/hash/rolling/Rabin_Fingerprint.js b/src/utils/hash/rolling/Rabin_Fingerprint.js
new file mode 100644
index 0000000000..b854af0864
--- /dev/null
+++ b/src/utils/hash/rolling/Rabin_Fingerprint.js
@@ -0,0 +1,51 @@
+/**
+ * Generates fingerprints using Rabin scheme with x = 2 (for potential compiler optimizations).
+ * Guaranteed not to over or underflow if function assumptions are met.
+ */
+export default class RabinFingerprint {
+ /**
+ * @param { function() : number } [primeGenerator]
+ * @assumes Output from any function call is prime less than Number.MAX_SAFE_INTEGER / 2.
+ */
+ constructor(primeGenerator) {
+ this.prime = primeGenerator();
+ }
+
+ /**
+ * @param { array[number] } [values]
+ * @returns {number} - The hash value after digesting input.
+ * @assumes All array elements are non-negative.
+ * @note First element in array is considered to be oldest value.
+ */
+ init(values) {
+ this.val = 0;
+ this.len = values.length;
+
+ for (let i = 0; i < values.length; i += 1) {
+ this.val = (((this.val * 2) % this.prime) + (values[i] % this.prime)) % this.prime;
+ }
+
+ return this.val;
+ }
+
+ /*
+ * @param {number} [oldValue]
+ * @param {number} [newValue]
+ * @returns {number} - The hash value after removing the oldest value & inserting the newest.
+ * @assumes Instance has already been initialized.
+ * @assumes oldValue is the oldest value still processed by the hash.
+ * @assumes newValue is non-negative.
+ */
+ roll(oldValue, newValue) {
+ let oldVal = oldValue % this.prime;
+ for (let i = 1; i < this.len; i += 1) {
+ oldVal = (oldVal * 2) % this.prime;
+ }
+ this.val = (this.val + this.prime - (oldVal % this.prime)) % this.prime;
+
+ const newVal = newValue % this.prime;
+ this.val = (((this.val * 2) % this.prime) + (newVal % this.prime)) % this.prime;
+
+ return this.val;
+ }
+}
diff --git a/src/utils/hash/rolling/__test__/Rabin_Fingerprint.test.js b/src/utils/hash/rolling/__test__/Rabin_Fingerprint.test.js
new file mode 100644
index 0000000000..d96f124234
--- /dev/null
+++ b/src/utils/hash/rolling/__test__/Rabin_Fingerprint.test.js
@@ -0,0 +1,59 @@
+import RabinFingerprint from '../Rabin_Fingerprint';
+
+describe('Rabin fingerprint Hash Family', () => {
+ it('should hash deterministically', () => {
+ const primeVals = [3, 5, 19, 53, 97, 401, 7039, 193939];
+ for (let primeIdx = 0; primeIdx < primeVals.length; primeIdx += 1) {
+ const primeVal = primeVals[primeIdx];
+ const hasher = new RabinFingerprint(() => primeVal);
+
+ // Test basic values
+ expect(hasher.init([])).toEqual(0);
+ expect(hasher.init([1])).toEqual(1);
+
+ // Test overflow
+ const largeVal = Number.MAX_SAFE_INTEGER;
+ expect(hasher.init([primeVal])).toEqual(0);
+ expect(hasher.init([largeVal])).toEqual(largeVal % primeVal);
+
+ const numLargeVal = 2; // 2 ^ numLargeVal fits in javascript number
+ const largeValues = new Array(numLargeVal).fill(largeVal);
+
+ const expVal = ((largeVal % primeVal) * ((2 ** numLargeVal) - 1)) % primeVal;
+ expect(hasher.init(largeValues)).toEqual(expVal);
+
+ // Test using Fermat's little theorem
+ const fermatValues = new Array(primeVal).fill(primeVal);
+ const numFermatTests = 100;
+ for (let i = 0; i < numFermatTests; i += 1) {
+ const randomValue = Math.floor(Math.random() * largeVal);
+ fermatValues[0] = randomValue;
+ expect(hasher.init(fermatValues)).toEqual(randomValue % primeVal);
+ }
+ }
+ });
+
+ it('should roll appropriately', () => {
+ const primeVals = [3, 5, 19, 53, 97, 401, 7039, 193939];
+
+ for (let primeIdx = 0; primeIdx < primeVals.length; primeIdx += 1) {
+ const primeVal = primeVals[primeIdx];
+ const hasher = new RabinFingerprint(() => primeVal);
+
+ // Test basic values
+ const largeVal = Number.MAX_SAFE_INTEGER;
+ expect(hasher.init([0])).toEqual(0);
+ expect(hasher.roll(0, 1)).toEqual(1);
+ expect(hasher.roll(1, primeVal)).toEqual(0);
+ expect(hasher.roll(primeVal, largeVal)).toEqual(largeVal % primeVal);
+
+ const numRollTest = 100;
+ let previousValue = largeVal;
+ for (let i = 0; i < numRollTest; i += 1) {
+ const randomVal = Math.floor(Math.random() * largeVal);
+ expect(hasher.roll(previousValue, randomVal)).toEqual(randomVal % primeVal);
+ previousValue = randomVal;
+ }
+ }
+ });
+});