         self.anagramDictionary = anagramDictionary
     }
     
-    
-    typealias OffsetIndexValueMap = [Int: (index: Int, value: Character?)]
-    private func charactersAt(x: Int, y: Int, length: Int, horizontal: Bool) -> OffsetIndexValueMap? {
+    private func charactersAt(x: Int, y: Int, length: Int, horizontal: Bool) -> [Int: Character]? {
         let size = board.config.size
-        var filled = OffsetIndexValueMap()
+        var fixedLetters = [Int: Character]()
         var index = 0
         var offset = boardState[horizontal][y][x]
-        let getValue = { self.board.letterAt(horizontal ? offset : x, horizontal ? y : offset) }
-        let addValue = {
-            if offset < size {
-                filled[offset] = (index, getValue())
+       
+        func addCharacter(mustExist: Bool, incrementAlways: Bool) -> Bool {
+            if offset >= size { return false }
+            var didExist = false
+            if let value = board.letterAt(horizontal ? offset : x, horizontal ? y : offset) {
+                fixedLetters[index] = value
+                didExist = true
+            }
+            if incrementAlways || didExist {
                 index += 1
                 offset += 1
             }
-        }
-        let collect = {
-            while offset < size && getValue() != nil {
-                addValue()
-            }
-        }
-        collect()
-        (0..<length).forEach{ _ in addValue() }
-        collect()
-        return filled.count == 0 ? nil : filled
+            return mustExist == true ? didExist : true
+        }
+
+        while addCharacter(true, incrementAlways: false) { }
+        for _ in 0..<length { addCharacter(false, incrementAlways: true) }
+        while addCharacter(true, incrementAlways: false) { }
+        
+        return length != index ? nil : fixedLetters
     }
     
     private func wordAt(x: Int, y: Int, string: String, horizontal: Bool) -> (word: Word, valid: Bool)? {

        return dropped
    }
    
    func validate(points: [(x: Int, y: Int, letter: Character)], blanks: [(x: Int, y: Int)]) -> ValidationResponse {
        let allBlanks = board.playedBlanks + blanks
        if points.count == 0 {

            if !isHorizontal && !isVertical {
                return .InvalidArrangement
            }
            // TODO: Cleanup duplication based on orientation here...
            if isHorizontal {
                let x = horizontalFirst.x
                let y = verticalFirst.y
