А я сделал так.

Вопрос по задаче

Решен

Отдельный метод для проверки каждого направления.

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 w : list) {
            System.out.println(w);
        }

        /*
Ожидаемый результат
home - (5, 3) - (2, 0 )
same - (1, 1) - (4, 1)
         */
    }

    public static List<Word> detectAllWords(int[][] crossword, String... words) {

        List<Word> list = new ArrayList<>();

        //Получаем массив с границами - нулями
        int[][] cross2 = returnModifyArray(crossword);

        //Определяем количество циклов, равное количеству слов.
        //Это позволит осуществить поиск по каждому слову отдельно
        for (int i = 0; i < words.length; i++) {
            //каждое слово развиваем на массив букв, где
            //ch[0] - это всегда первая буква искомого слова
            char[] ch = words[i].toCharArray();
            int wordLenth = words[i].length(); //Длина слова (количество символов)
            int firstCharX;
            int firstCharY;

            for (int k = 0; k < cross2.length; k++) {
                for (int l = 0; l < cross2[k].length; l++) {
                    //Если находим букву, с которой начинается слово,
                    //начинаем поиск остальных букв
                    if (cross2[k][l] == (int) ch[0]) {
                        firstCharX = k; //Определяем координаты (строка)
                        firstCharY = l; //первой буквы (столбец)

                        //Ищем по горизонтале вправо
                        Word wHR = findWordHorizRight(cross2, ch, wordLenth, firstCharY, firstCharX);
                        if (wHR != null) list.add(wHR);

                        //Ищем по горизонтале влево
                        Word wHL = findWordHorizLeft(cross2, ch, wordLenth, firstCharY, firstCharX);
                        if (wHL != null) list.add(wHL);

                        //Ищем по вертикали вверх
                        Word wVU = findWordVertUp(cross2, ch, wordLenth, firstCharY, firstCharX);
                        if (wVU != null) list.add(wVU);

                        //Ищем по вертикали вниз
                        Word wVD = findWordVertDown(cross2, ch, wordLenth, firstCharY, firstCharX);
                        if (wVD != null) list.add(wVD);

                        //Ищем по диагонали вверх вправо
                        Word wHVUR = findWordHorVerUpRight(cross2, ch, wordLenth, firstCharY, firstCharX);
                        if (wHVUR != null) list.add(wHVUR);

                        //Ищем по диагонали вверх влево
                        Word wHVUL = findWordHorVerUpLeft(cross2, ch, wordLenth, firstCharY, firstCharX);
                        if (wHVUL != null) list.add(wHVUL);

                        //Ищем по диагонали вниз влево
                        Word wHVDL = findWordHorVerDownLeft(cross2, ch, wordLenth, firstCharY, firstCharX);
                        if (wHVDL != null) list.add(wHVDL);

                        //Ищем по диагонали вниз вправо
                        Word wHVDR = findWordHorVerDownRight(cross2, ch, wordLenth, firstCharY, firstCharX);
                        if (wHVDR != null) list.add(wHVDR);


                    }
                }
            }
        }
        return list;
    }

    public static int[][] returnModifyArray(int[][] crossword) {
        int[][] cross2 = new int[crossword.length + 2][crossword[0].length + 2];

        for (int i = 0; i < crossword.length; i++) {
            for (int j = 0; j < crossword[i].length; j++) {
                cross2[i + 1][j + 1] = crossword[i][j];
            }
        }

        for (int i = 0; i < cross2.length; i++) {
            for (int j = 0; j < cross2[i].length; j++) {
                if (cross2[i][j] == 0) System.out.print("0 ");
                else System.out.print((char) cross2[i][j] + " ");
            }
            System.out.println();
        }
        return cross2;
    }

    public static Word findWordHorizRight(int[][] cross2, char[] ch, int wordLenth, int firstCharY, int firstCharX) {
        Word word = null;
        StringBuilder sB = new StringBuilder();
        sB.append(ch[0]);
        int checkWordLenth = 1; //Счетчик совпадений символов
        int k = firstCharX;
        int l = firstCharY;
        int lastCharX;
        int lastCharY;

        for (int m = 1; m < wordLenth; m++) {
            if ((l + 1) + (wordLenth - 1) <= cross2[k].length) {
                if (cross2[k][l + m] == ch[m]) {
                    sB.append((char) cross2[k][l + m]);
                    checkWordLenth = checkWordLenth + 1;
                }

                if (checkWordLenth == wordLenth) {
                    lastCharX = k;     //Определяем координаты (строка)
                    lastCharY = l + m; //последней буквы (столбец)
                    word = new Word(sB.toString());
                    word.setStartPoint(firstCharY - 1, firstCharX - 1);
                    word.setEndPoint(lastCharY - 1, lastCharX - 1);
                }
            }
        }
        return word;
    }

    public static Word findWordHorizLeft(int[][] cross2, char[] ch, int wordLenth, int firstCharY, int firstCharX) {
        Word word = null;
        StringBuilder sB = new StringBuilder();
        sB.append(ch[0]);
        int checkWordLenth = 1; //Счетчик совпадений символов
        int k = firstCharX;
        int l = firstCharY;
        int lastCharX;
        int lastCharY;

        for (int m = 1; m < wordLenth; m++) {
            if (l - (wordLenth - 1) > 0) {
                if (cross2[k][l - m] == ch[m]) {
                    sB.append((char) cross2[k][l - m]);
                    checkWordLenth = checkWordLenth + 1;
                }

                if (checkWordLenth == wordLenth) {
                    lastCharX = k;     //Определяем координаты (строка)
                    lastCharY = l - m; //последней буквы (столбец)
                    word = new Word(sB.toString());
                    word.setStartPoint(firstCharY - 1, firstCharX - 1);
                    word.setEndPoint(lastCharY - 1, lastCharX - 1);
                }
            }
        }
        return word;
    }

    public static Word findWordVertUp(int[][] cross2, char[] ch, int wordLenth, int firstCharY, int firstCharX) {
        Word word = null;
        StringBuilder sB = new StringBuilder();
        sB.append(ch[0]);
        int checkWordLenth = 1; //Счетчик совпадений символов
        int k = firstCharX;
        int l = firstCharY;
        int lastCharX;
        int lastCharY;

        for (int m = 1; m < wordLenth; m++) {
            if (k - (wordLenth - 1) > 0) {
                if (cross2[k - m][l] == ch[m]) {
                    sB.append((char) cross2[k - m][l]);
                    checkWordLenth = checkWordLenth + 1;
                }

                if (checkWordLenth == wordLenth) {
                    lastCharX = k - m;     //Определяем координаты (строка)
                    lastCharY = l;         //последней буквы (столбец)
                    word = new Word(sB.toString());
                    word.setStartPoint(firstCharY - 1, firstCharX - 1);
                    word.setEndPoint(lastCharY - 1, lastCharX - 1);
                }
            }
        }
        return word;
    }

    public static Word findWordVertDown(int[][] cross2, char[] ch, int wordLenth, int firstCharY, int firstCharX) {
        Word word = null;
        StringBuilder sB = new StringBuilder();
        sB.append(ch[0]);
        int checkWordLenth = 1; //Счетчик совпадений символов
        int k = firstCharX;
        int l = firstCharY;
        int lastCharX;
        int lastCharY;

        for (int m = 1; m < wordLenth; m++) {
            if ((k + 1) + (wordLenth - 1) <= cross2.length) {
                if (cross2[k + m][l] == ch[m]) {
                    sB.append((char) cross2[k + m][l]);
                    checkWordLenth = checkWordLenth + 1;
                }

                if (checkWordLenth == wordLenth) {
                    lastCharX = k + m;     //Определяем координаты (строка)
                    lastCharY = l;         //последней буквы (столбец)
                    word = new Word(sB.toString());
                    word.setStartPoint(firstCharY - 1, firstCharX - 1);
                    word.setEndPoint(lastCharY - 1, lastCharX - 1);
                }
            }
        }
        return word;
    }

    public static Word findWordHorVerUpRight(int[][] cross2, char[] ch, int wordLenth, int firstCharY, int firstCharX) {
        Word word = null;
        StringBuilder sB = new StringBuilder();
        sB.append(ch[0]);
        int checkWordLenth = 1; //Счетчик совпадений символов
        int k = firstCharX;
        int l = firstCharY;
        int lastCharX;
        int lastCharY;

        for (int m = 1; m < wordLenth; m++) {
            if ((l + 1) + (wordLenth - 1) <= cross2[k].length && k - (wordLenth - 1) > 0) {
                if (cross2[k - m][l + m] == ch[m]) {
                    sB.append((char) cross2[k - m][l + m]);
                    checkWordLenth = checkWordLenth + 1;
                }

                if (checkWordLenth == wordLenth) {
                    lastCharX = k - m;     //Определяем координаты (строка)
                    lastCharY = l + m; //последней буквы (столбец)
                    word = new Word(sB.toString());
                    word.setStartPoint(firstCharY - 1, firstCharX - 1);
                    word.setEndPoint(lastCharY - 1, lastCharX - 1);
                }
            }
        }
        return word;
    }

    public static Word findWordHorVerUpLeft(int[][] cross2, char[] ch, int wordLenth, int firstCharY, int firstCharX) {
        Word word = null;
        StringBuilder sB = new StringBuilder();
        sB.append(ch[0]);
        int checkWordLenth = 1; //Счетчик совпадений символов
        int k = firstCharX;
        int l = firstCharY;
        int lastCharX;
        int lastCharY;

        for (int m = 1; m < wordLenth; m++) {
            if (l - (wordLenth - 1) > 0 && k - (wordLenth - 1) > 0) {
                if (cross2[k - m][l - m] == ch[m]) {
                    sB.append((char) cross2[k - m][l - m]);
                    checkWordLenth = checkWordLenth + 1;
                }

                if (checkWordLenth == wordLenth) {
                    lastCharX = k - m;     //Определяем координаты (строка)
                    lastCharY = l - m; //последней буквы (столбец)
                    word = new Word(sB.toString());
                    word.setStartPoint(firstCharY - 1, firstCharX - 1);
                    word.setEndPoint(lastCharY - 1, lastCharX - 1);
                }
            }
        }
        return word;
    }

    public static Word findWordHorVerDownLeft(int[][] cross2, char[] ch, int wordLenth, int firstCharY, int firstCharX) {
        Word word = null;
        StringBuilder sB = new StringBuilder();
        sB.append(ch[0]);
        int checkWordLenth = 1; //Счетчик совпадений символов
        int k = firstCharX;
        int l = firstCharY;
        int lastCharX;
        int lastCharY;

        for (int m = 1; m < wordLenth; m++) {
            if (l - (wordLenth - 1) > 0 && (k + 1) + (wordLenth - 1) <= cross2.length) {
                if (cross2[k + m][l - m] == ch[m]) {
                    sB.append((char) cross2[k + m][l - m]);
                    checkWordLenth = checkWordLenth + 1;
                }

                if (checkWordLenth == wordLenth) {
                    lastCharX = k + m;     //Определяем координаты (строка)
                    lastCharY = l - m;     //последней буквы (столбец)
                    word = new Word(sB.toString());
                    word.setStartPoint(firstCharY - 1, firstCharX - 1);
                    word.setEndPoint(lastCharY - 1, lastCharX - 1);
                }
            }
        }
        return word;
    }

    public static Word findWordHorVerDownRight(int[][] cross2, char[] ch, int wordLenth, int firstCharY, int firstCharX) {
        Word word = null;
        StringBuilder sB = new StringBuilder();
        sB.append(ch[0]);
        int checkWordLenth = 1; //Счетчик совпадений символов
        int k = firstCharX;
        int l = firstCharY;
        int lastCharX;
        int lastCharY;

        for (int m = 1; m < wordLenth; m++) {
            if ((l + 1) + (wordLenth - 1) <= cross2[k].length && (k + 1) + (wordLenth - 1) <= cross2.length) {
                if (cross2[k + m][l + m] == ch[m]) {
                    sB.append((char) cross2[k + m][l + m]);
                    checkWordLenth = checkWordLenth + 1;
                }

                if (checkWordLenth == wordLenth) {
                    lastCharX = k + m;     //Определяем координаты (строка)
                    lastCharY = l + m;     //последней буквы (столбец)
                    word = new Word(sB.toString());
                    word.setStartPoint(firstCharY - 1, firstCharX - 1);
                    word.setEndPoint(lastCharY - 1, lastCharX - 1);
                }
            }
        }
        return word;
    }

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);
    }
}
}

