Merge pull request ByteByteGoHq#14 from marttp/kotlin-trie

Kotlin Chapter 12: Tries

Author: Destiny-02

kotlin/Tries/DesignATrie.kt

@@ -0,0 +1,50 @@
+data class TrieNode(
+    var isWord: Boolean = false,
+    val children: HashMap<Char, TrieNode> = hashMapOf()
+)
+
+class Trie {
+    val root = TrieNode()
+
+    fun insert(word: String) {
+        var node = root
+        for (c in word.toCharArray()) {
+            // For each character in the word, if it's not a child of
+            // the current node, create a new TrieNode for that
+            // character.
+            if (c !in node.children) {
+                node.children[c] = TrieNode()
+            }
+            node = node.children[c]!!
+        }
+        // Mark the last node as the end of a word.
+        node.isWord = true
+    }
+
+    fun search(word: String): Boolean {
+        var node = root
+        for (c in word.toCharArray()) {
+            // For each character in the word, if it's not a child of
+            // the current node, the word doesn't exist in the Trie.
+            if (c !in node.children) {
+                return false
+            }
+            node = node.children[c]!!
+        }
+        // Return whether the current node is marked as the end of the word.
+        return node.isWord
+    }
+
+    fun hasPrefix(prefix: String): Boolean {
+        var node = root
+        for (c in prefix.toCharArray()) {
+            if (c !in node.children) {
+                return false
+            }
+            node = node.children[c]!!
+        }
+        // Once we've traversed the nodes corresponding to each
+        // character in the prefix, return True.
+        return true
+    }
+}

kotlin/Tries/FindAllWordsOnABoard.kt

@@ -0,0 +1,60 @@
+data class TrieNode(
+    var word: String? = null,
+    val children: HashMap<Char, TrieNode> = hashMapOf()
+)
+
+fun findAllWordsOnABoard(board: Array<CharArray>, words: List<String>): List<String> {
+    val root = TrieNode()
+    // Insert every word into the trie.
+    for (word in words) {
+        var node = root
+        for (c in word.toCharArray()) {
+            if (c !in node.children) {
+                node.children[c] = TrieNode()
+            }
+            node = node.children[c]!!
+        }
+        node.word = word
+    }
+    val res = mutableListOf<String>()
+    // Start a DFS call from each cell of the board that contains a
+    // child of the root node, which represents the first letter of a
+    // word in the trie.
+    for (r in 0 until board.size) {
+        for (c in 0 until board[0].size) {
+            if (board[r][c] in root.children) {
+                dfs(board, r, c, root.children[board[r][c]], res)
+            }
+        }
+    }
+    return res
+}
+
+fun dfs(board: Array<CharArray>, r: Int, c: Int, node: TrieNode?, res: MutableList<String>) {
+    // If the current node represents the end of a word, add the word to
+    // the result.
+    if (node?.word != null) {
+        res.add(node.word!!)
+        // Ensure the current word is only added once.
+        node.word = null
+    }
+    val temp = board[r][c]
+    // Mark the current cell as visited.
+    board[r][c] = '#'
+    // Explore all adjacent cells that correspond with a child of the
+    // current TrieNode.
+    val dirs = listOf(-1 to 0, 1 to 0, 0 to -1, 0 to 1)
+    for ((dr, dc) in dirs) {
+        val nextR = r + dr
+        val nextC = c + dc
+        if (isWithinBounds(board, nextR, nextC) && board[nextR][nextC] in node?.children.orEmpty()) {
+            dfs(board, nextR, nextC, node?.children?.get(board[nextR][nextC]), res)
+        }
+        // Backtrack by reverting the cell back to its original character.
+        board[r][c] = temp
+    }
+}
+
+fun isWithinBounds(board: Array<CharArray>, r: Int, c: Int): Boolean {
+    return r in board.indices && c in board[0].indices
+}

kotlin/Tries/InsertAndSearchWordsWithWildcards.kt

@@ -0,0 +1,46 @@
+data class TrieNode(
+    var isWord: Boolean = false,
+    val children: HashMap<Char, TrieNode> = hashMapOf()
+)
+
+class InsertAndSearchWordsWithWildcards {
+    private val root = TrieNode()
+
+    fun insert(word: String) {
+        var node = root
+        for (c in word) {
+            if (c !in node.children) {
+                node.children[c] = TrieNode()
+            }
+            node = node.children[c]!!
+        }
+        node.isWord = true
+    }
+
+    fun search(word: String): Boolean {
+        // Start searching from the root of the trie.
+        return searchHelper(0, word, root)
+    }
+
+    fun searchHelper(wordIndex: Int, word: String, node: TrieNode): Boolean {
+        var node = node
+        for (i in wordIndex until word.length) {
+            val c = word[i]
+            if (c == '.') {
+                for (child in node.children.values) {
+                    // If a match is found, return true.
+                    if (searchHelper(i + 1, word, child)) {
+                        return true
+                    }
+                }
+            } else if (c in node.children) {
+                node = node.children[c]!!
+            } else {
+                return false
+            }
+            // After processing the last character, return true if we've
+            // reached the end of a word.
+        }
+        return node.isWord
+    }
+}