МОЙ ВАРИАНТ:

package com.javarush.test.level20.lesson10.bonus03;

import java.util.ArrayList;
import java.util.List;

/* Кроссворд
1. Дан двумерный массив, который содержит буквы английского алфавита в нижнем регистре.
2. Метод detectAllWords должен найти все слова из words в массиве crossword.
3. Элемент(startX, startY) должен соответствовать первой букве слова, элемент(endX, endY) - последней.
text - это само слово, располагается между начальным и конечным элементами
4. Все слова есть в массиве.
5. Слова могут быть расположены горизонтально, вертикально и по диагонали как в нормальном, так и в обратном порядке.
6. Метод main не участвует в тестировании
*/
public class Solution {
    public static void main(String[] args) {
        int[][] crossword = new int[][]{
                {'f', 'd', 'e', 'r', 'l', 'k'},
                {'u', 's', 'a', 'm', 'e', 'o'},
                {'l', 'n', 'g', 'r', 'o', 'v'},
                {'m', 'l', 'p', 'r', 'r', 'h'},
                {'p', 'o', 'e', 'e', 'j', 'j'}
        };
        List<Word> list = detectAllWords(crossword, "home", "same", "unpe", "vorgnl", "ker");
        for (Word word : list) System.out.println(word);
        /*
Ожидаемый результат
home - (5, 3) - (2, 0)
same - (1, 1) - (4, 1)
         */
    }

    /**
     * Порядок исполнения программы.
     *
     * 1. Берём слово.
     * 2. Раскладываем на символы.
     * 3. Прогоняем каждый символ через матрицу.
     * 4. Находим первую букву.
     * 5. Находим последнюю букву.
     * 6. Проверяем все буквы между ними.
     * 6.1. Вычисляем разницу между координатами.
     * 6.2. Создаём циклы по разнице.
     * 6.2.1. знак числа узнаём через метод с return 1 или -1.
     * 6.3. Или разница сокращается одинаковыми шагами цикла, или вообще не сокращается по одному из направлений.
     * 7. Если буквы совпадают, фиксируем первый и последний символы.
     * 8. Добавляем объект в список.
     */
    public static List<Word> detectAllWords(int[][] crossword, String... words) {
        List<Word> list = new ArrayList<>();
        for (String word : words) {
            char[] chars = word.toCharArray();
            int[] coordinates = detectCoordinates(crossword, chars);
            Word word1 = new Word(word);
            word1.setStartPoint(coordinates[0], coordinates[1]);
            word1.setEndPoint(coordinates[2], coordinates[3]);
            list.add(word1);
            System.out.println("---------");
        }
        return list;
    }

    private static int[] detectCoordinates(int[][] crossword, char[] chars) {
        int[] coordinates =  new int[4];
        for (int i = 0; i < crossword.length; i++) {
            for (int j = 0; j < crossword[i].length; j++) {

                if (crossword[i][j] == chars[0]) {
                    coordinates[1] = i;
                    coordinates[0] = j;
                    System.out.printf("detectCoordinates 1: %d - %d%n", coordinates[1], coordinates[0]);
                    int[] finish = detectLastChar(crossword, chars, i, j);
                    coordinates[2] = finish[0];
                    coordinates[3] = finish[1];
                    System.out.printf("detectCoordinates 2: %d - %d%n", coordinates[2], coordinates[3]);
                }
            }
        }
        return coordinates;
    }

    private static int[] detectLastChar(int[][] crossword, char[] chars, int y1, int x1) {
        int[] finalCoordinates = new int[2];
        for (int i = 0; i < crossword.length; i++) {
            for (int j = 0; j < crossword[i].length; j++) {
                if (crossword[i][j] == chars[chars.length - 1]) {
                    if (validate(crossword, chars, y1, x1, i, j)) {
                        finalCoordinates[0] = j;
                        finalCoordinates[1] = i;
                        return finalCoordinates;
                    }
                }
            }
        }
        return finalCoordinates;
    }

