import java.util.Random;

public class Ala {
    public static void main(String[] args) {
        Random randomGenerator = new Random();
        char[][] arr = new char[50][50];
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                arr[i][j] = (char) (randomGenerator.nextInt(26)+97);
            }
        }
        for (int i = 0; i < arr.length; i++) {
                System.out.printf("%-3d", i);
        }
        System.out.println();
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j]+"  ");
            }
            System.out.println();
        }
        boolean ala = false;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                if (j>1) {
                    if (arr[i][j] == 'a' && arr[i][j - 1] == 'l' && arr[i][j - 2] == 'a') {//left
                        ala = true;
                        System.out.println(i + " " + j);
                    }
                }
                if (j<arr[i].length-2) {
                    if (arr[i][j] == 'a' && arr[i][j + 1] == 'l' && arr[i][j + 2] == 'a') {//rigth
                        ala = true;
                        System.out.println(i + " " + j);
                    }
                }
                if (i<arr.length-2) {
                    if (arr[i][j] == 'a' && arr[i + 1][j] == 'l' && arr[i + 2][j] == 'a') {//bot
                        ala = true;
                        System.out.println(i + " " + j);
                    }
                }
                if (i>1) {
                    if (arr[i][j] == 'a' && arr[i-1][j] == 'l' && arr[i - 2][j] == 'a') {//top
                        ala = true;
                        System.out.println(i + " " + j);
                    }
                }
                if (i<arr.length-2 && j<arr[i].length-2) {
                    if (arr[i][j] == 'a' && arr[i + 1][j + 1] == 'l' && arr[i + 2][j + 2] == 'a') {//bot&rigth
                        ala = true;
                        System.out.println(i + " " + j);
                    }
                }
                if (i>1 && j>1) {
                    if (arr[i][j] == 'a' && arr[i - 1][j - 1] == 'l' && arr[i - 2][j - 2] == 'a') {//top&left
                        ala = true;
                        System.out.println(i + " " + j);
                    }
                }
                if (i>1 && j<arr[i].length-2) {
                    if (arr[i][j] == 'a' && arr[i - 1][j + 1] == 'l' && arr[i - 2][j + 2] == 'a') {//top&rigth
                        ala = true;
                        System.out.println(i + " " + j);
                    }
                }
                if (i<arr.length-2 && j>1) {
                    if (arr[i][j] == 'a' && arr[i + 1][j - 1] == 'l' && arr[i + 2][j - 2] == 'a') {//bot&left
                        ala = true;
                        System.out.println(i + " " + j);
                    }
                }
            }
        }
        System.out.println(ala);
    }
}

public static boolean contains(char[][] grid, String word) {

}

public static boolean contains(char[][] grid, String word) {
    return verticalContains(grid, word)
            || horizontalContains(grid, word)
            || diagonalContains(grid, word);
}

private static boolean verticalContains(char[][] grid, String word) {
    for (char[] row : grid) {
        if (new String(row).contains(word)) {
            return true;
        }
    }
    return false;
}

private static boolean horizontalContains(char[][] grid, String word) {
    int wordLength = word.length();
    int max = grid.length - wordLength;
    char[] wordArray = word.toCharArray();
    for (int i = 0, length = grid[0].length; i < length; i++) {
        loop: for (int j = 0; j < max; j++) {
            for (int k = j; k < wordArray.length; k++) {
                if (wordArray[k - j] != grid[k][i]) {
                    continue loop;
                }
            }
            return true;
        }
    }
}

private static boolean diagonalContains(char[][] grid, String word) {
    int wordLength = word.length();
    char[] wordArray = word.toCharArray();
    for (int i = 0, length = grid.length; i < length; i++) {
        loop: for (int j = 0, k = i, subLength = grid[i].length;
                j < subLength && k >= wordLength; j++, k--) {
            for (int l = 0; l < wordLength; l++) {
                if (grid[j + l][k - l] != wordArray[l]) {
                    continue loop;
                }
                return true;
            }
        }
    }
}

import java.util.Arrays;

public class CharGrid {

    private final char[][] grid;

    public CharGrid(char[][] grid) {
        int length = grid.length;
        this.grid = copyArray(grid);
    }

    public char[][] getGrid() {
        return copyArray(grid)
    }

    private char[][] copyArray(char[][] array) {
        char[][] result = Arrays.copy(array, length);
        for (int i = 0; i < length; i++) {
            result[i] = Arrays.copy(array[i], array[i].length);
        }
        return result;
    }

    public boolean contains(String word) {
        return verticalContains(grid, word)
                || horizontalContains(grid, word)
                || diagonalContains(grid, word);
    }

    private boolean verticalContains(String word) {
        for (char[] row : grid) {
            if (new String(row).contains(word)) {
                return true;
            }
        }
        return false;
    }

    private boolean horizontalContains(String word) {
        int wordLength = word.length();
        int max = grid.length - wordLength;
        char[] wordArray = word.toCharArray();
        for (int i = 0, length = grid[0].length; i < length; i++) {
            loop: for (int j = 0; j < max; j++) {
                for (int k = j; k < wordArray.length; k++) {
                    if (wordArray[k - j] != grid[k][i]) {
                        continue loop;
                    }
                }
                return true;
            }
        }
    }

    private boolean diagonalContains(String word) {
        int wordLength = word.length();
        char[] wordArray = word.toCharArray();
        for (int i = 0, length = grid.length; i < length; i++) {
            loop: for (int j = 0, k = i, subLength = grid[i].length;
                    j < subLength && k >= wordLength; j++, k--) {
                for (int l = 0; l < wordLength; l++) {
                    if (grid[j + l][k - l] != wordArray[l]) {
                        continue loop;
                    }
                    return true;
                }
            }
        }
    }

}

class WordGrid {
  public contains(String word) {
    return any(word in row for row in getRows())                ||
           any(word in column for column in getColumns())       ||
           any(word in diagonal for diagonal in getDiagonals())
   }
}