Adds BoyerMooreHorspool & Breadth First Search

Author: kelvinlauKL

SwiftAlgorithmClub/BoyerMooreHorspool.playground/Contents.swift

@@ -0,0 +1,88 @@
+//: Playground - noun: a place where people can play
+
+/*
+  Boyer-Moore string search
+
+  This code is based on the article "Faster String Searches" by Costas Menico
+  from Dr Dobb's magazine, July 1989.
+  http://www.drdobbs.com/database/faster-string-searches/184408171
+*/
+extension String {
+    func index(of pattern: String, usingHorspoolImprovement: Bool = false) -> Index? {
+        // Cache the length of the search pattern because we're going to
+        // use it a few times and it's expensive to calculate.
+        let patternLength = pattern.count
+        guard patternLength > 0, patternLength <= self.count else { return nil }
+
+        // Make the skip table. This table determines how far we skip ahead
+        // when a character from the pattern is found.
+        var skipTable = [Character: Int]()
+        for (i, c) in pattern.enumerated() {
+            skipTable[c] = patternLength - i - 1
+        }
+
+        // This points at the last character in the pattern.
+        let p = pattern.index(before: pattern.endIndex)
+        let lastChar = pattern[p]
+
+        // The pattern is scanned right-to-left, so skip ahead in the string by
+        // the length of the pattern. (Minus 1 because startIndex already points
+        // at the first character in the source string.)
+        var i = index(startIndex, offsetBy: patternLength - 1)
+
+        // This is a helper function that steps backwards through both strings
+        // until we find a character that doesn’t match, or until we’ve reached
+        // the beginning of the pattern.
+        func backwards() -> Index? {
+            var q = p
+            var j = i
+            while q > pattern.startIndex {
+                j = index(before: j)
+                q = index(before: q)
+                if self[j] != pattern[q] { return nil }
+            }
+            return j
+        }
+
+        // The main loop. Keep going until the end of the string is reached.
+        while i < endIndex {
+            let c = self[i]
+
+            // Does the current character match the last character from the pattern?
+            if c == lastChar {
+
+                // There is a possible match. Do a brute-force search backwards.
+                if let k = backwards() { return k }
+
+                if !usingHorspoolImprovement {
+                    // If no match, we can only safely skip one character ahead.
+                    i = index(after: i)
+                } else {
+                    // Ensure to jump at least one character (this is needed because the first
+                    // character is in the skipTable, and `skipTable[lastChar] = 0`)
+                    let jumpOffset = max(skipTable[c] ?? patternLength, 1)
+                    i = index(i, offsetBy: jumpOffset, limitedBy: endIndex) ?? endIndex
+                }
+            } else {
+                // The characters are not equal, so skip ahead. The amount to skip is
+                // determined by the skip table. If the character is not present in the
+                // pattern, we can skip ahead by the full pattern length. However, if
+                // the character *is* present in the pattern, there may be a match up
+                // ahead and we can't skip as far.
+                i = index(i, offsetBy: skipTable[c] ?? patternLength, limitedBy: endIndex) ?? endIndex
+            }
+        }
+        return nil
+    }
+}
+
+// A few simple tests
+
+let str = "Hello, World"
+str.index(of: "World")  // 7
+
+let animals = "🐶🐔🐷🐮🐱"
+animals.index(of: "🐮")  // 6
+
+let lorem = "Lorem ipsum dolor sit amet"
+lorem.index(of: "sit", usingHorspoolImprovement: true)  // 18

SwiftAlgorithmClub/BoyerMooreHorspool.playground/contents.xcplayground

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

SwiftAlgorithmClub/BoyerMooreHorspool.playground/playground.xcworkspace/contents.xcworkspacedata

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>IDEDidComputeMac32BitWarning</key>
+	<true/>
+</dict>
+</plist>

SwiftAlgorithmClub/BoyerMooreHorspool.playground/playground.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Timeline
+   version = "3.0">
+   <TimelineItems>
+      <LoggerValueHistoryTimelineItem
+         documentLocation = "file:///Users/neifmetus/Documents/Projects/swift-algorithm-club/Boyer-Moore-Horspool/BoyerMooreHorspool.playground#CharacterRangeLen=0&amp;CharacterRangeLoc=75&amp;EndingColumnNumber=21&amp;EndingLineNumber=2&amp;StartingColumnNumber=21&amp;StartingLineNumber=2&amp;Timestamp=560891520.806637"
+         selectedRepresentationIndex = "0"
+         shouldTrackSuperviewWidth = "NO">
+      </LoggerValueHistoryTimelineItem>
+      <LoggerValueHistoryTimelineItem
+         documentLocation = "file:///Users/neifmetus/Documents/Projects/swift-algorithm-club/Boyer-Moore-Horspool/BoyerMooreHorspool.playground#CharacterRangeLen=0&amp;CharacterRangeLoc=75&amp;EndingColumnNumber=21&amp;EndingLineNumber=2&amp;StartingColumnNumber=21&amp;StartingLineNumber=2&amp;Timestamp=560891520.806855"
+         selectedRepresentationIndex = "0"
+         shouldTrackSuperviewWidth = "NO">
+      </LoggerValueHistoryTimelineItem>
+      <LoggerValueHistoryTimelineItem
+         documentLocation = "file:///Users/neifmetus/Documents/Projects/swift-algorithm-club/Boyer-Moore-Horspool/BoyerMooreHorspool.playground#CharacterRangeLen=0&amp;CharacterRangeLoc=75&amp;EndingColumnNumber=21&amp;EndingLineNumber=2&amp;StartingColumnNumber=21&amp;StartingLineNumber=2&amp;Timestamp=560891520.807023"
+         selectedRepresentationIndex = "0"
+         shouldTrackSuperviewWidth = "NO">
+      </LoggerValueHistoryTimelineItem>
+   </TimelineItems>
+</Timeline>