Комментарии (10)

популярные
новые
старые

Для того, чтобы оставить комментарий Вы должны авторизоваться

Уровень 20

Student

6 января 2023, 13:45

Если бы за количество строк кода платили)))

Grock

Уровень 44

6 января 2023, 13:48

Да)) Код ужасен. Просто хотелось решить самостоятельно без подсказок.

Darkness

Уровень 13

6 января 2023, 14:07

Возможно быстрее было просто посидеть подумать над оптимальным подходом, чем писать столько кода и отлаживать. Чем подсказки плохи? Что лучше, делать самому из рук вон плохо и тратить на это уйму времени или быстрее научиться хорошему у мастера и совершенствовать свою технику?

Grock

Уровень 44

6 января 2023, 14:11

Полностью согласен! Код выдан экспромтом. Следующим этапом буду дорабатывать. А вы как решили эту задачу?

Darkness

Уровень 13

6 января 2023, 14:23

полезный

public static List<Word> detectAllWords(int[][] crossword, String... words) {
    List<Word> list = new ArrayList<>();
    for (String word : words) {
        for (int i = 0; i < crossword.length; i++) {
            for (int j = 0; j < crossword[i].length; j++) {
                for (int x = -1; x < 2; x++) {
                    for (int y = -1; y < 2; y++) {
                        try {
                            for (int w = 0; w < word.length(); w++) {
                                if (crossword[i + x * w][j + y * w] != word.charAt(w)) break;
                                if (w + 1 == word.length()) {
                                    Word addedWord = new Word(word);
                                    addedWord.setStartPoint(j, i);
                                    addedWord.setEndPoint(j + y * w, i + x * w);
                                    list.add(addedWord);
                                }
                            }
                        } catch (IndexOutOfBoundsException ignored) {
                        }
                    }
                }
            }
        }
    }
    return list;
}

