Skip to content
Related Articles
Open in App
Not now

Related Articles

Search a Word in a 2D Grid of characters

Improve Article
Save Article
  • Difficulty Level : Medium
  • Last Updated : 11 Jan, 2023
Improve Article
Save Article

Given a 2D grid of characters and a single word/an array of words, find all occurrences of the given word/words in the grid. A word can be matched in all 8 directions at any point. Word is said to be found in a direction if all characters match in this direction (not in zig-zag form).
The 8 directions are, Horizontally Left, Horizontally Right, Vertically Up, Vertically Down and 4 Diagonal directions.
Example: 

Input:  grid[][] = {"GEEKSFORGEEKS",
                    "GEEKSQUIZGEEK",
                    "IDEQAPRACTICE"};
        word = "GEEKS"

Output: pattern found at 0, 0
        pattern found at 0, 8
        pattern found at 1, 0
Explanation: 'GEEKS' can be found as prefix of
1st 2 rows and suffix of first row

Input:  grid[][] = {"GEEKSFORGEEKS",
                    "GEEKSQUIZGEEK",
                    "IDEQAPRACTICE"};
        word = "EEE"

Output: pattern found at 0, 2
        pattern found at 0, 10
        pattern found at 2, 2
        pattern found at 2, 12
Explanation: EEE can be found in first row 
twice at index 2 and index 10
and in second row at 2 and 12

Below diagram shows a bigger grid and presence of different words in it. 

wordsearch(1)

Source: Microsoft Interview Question.
 

Recommended Practice

Approach when a single word is given: The idea used here is simple, we check every cell. If cell has first character, then we one by one try all 8 directions from that cell for a match. Implementation is interesting though. We use two arrays x[] and y[] to find next move in all 8 directions. 
Below are implementation of the same:  

C++




// C++ programs to search a word in a 2D grid
#include <bits/stdc++.h>
using namespace std;
 
// For searching in all 8 direction
int x[] = { -1, -1, -1,  0, 0,  1, 1, 1 };
int y[] = { -1,  0,  1, -1, 1, -1, 0, 1 };
 
// This function searches in
// all 8-direction from point
// (row, col) in grid[][]
bool search2D(char *grid, int row, int col,
               string word, int R, int C)
{
    // If first character of word doesn't
    // match with given starting point in grid.
    if (*(grid+row*C+col) != word[0])
        return false;
 
    int len = word.length();
 
    // Search word in all 8 directions
    // starting from (row, col)
    for (int dir = 0; dir < 8; dir++) {
        // Initialize starting point
        // for current direction
        int k, rd = row + x[dir], cd = col + y[dir];
 
        // First character is already checked,
        // match remaining characters
        for (k = 1; k < len; k++) {
            // If out of bound break
            if (rd >= R || rd < 0 || cd >= C || cd < 0)
                break;
 
            // If not matched,  break
            if (*(grid+rd*C+cd) != word[k])
                break;
 
            // Moving in particular direction
            rd += x[dir], cd += y[dir];
        }
 
        // If all character matched, then value of k must
        // be equal to length of word
        if (k == len)
            return true;
    }
    return false;
}
 
// Searches given word in a given
// matrix in all 8 directions
void patternSearch(char *grid, string word,
                  int R, int C)
{
    // Consider every point as starting
    // point and search given word
    for (int row = 0; row < R; row++)
        for (int col = 0; col < C; col++)
            if (search2D(grid, row, col, word, R, C))
                cout << "pattern found at "
                     << row << ", "
                     << col << endl;
}
 
// Driver program
int main()
{
      int R = 3, C = 13;
    char grid[R][C] = { "GEEKSFORGEEKS",
                        "GEEKSQUIZGEEK",
                        "IDEQAPRACTICE" };
 
    patternSearch((char *)grid, "GEEKS", R, C);
    cout << endl;
    patternSearch((char *)grid, "EEE", R, C);
    return 0;
}


Java




// Java program to search
// a word in a 2D grid
import java.io.*;
import java.util.*;
 
class GFG {
 
    // Rows and columns in the given grid
    static int R, C;
 
    // For searching in all 8 direction
    static int[] x = { -1, -1, -1, 0, 0, 1, 1, 1 };
    static int[] y = { -1, 0, 1, -1, 1, -1, 0, 1 };
 
