• ,

level20.lesson10.bonus03

Долго сидел думал над этой задачей и вроде удалось решить — вывод правильный. Создал отдельный метод для каждого прохода. Поставил даже проверку на 1 символ(хотя в условии четко сказано, что должно быть слово)- тестирование никак не проходит.
Подскажите, пожалуйста, что еще упустил и на что нужно обратить внимание.

/* Кроссворд
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'}
        };
        detectAllWords(crossword, "home", "same","h","rrh","erl","ngr");
        /*
Ожидаемый результат
home - (5, 3) - (2, 0)
same - (1, 1) - (4, 1)
         */
    }
    public static List<Word> detectAllWords(int[][] crossword, String... words) {
        List<Word> list = new ArrayList<>();
        String name = "";
        for (String s : words) {
            name = s;
            Word w = new Word(name);
            char[] cr = name.toCharArray();
            for (int i = 0; i < crossword[0].length; i++) {
                for (int j = 0; j < crossword.length; j++) {
                    if (crossword[j][i] == cr[0]) {
                        w.setStartPoint(i, j);
                        if(cr.length==1){
                           list.add(w);
                            break;
                        }
                        if (roadUpRight(crossword, w)) {
                            list.add(w);
                            break;
                        }
                        if (roadUpLeft(crossword, w)) {
                            list.add(w);
                            break;
                        }
                        if (roadDownRight(crossword, w)) {
                            list.add(w);
                            break;
                        }
                        if (roadDownLeft(crossword, w)) {
                            list.add(w);
                            break;
                        }
                        if (roadRight(crossword, w)) {
                            list.add(w);
                            break;
                        }
                        if (roadLeft(crossword, w)) {
                            list.add(w);
                            break;
                        }
                        if (roadUp(crossword, w)) {
                            list.add(w);
                            break;
                        }
                        if (roadDown(crossword, w)) {
                            list.add(w);
                            break;
                        }
                    }
                }
            }
        }
        for (Word w : list) {
            System.out.println(w.toString());
        }
        return list;
    }

    public static boolean roadUpRight(int[][] crossword, Word word) {
        if (word.startX + 1 == crossword[0].length || word.startY - 1 == -1) {
            return false;
        }
        char[] cr = word.text.toCharArray();
        int c = 1;
        int j = word.startY - 1;
        for (int i = word.startX + 1; i < crossword[0].length; i++) {
            if (crossword[j][i] == cr[c]) {
                c++;
                word.setEndPoint(i, j);
                if (c == cr.length)
                    return true;
                if (j - 1 >= 0) {
                    j--;
                } else {
                    return false;
                }
            } else {
                return false;
            }
        }
        return false;
    }
    public static boolean roadUpLeft(int[][] crossword, Word word) {
        if (word.startX - 1 == -1 || word.startY - 1 == -1) {
            return false;
        }
        char[] cr = word.text.toCharArray();
        int c = 1;
        int j = word.startY - 1;
        for (int i = word.startX - 1; i >= 0; i--)
            if (crossword[j][i] == cr[c]) {
                c++;
                word.setEndPoint(i, j);
                if (c == cr.length)
                    return true;
                if (j - 1 >= 0) {
                    j--;
                } else {
                    return false;
                }
            } else {
                return false;
            }
        return false;
    }
    public static boolean roadDownRight(int[][] crossword, Word word) {
        if (word.startX + 1 == crossword[0].length || word.startY + 1 == crossword.length) {
            return false;
        }
        char[] cr = word.text.toCharArray();
        int c = 1;
        int j = word.startY + 1;
        for (int i = word.startX + 1; i < crossword[0].length; i++)
            if (crossword[j][i] == cr[c]) {
                c++;
                word.setEndPoint(i, j);
                if (c == cr.length)
                    return true;
                if (j < crossword.length) {
                    j++;
                } else return false;
            } else return false;
        return false;
    }
    public static boolean roadDownLeft(int[][] crossword, Word word) {
        if (word.startX - 1 == -1 || word.startY + 1 == crossword.length) {
            return false;
        }
        char[] cr = word.text.toCharArray();
        int c = 1;
        int j = word.startY + 1;
        for (int i = word.startX - 1; i >= 0; i--)
            if (crossword[j][i] == cr[c]) {
                c++;
                word.setEndPoint(i, j);
                if (c == cr.length)
                    return true;
                if (j < crossword.length) {
                    j++;
                } else return false;
            } else return false;
        return false;
    }
    public static boolean roadRight(int[][] crossword, Word word) {
        if (word.startX + 1 == crossword[0].length) {
            return false;
        }
        char[] cr = word.text.toCharArray();
        int c = 1;
        for (int i = word.startX + 1; i < crossword[0].length; i++)
            if (crossword[word.startY][i] == cr[c]) {
                c++;
                word.setEndPoint(i, word.startY);
                if (c == cr.length)
                    return true;
            }
        return false;
    }
    public static boolean roadLeft(int[][] crossword, Word word) {
        if (word.startX - 1 == -1) {
            return false;
        }
        char[] cr = word.text.toCharArray();
        int c = 1;
        for (int i = word.startX - 1; i >= 0; i--)
            if (crossword[word.startY][i] == cr[c]) {
                c++;
                word.setEndPoint(i, word.startY);
                if (c == cr.length)
                    return true;
            }
        return false;
    }
    public static boolean roadUp(int[][] crossword, Word word) {
        if (word.startY - 1 == -1) {
            return false;
        }
        char[] cr = word.text.toCharArray();
        int c = 1;
        for (int j = word.startY - 1; j >= 0; j--)
            if (crossword[j][word.startX] == cr[c]) {
                c++;
                word.setEndPoint(word.startX, j);
                if (c == cr.length)
                    return true;
            }
        return false;
    }
    public static boolean roadDown(int[][] crossword, Word word) {
        if (word.startY + 1 == crossword.length) {
            return false;
        }
        char[] cr = word.text.toCharArray();
        int c = 1;
        for (int j = word.startY + 1; j < crossword.length; j++)
            if (crossword[j][word.startX] == cr[c]) {
                c++;
                word.setEndPoint(word.startX, j);
                if (c == cr.length)
                    return true;
            }
        return false;
    }
    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);
        }
    }
}