Циклы: for word - проходим по каждому слову; for i j - проходим по массиву; for x y - проходим по направлениям; for w - проходим по чарам слова. Сразу оговорюсь, мой код плохой. Всё это нужно разбить по методам, но мне и так понятно.

Grock

Уровень 44

8 января 2023, 10:45

Здорово, крутой код! Он на порядок лучше моего. Интересное решение об игнорировании ошибки выхода за пределы массива.

Grock

Уровень 44

8 января 2023, 15:07

Сократил код в 3 раза.

public static List<Word> detectAllWords(int[][] crossword, String... words) {
    List<Word> list = new ArrayList<>();
    int[][] cross2 = returnModifyArray(crossword);
    for (int i = 0; i < words.length; i++) {
        int wordLenth = words[i].length();
        for (int k = 0; k < cross2.length; k++) {
            for (int l = 0; l < cross2[k].length; l++) {
                if (cross2[k][l] == (int) words[i].charAt(0)) {
                    findWordRight(cross2, words[i], wordLenth, l, k, list);
                    findWordLeft(cross2, words[i], wordLenth, l, k, list);
                    findWordUp(cross2, words[i], wordLenth, l, k, list);
                    findWordDown(cross2, words[i], wordLenth, l, k, list);
                    findWordUpRight(cross2, words[i], wordLenth, l, k, list);
                    findWordUpLeft(cross2, words[i], wordLenth, l, k, list);
                    findWordDownLeft(cross2, words[i], wordLenth, l, k, list);
                    findWordDownRight(cross2, words[i], wordLenth, l, k, list);
                } } } } return list; }

