# Search a Word in a 2D Grid of characters

• Difficulty Level : Medium
• Last Updated : 15 Feb, 2022

Given a 2D grid of characters and a word, find all occurrences of the given word 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.

Source: Microsoft Interview Question.

Approach: 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 ``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

 ``

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.

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.