level20.lesson10.bonus03

Уже не знаю что делать. Все тесты перепробовал все работает. Находит слова если они начинаются с одной буквы, и в обратном порядке. Подскажите что не так я сделал или дайте тесты которые можно проверить.
package com.javarush.test.level20.lesson10.bonus03;

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

/* Кроссворд
1. Дан двумерный массив, который содержит буквы английского алфавита в нижнем регистре.
2. Метод detectAllWords должен найти все слова из words в массиве crossword.
3. Элемент(startX, startY) должен соответствовать первой букве слова, элемент(endX, endX) - последней.
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", "rr");
        for (Word word : list) {
            System.out.println(word);
        }

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

    public static List<Word> detectAllWords(int[][] crossword, String... words) {
        List<Word> list = new ArrayList<>();
        for (String s : words) {
            char[] chars = s.toCharArray();
            int k = chars.length - 1;
            for (int i = 0; i < 5; i++) {
                for (int j = 0; j < 6; j++) {
                    if (crossword[i][j] == chars[0]){

//                        boolean cont = true;
//                        boolean addWord = false;
                        try{
                            Word newWord = new Word(s);
                            newWord.setStartPoint(i, j);
                            if (crossword[newWord.startX-1][newWord.startY-1] == chars[1]){
                                if (crossword[newWord.startX - k][newWord.startY - k] == chars[chars.length-1]) {
                                    newWord.setEndPoint(newWord.startX - k, newWord.startY - k);
                                    StringBuilder builder = new StringBuilder();
                                    for (int l = 0; l < chars.length; l++) {
                                        builder.append((char)(crossword[newWord.startX - l][newWord.startY - l]));
                                    }
                                    if (builder.toString().equals(s)) {
//                                        cont = false;
//                                        addWord = true;
                                        int i1 = newWord.startX;
                                        int j1 = newWord.startY;
                                        newWord.setStartPoint(j1, i1);
                                        i1 = newWord.endX;
                                        j1 = newWord.endY;
                                        newWord.setEndPoint(j1, i1);
                                        list.add(newWord);
                                    }
                                }
                            }
                        } catch (ArrayIndexOutOfBoundsException e){}
                        try {
                            Word newWord = new Word(s);
                            newWord.setStartPoint(i, j);

                            if (crossword[newWord.startX-1][newWord.startY] == chars[1] ){
                                if (crossword[newWord.startX - k][newWord.startY] == chars[chars.length-1]) {
                                    newWord.setEndPoint(newWord.startX - k, newWord.startY);
                                    StringBuilder builder = new StringBuilder();
                                    for (int l = 0; l < chars.length; l++) {
                                        builder.append((char)(crossword[newWord.startX - l][newWord.startY]));
                                    }
                                    if (builder.toString().equals(s)) {
                                       int i1 = newWord.startX;
                                        int j1 = newWord.startY;
                                        newWord.setStartPoint(j1, i1);
                                        i1 = newWord.endX;
                                        j1 = newWord.endY;
                                        newWord.setEndPoint(j1, i1);
                                        list.add(newWord);
                                    }
                                }
                            }
                        } catch (ArrayIndexOutOfBoundsException e) {}
                        try {
                            Word newWord = new Word(s);
                            newWord.setStartPoint(i, j);
                            if (crossword[newWord.startX-1][newWord.startY+1] == chars[1]){
                                if (crossword[newWord.startX - k][newWord.startY + k] == chars[chars.length-1]) {
                                    newWord.setEndPoint(newWord.startX - k, newWord.startY + k);
                                    StringBuilder builder = new StringBuilder();
                                    for (int l = 0; l < chars.length; l++) {
                                        builder.append((char)(crossword[newWord.startX - l][newWord.startY + l]));
                                    }
                                    if (builder.toString().equals(s)) {
                                        int i1 = newWord.startX;
                                        int j1 = newWord.startY;
                                        newWord.setStartPoint(j1, i1);
                                        i1 = newWord.endX;
                                        j1 = newWord.endY;
                                        newWord.setEndPoint(j1, i1);
                                        list.add(newWord);
                                    }
                                }
                            }
                        } catch (ArrayIndexOutOfBoundsException e) {}
                        try {
                            Word newWord = new Word(s);
                            newWord.setStartPoint(i, j);
                            if (crossword[newWord.startX][newWord.startY-1] == chars[1]){
                                if (crossword[newWord.startX][newWord.startY - k] == chars[chars.length-1]) {
                                    newWord.setEndPoint(newWord.startX, newWord.startY - k);
                                    StringBuilder builder = new StringBuilder();
                                    for (int l = 0; l < chars.length; l++) {
                                        builder.append((char)(crossword[newWord.startX][newWord.startY - l]));
                                    }
                                    if (builder.toString().equals(s)) {
                                        int i1 = newWord.startX;
                                        int j1 = newWord.startY;
                                        newWord.setStartPoint(j1, i1);
                                        i1 = newWord.endX;
                                        j1 = newWord.endY;
                                        newWord.setEndPoint(j1, i1);
                                        list.add(newWord);
                                    }
                                }
                            }
                        } catch (ArrayIndexOutOfBoundsException e) {}
                        try {
                            Word newWord = new Word(s);
                            newWord.setStartPoint(i, j);
                            if (crossword[newWord.startX][newWord.startY+1] == chars[1]){
                                if (crossword[newWord.startX][newWord.startY + k] == chars[chars.length-1]) {
                                    newWord.setEndPoint(newWord.startX, newWord.startY + k);
                                    StringBuilder builder = new StringBuilder();
                                    for (int l = 0; l < chars.length; l++) {
                                        builder.append((char)(crossword[newWord.startX][newWord.startY + l]));
                                    }
                                    if (builder.toString().equals(s)) {
                                        int i1 = newWord.startX;
                                        int j1 = newWord.startY;
                                        newWord.setStartPoint(j1, i1);
                                        i1 = newWord.endX;
                                        j1 = newWord.endY;
                                        newWord.setEndPoint(j1, i1);
                                        list.add(newWord);
                                    }
                                }
                            }
                        } catch (ArrayIndexOutOfBoundsException e) {}
                        try {
                            Word newWord = new Word(s);
                            newWord.setStartPoint(i, j);
                            if (crossword[newWord.startX+1][newWord.startY-1] == chars[1]){
                                if (crossword[newWord.startX + k][newWord.startY - k] == chars[chars.length-1]) {
                                    newWord.setEndPoint(newWord.startX + k, newWord.startY - k);
                                    StringBuilder builder = new StringBuilder();
                                    for (int l = 0; l < chars.length; l++) {
                                        builder.append((char)(crossword[newWord.startX + l][newWord.startY - l]));
                                    }
                                    if (builder.toString().equals(s)) {
                                        int i1 = newWord.startX;
                                        int j1 = newWord.startY;
                                        newWord.setStartPoint(j1, i1);
                                        i1 = newWord.endX;
                                        j1 = newWord.endY;
                                        newWord.setEndPoint(j1, i1);
                                        list.add(newWord);
                                    }
                                }
                            }
                        } catch (ArrayIndexOutOfBoundsException e) {}
                        try {
                            Word newWord = new Word(s);
                            newWord.setStartPoint(i, j);
                            if (crossword[newWord.startX+1][newWord.startY] == chars[1]){
                                if (crossword[newWord.startX + k][newWord.startY] == chars[chars.length-1]) {
                                    newWord.setEndPoint(newWord.startX + k, newWord.startY);
                                    StringBuilder builder = new StringBuilder();
                                    for (int l = 0; l < chars.length; l++) {
                                        builder.append((char)(crossword[newWord.startX + l][newWord.startY]));
                                    }
                                    if (builder.toString().equals(s)) {
                                        int i1 = newWord.startX;
                                        int j1 = newWord.startY;
                                        newWord.setStartPoint(j1, i1);
                                        i1 = newWord.endX;
                                        j1 = newWord.endY;
                                        newWord.setEndPoint(j1, i1);
                                        list.add(newWord);
                                    }
                                }
                            }
                        } catch (ArrayIndexOutOfBoundsException e) {}
                        try {
                            Word newWord = new Word(s);
                            newWord.setStartPoint(i, j);
                            if (crossword[newWord.startX+1][newWord.startY+1] == chars[1]){
                                if (crossword[newWord.startX + k][newWord.startY + k] == chars[chars.length-1]) {
                                    newWord.setEndPoint(newWord.startX + k, newWord.startY + k);
                                    StringBuilder builder = new StringBuilder();
                                    for (int l = 0; l < chars.length; l++) {
                                        builder.append((char)(crossword[newWord.startX + l][newWord.startY + l]));
                                    }
                                    if (builder.toString().equals(s)) {
                                        int i1 = newWord.startX;
                                        int j1 = newWord.startY;
                                        newWord.setStartPoint(j1, i1);
                                        i1 = newWord.endX;
                                        j1 = newWord.endY;
                                        newWord.setEndPoint(j1, i1);
                                        list.add(newWord);
                                    }
                                }
                            }
                        } catch (ArrayIndexOutOfBoundsException e) {}
                    }
                }
            }
        }
        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);
        }
    }
}


При
detectAllWords(crossword, "home", "same", "rr");


Вывод:
home - (5, 3) - (2, 0)
same - (1, 1) - (4, 1)
rr - (3, 2) - (3, 3)
rr - (3, 2) - (4, 3)
rr - (3, 3) - (3, 2)
rr - (3, 3) - (4, 3)
rr - (4, 3) - (3, 2)
rr - (4, 3) - (3, 3)