Grock

Уровень 44

8 января 2023, 15:08

public static int[][] returnModifyArray(int[][] crossword) {
    int[][] cross2 = new int[crossword.length + 2][crossword[0].length + 2];
    for (int i = 0; i < crossword.length; i++) { for (int j = 0; j < crossword[i].length; j++) cross2[i + 1][j + 1] = crossword[i][j];
    } return cross2; }

Grock

Уровень 44

8 января 2023, 15:08

public static void findWordRight(int[][] cross2, String word, int wordLenth, int firstCharY, int firstCharX, List<Word> list) {
    int checkRight = 1;
    for (int m = 1; m < wordLenth; m++) {
        if ((firstCharY + 1) + (wordLenth - 1) <= cross2[firstCharX].length) {
            if (cross2[firstCharX][firstCharY + m] == word.charAt(m)) checkRight = checkRight + 1;
            if (checkRight == wordLenth) addWordTotList(word, firstCharY, firstCharX, firstCharY + m, firstCharX, list); } } }

public static void findWordLeft(int[][] cross2, String word, int wordLenth, int firstCharY, int firstCharX, List<Word> list) {
    int checkLeft = 1;
    for (int m = 1; m < wordLenth; m++) {
        if (firstCharY - (wordLenth - 1) > 0) {
            if (cross2[firstCharX][firstCharY - m] == word.charAt(m)) checkLeft += 1;
            if (checkLeft == wordLenth) addWordTotList(word, firstCharY, firstCharX, firstCharY - m, firstCharX, list); } } }

public static void findWordUp(int[][] cross2, String word, int wordLenth, int firstCharY, int firstCharX, List<Word> list) {
    int checkUp = 1;
    for (int m = 1; m < wordLenth; m++) {
        if (firstCharX - (wordLenth - 1) > 0) {
            if (cross2[firstCharX - m][firstCharY] == word.charAt(m)) checkUp += 1;
            if (checkUp == wordLenth) addWordTotList(word, firstCharY, firstCharX, firstCharY, firstCharX - m, list); } } }

...и подобным образом остальные 5 методов

Grock

Уровень 44

8 января 2023, 15:09

public static void addWordTotList(String word, int firstCharY,  int firstCharX, int lastCharY, int lastCharX, List<Word> list) {
    Word w = new Word(word);
    w.setStartPoint(firstCharY - 1, firstCharX - 1);
    w.setEndPoint(lastCharY - 1, lastCharX - 1);
    list.add(w); }