    // This function searches in all
    // 8-direction from point
    // (row, col) in grid[][]
    static boolean search2D(char[][] grid, int row,
                            int col, String word)
    {
        // If first character of word
        // doesn't match with
        // given starting point in grid.
        if (grid[row][col] != word.charAt(0))
            return false;
 
        int len = word.length();
 
        // Search word in all 8 directions
        // starting from (row, col)
        for (int dir = 0; dir < 8; dir++) {
            // Initialize starting point
            // for current direction
            int k, rd = row + x[dir], cd = col + y[dir];
 
            // First character is already checked,
            // match remaining characters
            for (k = 1; k < len; k++) {
                // If out of bound break
                if (rd >= R || rd < 0 || cd >= C || cd < 0)
                    break;
 
                // If not matched, break
                if (grid[rd][cd] != word.charAt(k))
                    break;
 
                // Moving in particular direction
                rd += x[dir];
                cd += y[dir];
            }
 
            // If all character matched,
            // then value of must
            // be equal to length of word
            if (k == len)
                return true;
        }
        return false;
    }
 
    // Searches given word in a given
    // matrix in all 8 directions
    static void patternSearch(
        char[][] grid,
        String word)
    {
        // Consider every point as starting
        // point and search given word
        for (int row = 0; row < R; row++) {
            for (int col = 0; col < C; col++) {
                if (grid[row][col]==word.charAt(0)  &&
                    search2D(grid, row, col, word))
                        System.out.println(
                            "pattern found at " + row + ", " + col);
            }
        }
    }
 
    // Driver code
    public static void main(String args[])
    {
        R = 3;
        C = 13;
        char[][] grid = { { 'G', 'E', 'E', 'K', 'S', 'F', 'O', 'R', 'G', 'E', 'E', 'K', 'S' },
                          { 'G', 'E', 'E', 'K', 'S', 'Q', 'U', 'I', 'Z', 'G', 'E', 'E', 'K' },
                          { 'I', 'D', 'E', 'Q', 'A', 'P', 'R', 'A', 'C', 'T', 'I', 'C', 'E' } };
        patternSearch(grid, "GEEKS");
        System.out.println();
        patternSearch(grid, "EEE");
    }
}
 
// This code is contributed by rachana soma


Python3




# Python3 program to search a word in a 2D grid
class GFG:
     
    def __init__(self):
        self.R = None
        self.C = None
        self.dir = [[-1, 0], [1, 0], [1, 1],
                    [1, -1], [-1, -1], [-1, 1],
                    [0, 1], [0, -1]]
                     
    # This function searches in all 8-direction
    # from point(row, col) in grid[][]
    def search2D(self, grid, row, col, word):
         
        # If first character of word doesn't match
        # with the given starting point in grid.
        if grid[row][col] != word[0]:
            return False
             
        # Search word in all 8 directions
        # starting from (row, col)
        for x, y in self.dir:
             
            # Initialize starting point
            # for current direction
            rd, cd = row + x, col + y
            flag = True
             
            # First character is already checked,
            # match remaining characters
            for k in range(1, len(word)):
                 
                # If out of bound or not matched, break
                if (0 <= rd <self.R and
                    0 <= cd < self.C and
                    word[k] == grid[rd][cd]):
                     
                    # Moving in particular direction
                    rd += x
                    cd += y
                else:
                    flag = False
                    break
             
            # If all character matched, then
            # value of flag must be false       
            if flag:
                return True
        return False
         
    # Searches given word in a given matrix
    # in all 8 directions   
    def patternSearch(self, grid, word):
         
        # Rows and columns in given grid
        self.R = len(grid)
        self.C = len(grid[0])
         
        # Consider every point as starting point
        # and search given word
        for row in range(self.R):
            for col in range(self.C):
                if self.search2D(grid, row, col, word):
                    print("pattern found at " +
                           str(row) + ', ' + str(col))
                     
# Driver Code
if __name__=='__main__':
    grid = ["GEEKSFORGEEKS",
            "GEEKSQUIZGEEK",
            "IDEQAPRACTICE"]
    gfg = GFG()
    gfg.patternSearch(grid, 'GEEKS')
    print('')
    gfg.patternSearch(grid, 'EEE')
     
# This code is contributed by Yezheng Li


C#




// C# program to search a word in a 2D grid
using System;
class GFG {
 
    // Rows and columns in given grid
    static int R, C;
 
    // For searching in all 8 direction
    static int[] x = { -1, -1, -1, 0, 0, 1, 1, 1 };
    static int[] y = { -1, 0, 1, -1, 1, -1, 0, 1 };
 