    private static boolean validate(int[][] crossword,
                                    char[] chars,
                                    int y1, int x1, int y2, int x2) {
        int xSign = detectSign(x1, x2);
        int ySign = detectSign(y1, y2);
        System.out.println("x: " + xSign);
        System.out.println("y: " + ySign);
        int counter = 0;
        System.out.printf("validate: (%d - %d) - (%d - %d)%n", y1, x1, y2, x2);

        while(++counter < chars.length) {
            y1 += ySign;
            x1 += xSign;
            System.out.printf("subvalidate: (%d - %d) - (%d - %d), ", y1, x1, y2, x2);
            System.out.printf("crossword: %c, char: %c - ", crossword[y1][x1], chars[counter]);
            if (crossword[y1][x1] != chars[counter]) {
                System.out.println("false");
                return false;
            }
            System.out.println("true");
        }
        return true;
    }

    private static int detectSign(int i, int j) {
        if (i > j) return -1;
        else if (i < j) return 1;
        else return 0;
    }

    public static class Word {
        private String text;
        private int startX;
        private int startY;
        private int endX;
        private int endY;

        public Word(String text) {
            this.text = text;
        }

        public void setStartPoint(int i, int j) {
            startX = i;
            startY = j;
        }

        public void setEndPoint(int i, int j) {
            endX = i;
            endY = j;
        }

        @Override
        public String toString() {
            return String.format("%s - (%d, %d) - (%d, %d)", text, startX, startY, endX, endY);
        }
    }
}

МОЙ ВАРИАНТ 2, ПЕРЕПИСАЛ В ОДИН МЕТОД:

package com.javarush.test.level20.lesson10.bonus03;

import java.util.ArrayList;
import java.util.List;

/* Кроссворд
1. Дан двумерный массив, который содержит буквы английского алфавита в нижнем регистре.
2. Метод detectAllWords должен найти все слова из words в массиве crossword.
3. Элемент(startX, startY) должен соответствовать первой букве слова, элемент(endX, endY) - последней.
text - это само слово, располагается между начальным и конечным элементами
4. Все слова есть в массиве.
5. Слова могут быть расположены горизонтально, вертикально и по диагонали как в нормальном, так и в обратном порядке.
6. Метод main не участвует в тестировании
*/
public class Solution {
    public static void main(String[] args) {
        int[][] crossword = new int[][]{
                {'f', 'd', 'e', 'r', 'l', 'k'},
                {'u', 's', 'a', 'm', 'e', 'o'},
                {'l', 'n', 'g', 'r', 'o', 'v'},
                {'m', 'l', 'p', 'r', 'r', 'h'},
                {'p', 'o', 'e', 'e', 'j', 'j'}
        };
        List<Word> list = detectAllWords(crossword, "home", "same");
        for (Word word : list) System.out.println(word);
        /*
Ожидаемый результат
home - (5, 3) - (2, 0)
same - (1, 1) - (4, 1)
         */
    }

    /**
     * Порядок исполнения программы.
     *
     * 1. Берём слово.
     * 2. Раскладываем на символы.
     * 3. Прогоняем каждый символ через матрицу.
     * 4. Находим первую букву.
     * 5. Находим последнюю букву.
     * 6. Проверяем все буквы между ними.
     * 6.1. Вычисляем разницу между координатами.
     * 6.2. Создаём циклы по разнице.
     * 6.2.1. знак числа узнаём через метод с return 1 или -1.
     * 6.3. Или разница сокращается одинаковыми шагами цикла, или вообще не сокращается по одному из направлений.
     * 7. Если буквы совпадают, фиксируем первый и последний символы.
     * 8. Добавляем объект в список.
     */
    public static List<Word> detectAllWords(int[][] crossword, String... words) {
        List<Word> list = new ArrayList<>();
        for (String word : words) {
            char[] chars = word.toCharArray();
            int[] coordinates1 =  new int[4];
            for (int y1 = 0; y1 < crossword.length; y1++) {
                for (int x1 = 0; x1 < crossword[y1].length; x1++) {

                    if (crossword[y1][x1] == chars[0]) {
                        coordinates1[1] = y1;
                        coordinates1[0] = x1;
                        int[] finish1 = new int[2];
                        boolean isChecked = false;

                        for (int k = 0; k < crossword.length; k++) {
                            for (int l = 0; l < crossword[k].length; l++) {

                                if (crossword[k][l] == chars[chars.length - 1] && !isChecked) {

                                    int result1;
                                    if (x1 > l) result1 = -1;
                                    else if (x1 < l) result1 = 1;
                                    else result1 = 0;
                                    int xSign = result1;
                                    int result;
                                    if (y1 > k) result = -1;
                                    else if (y1 < k) result = 1;
                                    else result = 0;
                                    int ySign = result;
                                    int thisX = x1;
                                    int thisY = y1;
                                    int counter = 0;
                                    while(++counter < chars.length) {
                                        thisY += ySign;
                                        thisX += xSign;
                                        if (crossword[thisY][thisX] != chars[counter]) {
                                            break;
                                        }
                                    }
                                    if (counter == chars.length) {
                                        isChecked = true;
                                        finish1[0] = l;
                                        finish1[1] = k;
                                    }
                                }
                            }
                        }
                        coordinates1[2] = finish1[0];
                        coordinates1[3] = finish1[1];
                    }
                }
            }
            Word word1 = new Word(word);
            word1.setStartPoint(coordinates1[0], coordinates1[1]);
            word1.setEndPoint(coordinates1[2], coordinates1[3]);
            list.add(word1);
        }
        return list;
    }

