Switched to Double to handle large prime

multiplier

Author: Bill Barbour

README.markdown

@@ -56,7 +56,7 @@ If you're new to algorithms and data structures, here are a few good ones to sta
 - [Brute-Force String Search](Brute-Force String Search/). A naive method.
 - [Boyer-Moore](Boyer-Moore/). A fast method to search for substrings. It skips ahead based on a look-up table, to avoid looking at every character in the text.
 - Knuth-Morris-Pratt
-- Rabin-Karp
+- [Rabin-Karp](Rabin-Karp/)  Faster search by using hashing.
 - [Longest Common Subsequence](Longest Common Subsequence/). Find the longest sequence of characters that appear in the same order in both strings.
 
 ### Sorting

Rabin-Karp/README.markdown

@@ -0,0 +1,79 @@
+# Rabin-Karp string search algorithm
+
+The Rabin-Karp string search alogrithm is used to search text for a pattern.
+
+Algorithms that check for palindromes are a common programming interview question.
+
+## Example
+
+Given a text of "The big dog jumped over the fox" and a search pattern of "ump" this will return 13.
+It starts by hashing "ump" then hashing "The".  If hashed don't match then it slides the window a character
+at a time (e.g. "he ") and subtracts out the previous hash from the "T".
+
+## Algorithm
+
+The Rabin-Karp alogrithm uses a sliding window the size of the search pattern.  It starts by hashing the search pattern, then
+hashing the first x characters of the text string where x is the length of the search pattern.  It then slides the window one character over and uses
+the previous hash value to calculate the new hash faster.  Only when it finds a hash that matches the hash of the search pattern will it compare
+the two strings it see if they are the same (prevent a hash collision from producing a false positive)
+
+## The code
+
+The major search method is next.  More implementation details are in rabin-karp.swift
+
+```swift
+public func search(text: String , pattern: String) -> Int {
+    // convert to array of ints
+    let patternArray = pattern.characters.flatMap { $0.asInt }
+    let textArray = text.characters.flatMap { $0.asInt }
+
+    if textArray.count < patternArray.count {
+        return -1
+    }
+
+    let patternHash = hash(array: patternArray)
+    var endIdx = patternArray.count - 1
+    let firstChars = Array(textArray[0...endIdx])
+    let firstHash = hash(array: firstChars)
+
+    if (patternHash == firstHash) {
+        // Verify this was not a hash collison
+        if firstChars == patternArray {
+            return 0
+        }
+    }
+
+    var prevHash = firstHash
+    // Now slide the window across the text to be searched
+    for idx in 1...(textArray.count - patternArray.count) {
+        endIdx = idx + (patternArray.count - 1)
+        let window = Array(textArray[idx...endIdx])
+        let windowHash = nextHash(prevHash: prevHash, dropped: textArray[idx - 1], added: textArray[endIdx], patternSize: patternArray.count - 1)
+
+        if windowHash == patternHash {
+            if patternArray == window {
+                return idx
+            }
+        }
+
+        prevHash = windowHash
+    }
+
+    return -1
+}
+```
+
+This code can be tested in a playground using the following:
+
+```swift
+  search(text: "The big dog jumped"", "ump")
+```
+
+This will return 13 since ump is in the 13 position of the zero based string.
+
+## Additional Resources
+
+[Rabin-Karp Wikipedia](https://en.wikipedia.org/wiki/Rabin%E2%80%93Karp_algorithm)
+
+
+*Written by [Bill Barbour](https://github.com/brbatwork)*

Rabin-Karp/Rabin-Karp.playground/Contents.swift

@@ -0,0 +1,85 @@
+//: Taking our rabin-karp algorithm for a walk
+
+import UIKit
+
+struct Constants {
+    static let hashMultiplier = 69069
+}
+
+precedencegroup PowerPrecedence { higherThan: MultiplicationPrecedence }
+infix operator ** : PowerPrecedence
+func ** (radix: Int, power: Int) -> Int {
+    return Int(pow(Double(radix), Double(power)))
+}
+func ** (radix: Double, power: Int) -> Double {
+    return pow(radix, Double(power))
+}
+
+extension Character {
+    var asInt:Int {
+        let s = String(self).unicodeScalars
+        return Int(s[s.startIndex].value)
+    }
+}
+
+// Find first position of pattern in the text using Rabin Karp algorithm
+public func search(text: String , pattern: String) -> Int {
+    // convert to array of ints
+    let patternArray = pattern.characters.flatMap { $0.asInt }
+    let textArray = text.characters.flatMap { $0.asInt }
+    
+    if textArray.count < patternArray.count {
+        return -1
+    }
+    
+    let patternHash = hash(array: patternArray)
+    var endIdx = patternArray.count - 1
+    let firstChars = Array(textArray[0...endIdx])
+    let firstHash = hash(array: firstChars)
+    
+    if (patternHash == firstHash) {
+        // Verify this was not a hash collison
+        if firstChars == patternArray {
+            return 0
+        }
+    }
+    
+    var prevHash = firstHash
+    // Now slide the window across the text to be searched
+    for idx in 1...(textArray.count - patternArray.count) {
+        endIdx = idx + (patternArray.count - 1)
+        let window = Array(textArray[idx...endIdx])
+        let windowHash = nextHash(prevHash: prevHash, dropped: textArray[idx - 1], added: textArray[endIdx], patternSize: patternArray.count - 1)
+        
+        if windowHash == patternHash {
+            if patternArray == window {
+                return idx
+            }
+        }
+        
+        prevHash = windowHash
+    }
+    
+    return -1
+}
+
+public func hash(array: Array<Int>) -> Double {
+    var total : Double = 0
+    var exponent = array.count - 1
+    for i in array {
+        total += Double(i) * (Double(Constants.hashMultiplier) ** exponent)
+        exponent -= 1
+    }
+    
+    return Double(total)
+}
+
+public func nextHash(prevHash: Double, dropped: Int, added: Int, patternSize: Int) -> Double {
+    let oldHash = prevHash - (Double(dropped) * (Double(Constants.hashMultiplier) ** patternSize))
+    return Double(Constants.hashMultiplier) * oldHash + Double(added)
+}
+
+// TESTS
+assert(search(text:"The big dog jumped over the fox", pattern:"ump") == 13, "Invalid index returned")
+assert(search(text:"The big dog jumped over the fox", pattern:"missed") == Int(-1), "Invalid index returned")
+assert(search(text:"The big dog jumped over the fox", pattern:"T") == 0, "Invalid index returned")

Rabin-Karp/Rabin-Karp.playground/contents.xcplayground

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<playground version='5.0' target-platform='ios'>
+    <timeline fileName='timeline.xctimeline'/>
+</playground>

Rabin-Karp/Rabin-Karp.playground/playground.xcworkspace/contents.xcworkspacedata

@@ -0,0 +1,103 @@
+// The MIT License (MIT)
+
+// Copyright (c) 2016 Bill Barbour (brbatwork[at]gmail.com)
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+struct Constants {
+    static let hashMultiplier = 69069
+}
+
+precedencegroup PowerPrecedence { higherThan: MultiplicationPrecedence }
+infix operator ** : PowerPrecedence
+func ** (radix: Int, power: Int) -> Int {
+    return Int(pow(Double(radix), Double(power)))
+}
+func ** (radix: Double, power: Int) -> Double {
+    return pow(radix, Double(power))
+}
+
+extension Character {
+    var asInt:Int {
+        let s = String(self).unicodeScalars
+        return Int(s[s.startIndex].value)
+    }
+}
+
+// Find first position of pattern in the text using Rabin Karp algorithm
+public func search(text: String , pattern: String) -> Int {
+    // convert to array of ints
+    let patternArray = pattern.characters.flatMap { $0.asInt }
+    let textArray = text.characters.flatMap { $0.asInt }
+
+    if textArray.count < patternArray.count {
+        return -1
+    }
+
+    let patternHash = hash(array: patternArray)
+    var endIdx = patternArray.count - 1
+    let firstChars = Array(textArray[0...endIdx])
+    let firstHash = hash(array: firstChars)
+
+    if (patternHash == firstHash) {
+        // Verify this was not a hash collison
+        if firstChars == patternArray {
+            return 0
+        }
+    }
+
+    var prevHash = firstHash
+    // Now slide the window across the text to be searched
+    for idx in 1...(textArray.count - patternArray.count) {
+        endIdx = idx + (patternArray.count - 1)
+        let window = Array(textArray[idx...endIdx])
+        let windowHash = nextHash(prevHash: prevHash, dropped: textArray[idx - 1], added: textArray[endIdx], patternSize: patternArray.count - 1)
+
+        if windowHash == patternHash {
+            if patternArray == window {
+                return idx
+            }
+        }
+
+        prevHash = windowHash
+    }
+
+    return -1
+}
+
+public func hash(array: Array<Int>) -> Double {
+    var total : Double = 0
+    var exponent = array.count - 1
+    for i in array {
+        total += Double(i) * (Double(Constants.hashMultiplier) ** exponent)
+        exponent -= 1
+    }
+
+    return Double(total)
+}
+
+public func nextHash(prevHash: Double, dropped: Int, added: Int, patternSize: Int) -> Double {
+    let oldHash = prevHash - (Double(dropped) * (Double(Constants.hashMultiplier) ** patternSize))
+    return Double(Constants.hashMultiplier) * oldHash + Double(added)
+}
+
+// TESTS
+assert(search(text:"The big dog jumped over the fox", pattern:"ump") == 13, "Invalid index returned")
+assert(search(text:"The big dog jumped over the fox", pattern:"missed") == -1, "Invalid index returned")
+assert(search(text:"The big dog jumped over the fox", pattern:"T") == 0, "Invalid index returned")