    // This function searches in all 8-direction
    // from point (row, col) in grid[, ]
    static bool search2D(char[, ] grid, int row,
                         int col, String word)
    {
        // If first character of word doesn't match
        // with given starting point in grid.
        if (grid[row, col] != word[0]) {
            return false;
        }
 
        int len = word.Length;
 
        // Search word in all 8 directions
        // starting from (row, col)
        for (int dir = 0; dir < 8; dir++) {
            // Initialize starting point
            // for current direction
            int k, rd = row + x[dir], cd = col + y[dir];
 
            // First character is already checked,
            // match remaining characters
            for (k = 1; k < len; k++) {
                // If out of bound break
                if (rd >= R || rd < 0 || cd >= C || cd < 0) {
                    break;
                }
 
                // If not matched, break
                if (grid[rd, cd] != word[k]) {
                    break;
                }
 
                // Moving in particular direction
                rd += x[dir];
                cd += y[dir];
            }
 
            // If all character matched, then value of k
            // must be equal to length of word
            if (k == len) {
                return true;
            }
        }
        return false;
    }
 
    // Searches given word in a given
    // matrix in all 8 directions
    static void patternSearch(char[, ] grid,
                              String word)
    {
        // Consider every point as starting
        // point and search given word
        for (int row = 0; row < R; row++) {
            for (int col = 0; col < C; col++) {
                if (search2D(grid, row, col, word)) {
                    Console.WriteLine("pattern found at " + row + ", " + col);
                }
            }
        }
    }
 
    // Driver code
    public static void Main(String[] args)
    {
        R = 3;
        C = 13;
        char[, ] grid = { { 'G', 'E', 'E', 'K', 'S', 'F', 'O',
                            'R', 'G', 'E', 'E', 'K', 'S' },
                          { 'G', 'E', 'E', 'K', 'S', 'Q', 'U',
                            'I', 'Z', 'G', 'E', 'E', 'K' },
                          { 'I', 'D', 'E', 'Q', 'A', 'P', 'R',
                            'A', 'C', 'T', 'I', 'C', 'E' } };
        patternSearch(grid, "GEEKS");
        Console.WriteLine();
        patternSearch(grid, "EEE");
    }
}
 
#This code is contributed by Rajput - Ji


Javascript




<script>
 
// JavaScript program to search
// a word in a 2D grid
 
 // Rows and columns in the given grid
let R, C;
 
// For searching in all 8 direction
let x=[-1, -1, -1, 0, 0, 1, 1, 1];
 
let y=[-1, 0, 1, -1, 1, -1, 0, 1];
 
// This function searches in all
    // 8-direction from point
    // (row, col) in grid[][]
function search2D(grid,row,col,word)
{
    // If first character of word
        // doesn't match with
        // given starting point in grid.
        if (grid[row][col] != word[0])
            return false;
  
        let len = word.length;
  
        // Search word in all 8 directions
        // starting from (row, col)
        for (let dir = 0; dir < 8; dir++) {
            // Initialize starting point
            // for current direction
            let k, rd = row + x[dir], cd = col + y[dir];
  
            // First character is already checked,
            // match remaining characters
            for (k = 1; k < len; k++) {
                // If out of bound break
                if (rd >= R || rd < 0 || cd >= C || cd < 0)
                    break;
  
                // If not matched, break
                if (grid[rd][cd] != word[k])
                    break;
  
                // Moving in particular direction
                rd += x[dir];
                cd += y[dir];
            }
  
            // If all character matched,
            // then value of must
            // be equal to length of word
            if (k == len)
                return true;
        }
        return false;
}
 
// Searches given word in a given
    // matrix in all 8 directions
function patternSearch( grid,word)
{
    // Consider every point as starting
        // point and search given word
        for (let row = 0; row < R; row++) {
            for (let col = 0; col < C; col++) {
                if (search2D(grid, row, col, word))
                    document.write(
                        "pattern found at " + row + ", " + col+"<br>");
            }
        }
}
 
// Driver code
R = 3;
C = 13;
let grid = [[ 'G', 'E', 'E', 'K', 'S', 'F', 'O',
'R', 'G', 'E', 'E', 'K', 'S' ],
 
[ 'G', 'E', 'E', 'K', 'S', 'Q', 'U', 'I', 'Z',
'G', 'E', 'E', 'K' ],
 
[ 'I', 'D', 'E', 'Q', 'A', 'P', 'R', 'A', 'C',
'T', 'I', 'C', 'E' ] ];
patternSearch(grid, "GEEKS");
document.write("<br>");
patternSearch(grid, "EEE");
 
 
// This code is contributed by avanitrachhadiya2155
</script>