    public static class Word {
        private String text;
        private int startX;
        private int startY;
        private int endX;
        private int endY;

        public Word(String text) {
            this.text = text;
        }

        public void setStartPoint(int i, int j) {
            startX = i;
            startY = j;
        }

        public void setEndPoint(int i, int j) {
            endX = i;
            endY = j;
        }

        @Override
        public String toString() {
            return String.format("%s - (%d, %d) - (%d, %d)", text, startX, startY, endX, endY);
        }
    }
}

СПИСАЛ ВАРИАНТ:

package com.javarush.test.level20.lesson10.bonus03;

import java.util.ArrayList;
import java.util.List;

/* Кроссворд
1. Дан двумерный массив, который содержит буквы английского алфавита в нижнем регистре.
2. Метод detectAllWords должен найти все слова из words в массиве crossword.
3. Элемент(startX, startY) должен соответствовать первой букве слова, элемент(endX, endY) - последней.
text - это само слово, располагается между начальным и конечным элементами
4. Все слова есть в массиве.
5. Слова могут быть расположены горизонтально, вертикально и по диагонали как в нормальном, так и в обратном порядке.
6. Метод main не участвует в тестировании
*/
public class Solution {
    public static void main(String[] args) {
        List<Word> list = new ArrayList<Word>();
        int[][] crossword = new int[][]{
                {'f', 'd', 'e', 'r', 'l', 'k'},
                {'u', 's', 'a', 'm', 'e', 'o'},
                {'l', 'n', 'g', 'r', 'o', 'v'},
                {'m', 'l', 'p', 'r', 'r', 'h'},
                {'p', 'o', 'e', 'e', 'j', 'j'}
        };
        list = detectAllWords(crossword, "emoh", "home", null, "", "same", "emas", "fderlk", "klredf", "fulmp", "poeejj", "jjeeop", "pmluf", "kovhj", "jhvok", "lprr", "rrpl", "lprr", "o", "", null, "test", "eo", "oe");
        for (Word s : list) {
            System.out.println(s.toString());
        }
        /*
Ожидаемый результат
home - (5, 3) - (2, 0)
same - (1, 1) - (4, 1)
         */
    }

