Breaking News: Grepper is joining You.com. Read the official announcement!

In this challenge, you will be given a list of strings that you need to find in the 2D grid. Neighboring characters can be combined to form strings. Remember that the diagonals are not included in neighboring characters; only up, down, right, and left nei

Sumit Rawal answered on September 8, 2023 Popularity 1/10 Helpfulness 1/10

answer In this challenge, you will be given a list of strings that you need to find in the 2D grid. Neighboring characters can be combined to form strings. Remember that the diagonals are not included in neighboring characters; only up, down, right, and left nei

In this challenge, you will be given a list of strings that you need to find in the 2D grid. Neighboring characters can be combined to form strings. Remember that the diagonals are not included in neighboring characters; only up, down, right, and left nei

Comment

import scala.collection.mutable

object WordSearchInGridWithTrie {
  // Definition for a Trie Node
  class TrieNode {
    val children: mutable.Map[Char, TrieNode] = mutable.Map()
    var isEndOfWord: Boolean = false
  }

  // Definition for a Trie
  class Trie {
    val root: TrieNode = new TrieNode()

    def insert(word: String): Unit = {
      var node = root
      for (char <- word) {
        if (!node.children.contains(char)) {
          node.children(char) = new TrieNode()
        }
        node = node.children(char)
      }
      node.isEndOfWord = true
    }
  }

  def main(args: Array[String]): Unit = {
    val board = Array(
      Array('o', 'a', 'a', 'n'),
      Array('e', 't', 'a', 'e'),
      Array('i', 'h', 'k', 'r'),
      Array('i', 'f', 'l', 'v')
    )
    val words = Array("oath", "pea", "eat", "rain")

    val foundWords = findWords(board, words)

    println("Words found in the board:")
    foundWords.foreach(println)
  }

  def findWords(board: Array[Array[Char]], words: Array[String]): List[String] = {
    val trie = new Trie()

    // Build the Trie with all the target words
    words.foreach(trie.insert)

    val foundWords = scala.collection.mutable.Set[String]()

    def backtrack(node: TrieNode, row: Int, col: Int, path: StringBuilder): Unit = {
      val char = board(row)(col)
      val child = node.children.getOrElse(char, null)

      if (child != null) {
        path.append(char)
        board(row)(col) = ' ' // Mark the cell as visited

        if (child.isEndOfWord) {
          foundWords += path.toString()
          child.isEndOfWord = false // Avoid duplicate entries
        }

        val directions = Array((-1, 0), (1, 0), (0, -1), (0, 1))
        for ((dr, dc) <- directions) {
          val newRow = row + dr
          val newCol = col + dc

          if (newRow >= 0 && newRow < board.length && newCol >= 0 && newCol < board(0).length) {
            backtrack(child, newRow, newCol, path)
          }
        }

        path.deleteCharAt(path.length - 1) // Backtrack
        board(row)(col) = char // Restore the cell
      }
    }

    for (row <- board.indices) {
      for (col <- board(0).indices) {
        backtrack(trie.root, row, col, new StringBuilder())
      }
    }

    foundWords.toList
  }
}

Popularity 1/10 Helpfulness 1/10 Language scala

Source: chat.openai.com

Tags: 2d find list scala this

Link to this answer
Share Copy Link

Contributed on Sep 08 2023

Sumit Rawal

0 Answers Avg Quality 2/10

In this challenge, you will be given a list of strings that you need to find in the 2D grid. Neighboring characters can be combined to form strings. Remember that the diagonals are not included in neighboring characters; only up, down, right, and left nei

Contents

More Related Answers

In this challenge, you will be given a list of strings that you need to find in the 2D grid. Neighboring characters can be combined to form strings. Remember that the diagonals are not included in neighboring characters; only up, down, right, and left nei

Grepper

Documentation

Social

Legal

Contact

Oops, You will need to install Grepper and log-in to perform this action.