SwiftAlgorithmClub/BoyerMooreHorspool.playground/timeline.xctimeline

@@ -0,0 +1,44 @@
+func breadthFirstSearch(_ graph: Graph, source: Node) -> [String] {
+  var queue = Queue<Node>()
+  queue.enqueue(source)
+
+  var nodesExplored = [source.label]
+  source.visited = true
+
+  while let node = queue.dequeue() {
+    for edge in node.neighbors {
+      let neighborNode = edge.neighbor
+      if !neighborNode.visited {
+        queue.enqueue(neighborNode)
+        neighborNode.visited = true
+        nodesExplored.append(neighborNode.label)
+      }
+    }
+  }
+
+  return nodesExplored
+}
+
+let graph = Graph()
+
+let nodeA = graph.addNode("a")
+let nodeB = graph.addNode("b")
+let nodeC = graph.addNode("c")
+let nodeD = graph.addNode("d")
+let nodeE = graph.addNode("e")
+let nodeF = graph.addNode("f")
+let nodeG = graph.addNode("g")
+let nodeH = graph.addNode("h")
+
+graph.addEdge(nodeA, neighbor: nodeB)
+graph.addEdge(nodeA, neighbor: nodeC)
+graph.addEdge(nodeB, neighbor: nodeD)
+graph.addEdge(nodeB, neighbor: nodeE)
+graph.addEdge(nodeC, neighbor: nodeF)
+graph.addEdge(nodeC, neighbor: nodeG)
+graph.addEdge(nodeE, neighbor: nodeH)
+graph.addEdge(nodeE, neighbor: nodeF)
+graph.addEdge(nodeF, neighbor: nodeG)
+
+let nodesExplored = breadthFirstSearch(graph, source: nodeA)
+print(nodesExplored)

SwiftAlgorithmClub/BreadthFirstSearch.playground/Pages/Simple example.xcplaygroundpage/Contents.swift

@@ -0,0 +1,11 @@
+public class Edge: Equatable {
+  public var neighbor: Node
+
+  public init(_ neighbor: Node) {
+    self.neighbor = neighbor
+  }
+}
+
+public func == (_ lhs: Edge, rhs: Edge) -> Bool {
+  return lhs.neighbor == rhs.neighbor
+}

SwiftAlgorithmClub/BreadthFirstSearch.playground/Sources/Edge.swift

@@ -0,0 +1,53 @@
+public class Graph: CustomStringConvertible, Equatable {
+  public private(set) var nodes: [Node]
+
+  public init() {
+    self.nodes = []
+  }
+
+  @discardableResult public func addNode(_ label: String) -> Node {
+    let node = Node(label)
+    nodes.append(node)
+    return node
+  }
+
+  public func addEdge(_ source: Node, neighbor: Node) {
+    let edge = Edge(neighbor)
+    source.neighbors.append(edge)
+  }
+
+  public var description: String {
+    var description = ""
+
+    for node in nodes where !node.neighbors.isEmpty {
+      description += "[node: \(node.label) edges: \(node.neighbors.map { $0.neighbor.label})]"
+    }
+    return description
+  }
+
+  public func findNodeWithLabel(_ label: String) -> Node {
+    return nodes.filter { $0.label == label }.first!
+  }
+
+  public func duplicate() -> Graph {
+    let duplicated = Graph()
+
+    for node in nodes {
+      duplicated.addNode(node.label)
+    }
+
+    for node in nodes {
+      for edge in node.neighbors {
+        let source = duplicated.findNodeWithLabel(node.label)
+        let neighbour = duplicated.findNodeWithLabel(edge.neighbor.label)
+        duplicated.addEdge(source, neighbor: neighbour)
+      }
+    }
+
+    return duplicated
+  }
+}
+
+public func == (_ lhs: Graph, rhs: Graph) -> Bool {
+  return lhs.nodes == rhs.nodes
+}

SwiftAlgorithmClub/BreadthFirstSearch.playground/Sources/Graph.swift

@@ -0,0 +1,32 @@
+public class Node: CustomStringConvertible, Equatable {
+  public var neighbors: [Edge]
+
+  public private(set) var label: String
+  public var distance: Int?
+  public var visited: Bool
+
+  public init(_ label: String) {
+    self.label = label
+    neighbors = []
+    visited = false
+  }
+
+  public var description: String {
+    if let distance = distance {
+      return "Node(label: \(label), distance: \(distance))"
+    }
+    return "Node(label: \(label), distance: infinity)"
+  }
+
+  public var hasDistance: Bool {
+    return distance != nil
+  }
+
+  public func remove(_ edge: Edge) {
+    neighbors.remove(at: neighbors.firstIndex { $0 === edge }!)
+  }
+}
+
+public func == (_ lhs: Node, rhs: Node) -> Bool {
+  return lhs.label == rhs.label && lhs.neighbors == rhs.neighbors
+}

SwiftAlgorithmClub/BreadthFirstSearch.playground/Sources/Node.swift

@@ -0,0 +1,31 @@
+public struct Queue<T> {
+  private var array: [T]
+
+  public init() {
+    array = []
+  }
+
+  public var isEmpty: Bool {
+    return array.isEmpty
+  }
+
+  public var count: Int {
+    return array.count
+  }
+
+  public mutating func enqueue(_ element: T) {
+    array.append(element)
+  }
+
+  public mutating func dequeue() -> T? {
+    if isEmpty {
+      return nil
+    } else {
+      return array.removeFirst()
+    }
+  }
+
+  public func peek() -> T? {
+    return array.first
+  }
+}