    public static List<Word> detectAllWords(int[][] crossword, String... words) {
        boolean textFineshed = false;
        List<Word> list = new ArrayList<Word>();
        for (String findWords : words) {
            if (findWords == null || findWords == "") continue;
            textFineshed = false;
            int xStart = 0,
                    yStart = 0,
                    xEnd = 0,
                    yEnd = 0;
            boolean isFirstSimbol, isText = false,
                    up = true, down = true, left = true, right = true,
                    leftUp = true, leftDown = true, rightUp = true, rightDown = true;
            char[] simbolWords = findWords.toLowerCase().toCharArray();
            isFirstSimbol = false;
            for (int x = 0; x < crossword.length; x++) {
                for (int y = 0; y < crossword[x].length; y++) {

                    if ((char) crossword[x][y] == simbolWords[0]) isFirstSimbol = true;
                    if (isFirstSimbol) {
                        xStart = x;
                        yStart = y;
                        for (int i = 0; i < simbolWords.length; i++) {

                            if (up) {
                                try {
                                    up = (char) crossword[x - i][y] == simbolWords[i];
                                    xEnd = x - i;
                                    yEnd = y;
                                    if (up && i + 1 == simbolWords.length) {
                                        isText = true;
                                        down = left = right = leftDown = leftUp = rightUp = rightDown = false;
                                    }
                                } catch (ArrayIndexOutOfBoundsException e) {
                                    up = false;
                                }
                            }
                            if (down) {
                                try {
                                    down = (char) crossword[x + i][y] == simbolWords[i];
                                    xEnd = x + i;
                                    yEnd = y;
                                    if (down && i + 1 == simbolWords.length) {
                                        isText = true;
                                        left = right = leftDown = leftUp = rightUp = rightDown = false;
                                    }
                                } catch (ArrayIndexOutOfBoundsException e) {
                                    down = false;
                                }
                            }

                            if (left) {
                                try {
                                    left = (char) crossword[x][y - i] == simbolWords[i];
                                    xEnd = x;
                                    yEnd = y - i;
                                    if (left && i + 1 == simbolWords.length) {
                                        isText = true;
                                        right = leftDown = leftUp = rightUp = rightDown = false;
                                    }
                                } catch (ArrayIndexOutOfBoundsException e) {
                                    left = false;
                                }
                            }

                            if (right) {
                                try {
                                    right = (char) crossword[x][y + i] == simbolWords[i];
                                    xEnd = x;
                                    yEnd = y + i;
                                    if (right && i + 1 == simbolWords.length) {
                                        isText = true;
                                        leftDown = leftUp = rightUp = rightDown = false;
                                    }
                                } catch (ArrayIndexOutOfBoundsException e) {
                                    right = false;
                                }
                            }

                            if (leftUp) {
                                try {
                                    leftUp = (char) crossword[x - i][y - i] == simbolWords[i];
                                    xEnd = x - i;
                                    yEnd = y - i;
                                    if (leftUp && i + 1 == simbolWords.length) {
                                        isText = true;
                                        leftDown = rightUp = rightDown = false;
                                    }
                                } catch (ArrayIndexOutOfBoundsException e) {
                                    leftUp = false;
                                }
                            }

                            if (leftDown) {
                                try {
                                    leftDown = (char) crossword[x + i][y - i] == simbolWords[i];
                                    xEnd = x + i;
                                    yEnd = y - i;
                                    if (leftDown && i + 1 == simbolWords.length) {
                                        isText = true;
                                        rightUp = rightDown = false;
                                    }
                                } catch (ArrayIndexOutOfBoundsException e) {
                                    leftDown = false;
                                }
                            }

                            if (rightUp) {
                                try {
                                    rightUp = (char) crossword[x - i][y + i] == simbolWords[i];
                                    xEnd = x - i;
                                    yEnd = y + i;
                                    if (rightUp && i + 1 == simbolWords.length) {
                                        isText = true;
                                        rightDown = false;
                                    }
                                } catch (ArrayIndexOutOfBoundsException e) {
                                    rightUp = false;
                                }
                            }

                            if (rightDown) {
                                try {
                                    rightDown = (char) crossword[x + i][y + i] == simbolWords[i];
                                    xEnd = x + i;
                                    yEnd = y + i;
                                    if (rightDown && i + 1 == simbolWords.length) isText = true;
                                } catch (ArrayIndexOutOfBoundsException e) {
                                    rightDown = false;
                                }
                            }

                            if (isText) {
                                Word word = new Word(findWords);
                                word.setStartPoint(yStart, xStart);
                                word.setEndPoint(yEnd, xEnd);
                                list.add(word);
                                textFineshed = true;
                            }
                            if (textFineshed) break;
                            if (!(up || down || right || left || leftUp || leftDown || rightUp || rightDown)) {
                                isFirstSimbol = false;
                                up = down = left = right = leftDown = leftUp = rightUp = rightDown = true;
                                break;
                            }
                        }
                        if (textFineshed) break;
                    }


                    if (textFineshed) break;
                }
                if (textFineshed) break;
            }
        }

        return list;
    }

    public static class Word {
        private String text;
        private int startX;
        private int startY;
        private int endX;
        private int endY;

        public Word(String text) {
            this.text = text;
        }

        public void setStartPoint(int i, int j) {
            startX = i;
            startY = j;
        }

        public void setEndPoint(int i, int j) {
            endX = i;
            endY = j;
        }

        @Override
        public String toString() {
            return String.format("%s - (%d, %d) - (%d, %d)", text, startX, startY, endX, endY);
        }
    }
}