Word Search in a 2D Grid of characters

// C# program to search a word in a 2D grid
using System;
using System.Collections.Generic;

class GfG {

    // This function checks if the given
    // coordinate is valid
    static bool validCoord(int x, int y, int m, int n) {
        if (x >= 0 && x < m && y >= 0 && y < n)
            return true;
        return false;
    }

    // This function searches for the given word
    // in a given direction from the coordinate.
    static bool findWord(int index, string word, char[,] grid, 
                         int x, int y, int dirX, int dirY) {

        // if word has been found
        if (index == word.Length) return true;

        // if the current coordinate is
        // valid and characters match, then
        // check the next index
        if (validCoord(x, y, grid.GetLength(0), grid.GetLength(1)) 
            && word[index] == grid[x, y])
            return findWord(index + 1, word, grid, 
                            x + dirX, y + dirY, dirX, dirY);

        return false;
    }

    // This function calls search2D for each coordinate
    static int[][] searchWord(char[,] grid, string word) {
        int m = grid.GetLength(0);
        int n = grid.GetLength(1);

        List<int[]> ans = new List<int[]>();

        // x and y are used to set the direction in which
        // word needs to be searched.
        int[] x = { -1, -1, -1, 0, 0, 1, 1, 1 };
        int[] y = { -1, 0, 1, -1, 1, -1, 0, 1 };

        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {

                // Search in all 8 directions
                for (int k = 0; k < 8; k++) {

                    // If word is found, then append the
                    // coordinates into answer and break.
                    if (findWord(0, word, grid, i, j, x[k], y[k])) {
                        ans.Add(new int[] { i, j });
                        break;
                    }
                }
            }
        }

        return ans.ToArray();
    }

    static void printResult(int[][] ans) {
        foreach (var a in ans) {
            Console.Write( "{" + a[0] + "," + a[1] + "}" + " ");
        }
        Console.WriteLine();
    }

    static void Main() {
        char[,] grid = {
            { 'a', 'b', 'a', 'b' },
            { 'a', 'b', 'e', 'b' },
            { 'e', 'b', 'e', 'b' }
        };
        string word = "abe";

        int[][] ans = searchWord(grid, word);

        printResult(ans);
    }
}

// C# program to search word in 2D grid in 8 directions
using System;
using System.Collections.Generic;

class GfG {
    
    // This function searches for the given word
    // in all 8 directions from the coordinate.
    static bool search2D(char[][] grid, int row, int col, string word) {
        int m = grid.Length;
        int n = grid[0].Length;
        
        // return false if the given coordinate
        // does not match with first index char.
        if (grid[row][col] != word[0])
            return false;
        
        int len = word.Length;
        
        // x and y are used to set the direction in which
	    // word needs to be searched.
        int[] x = { -1, -1, -1, 0, 0, 1, 1, 1 };
        int[] y = { -1, 0, 1, -1, 1, -1, 0, 1 };
        
        // This loop will search in all the 8 directions
        // one by one. It will return true if one of the 
        // directions contain the word.
        for (int dir = 0; dir < 8; dir++) {
            
            // Initialize starting point for current direction
            int k, currX = row + x[dir], currY = col + y[dir];
            
            // First character is already checked, match remaining
            // characters
            for (k = 1; k < len; k++) {
                
                // break if out of bounds
                if (currX >= m || currX < 0 || currY >= n || currY < 0)
                    break;
                
                // break if characters dont match
                if (grid[currX][currY] != word[k])
                    break;
                
                // Moving in particular direction
                currX += x[dir];
                currY += y[dir];
            }
            
            // If all character matched, then value of must
            // be equal to length of word
            if (k == len)
                return true;
        }
        
        // if word is not found in any direction,
        // then return false
        return false;
    }
    
    // This function calls search2D for each coordinate
    static List<int[]> searchWord(char[][] grid, string word) {
        int m = grid.Length;
        int n = grid[0].Length;
        List<int[]> ans = new List<int[]>();
        
        // if the word is found from this coordinate,
	    // then append it to result.
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (search2D(grid, i, j, word)) {
                    ans.Add(new int[] { i, j });
                }
            }
        }
        
        return ans;
    }

    static void printResult(List<int[]> ans) {
        foreach (var coord in ans) {
            Console.Write( "{" + coord[0] + "," + coord[1] + "}" + " ");
        }
        Console.WriteLine();
    }

    static void Main() {
        char[][] grid = new char[][] {
            new char[] { 'a', 'b', 'a', 'b' },
            new char[] { 'a', 'b', 'e', 'b' },
            new char[] { 'e', 'b', 'e', 'b' }
        };
        string word = "abe";
        
        List<int[]> ans = searchWord(grid, word);
        
        printResult(ans);
    }
}