Output

pattern found at 0, 0
pattern found at 0, 8
pattern found at 1, 0

pattern found at 0, 2
pattern found at 0, 10
pattern found at 2, 2
pattern found at 2, 12

Complexity Analysis:  

  • Time complexity: O(R*C*8*len(str)). 
    All the cells will be visited and traversed in all 8 directions, where R and C is side of matrix so time complexity is O(R*C).
  • Auxiliary Space: O(1). 
    As no extra space is needed.

Approach when array of words is given: The idea used here is simple, we check every cell. If cell has first character, then we one by one try all 8 directions from that cell for a match, put this check in a loop.  We use mover array to store the manner in which next moves are possible={left,right,up,down,…diagonals}. 
Below are implementation of the same:  

C++




#include <bits/stdc++.h>
using namespace std;
// making a solution class to solve the problem and to keep
// the components and functions of solution together
class Solution {
public:
    // making the possible moves in movers array
    vector<vector<int> > mover
        = { { 1, 0 }, { 0, 1 },   { -1, 0 }, { 0, -1 },
            { 1, 1 }, { -1, -1 }, { 1, -1 }, { -1, 1 } };
    // making the board global variable
    vector<vector<char> > board;
    // depth first search for the string, with the
    // coordinates and a visited array to take care that we
    // do not overlap the places visited already
    bool dfs(int x, int y, string& s,
             vector<vector<bool> > vis)
    {
        // if string length becomes 0 means string is found
        if (s.length() == 0)
            return true;
        vis[x][y] = true;
        // making a solution boolean to see if we can
        // perform depth search to find answer
        bool sol = false;
        // making possible moves
        for (int i = 0; i < mover.size(); i++) {
            int curr_x = mover[i][0] + x;
            int curr_y = mover[i][1] + y;
            // checking for out of bound areas
            if (curr_x >= 0 && curr_x < board.size()) {
                if (curr_y >= 0
                    && curr_y < board[0].size()) {
                    // checking for similarity in the first
                    // letter and the visited array
                    if (board[curr_x][curr_y] == s[0]
                        && vis[curr_x][curr_y] == false) {
                        string k = s.substr(
                            1); // removing the first letter
                                // from the string
                        sol |= dfs(curr_x, curr_y, k, vis);
                    }
                }
            }
        }
        return sol;
    }
    // making a function findwords to find words along with
    // their location which inputs the board and list of
    // words
    vector<string> findWords(vector<vector<char> >& board,
                             vector<string>& words)
    {
        this->board
            = board; // making board a global variable
        vector<string> ans;
        vector<vector<bool> > vis(
            board.size(),
            vector<bool>(board[0].size(),
                         false)); // visited array
        for (auto& word : words) {
            for (int i = 0; i < board.size(); i++) {
                for (int j = 0; j < board[i].size(); j++) {
                    if (board[i][j] == word[0]) {
                        // if first letter of(i,j)==
                        // string's first letter then we can
                        // perform dfs to check the
                        // possiblity of string being present
                        // from location (i,j)
                        string s = word.substr(1);
                        if (dfs(i, j, s, vis)) {
                            ans.push_back(
                                word + "->{" + to_string(i)
                                + "," + to_string(j) + "}");
                        }
                    }
                }
                if (ans.size() && ans.back() == word)
                    break;
            }
        }
        return ans;
    }
};
int main()
{
    // making 1 instance of class solution as solver
    Solution solver;
    vector<vector<char> > board
        = { { 'o', 'a', 'a', 'n' },
            { 'e', 't', 'a', 'e' },
            { 'i', 'h', 'k', 'r' },
            { 'i', 'f', 'l', 'v' } };
    vector<string> words = { "oath", "pea", "eat", "rain" };
    // using the function findwords from our solution class
    // to find the answer
    vector<string> ans = solver.findWords(board, words);
    // printing the answer
    for (auto& part : ans)
        cout << part << endl;
    return 0;
}//contributed by NamanAnand


Output

oath->{0,0}
eat->{1,0}
eat->{1,3}

Complexity Analysis:  

  • Time complexity: O(R*C*len(str)*Number(str)*len(str))
    All the cells will be visited and traversed in all 8 directions, where R and C is side of matrix so time complexity is O(R*C) for each string.
  • Auxiliary Space: O(R*C*Numberof(str)*len(str)). (due to visited array)

Exercise: The above solution only print locations of word. Extend it to print the direction where word is present.
See this for solution of exercise.
This article is contributed by Utkarsh Trivedi. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 


My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!