The list returned by detectAllWords is not the right size!

Question about the task

Resolved

I can't figure out why...

package com.codegym.task.task20.task2027;

import java.util.*;

/*
Word search

*/

public class Solution {

    public static List<Word> detectAllWords(int[][] matrix, String... words) {
        List<Word> array = new ArrayList<>();
        for (String word : words) {
            char[] chars = word.toCharArray();
            for (int row = 0; row < matrix.length; row ++) {
                for (int column = 0; column < matrix[0].length; column ++) {
                    if (matrix[row][column] == chars[0]) {
                        detect(matrix, chars, row, column).ifPresent(array::addAll);
                    }
                }
            }
        }
        return array;
    }

    public static Optional<List<Word>> detect(int[][] haystack, char[] needle, int row, int column) {
        List<Word> words = new ArrayList<>();
        String text = String.valueOf(needle);
        int length = needle.length;
        int[] axes = {1, -1};
        for (int axe: axes) {
            boolean rowAxe = true, columnAxe = true;
            boolean[] diagonalAxes = {true, true};
            for (int index = 0; index < length; index ++) {
                int increment = axe * index;
                boolean rowIncrement = row + increment < haystack.length && row + increment + 1 > 0;
                boolean columnIncrement = column + increment < haystack[0].length && column + increment + 1 > 0;
                boolean columnDecrement = column - increment < haystack[0].length && column - increment + 1> 0 ;
                rowAxe =  rowIncrement && rowAxe && (haystack[row + increment][column] == needle[index]);
                columnAxe = columnIncrement && columnAxe && (haystack[row][column + increment] == needle[index]);
                diagonalAxes[0] = (rowIncrement && columnIncrement) &&
                        diagonalAxes[0] && haystack[row + increment][column + increment] == needle[index];
                diagonalAxes[1] = (rowIncrement && columnDecrement) &&
                        diagonalAxes[1] && haystack[row + increment][column - increment] == needle[index];
                if (!rowAxe && !columnAxe && !diagonalAxes[0] && !diagonalAxes[1]) { break; }
            }
            if (rowAxe) words.add(new Word(text, column, row, column, row + axe * (length - 1)));
            if (columnAxe) words.add(new Word(text, column, row, column + axe * (length - 1), row));
            if (diagonalAxes[0]) words.add(
                    new Word(text, column, row, column + axe * (length - 1), row + axe * (length - 1))
            );
            if (diagonalAxes[1]) words.add(
                    new Word(text, column, row, column - axe * (length - 1), row + axe * (length - 1))
            );
        }
        return Optional.of(words);
    }

    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 Word(String text, int startX, int startY, int endX, int endY) {
            this(text);
            setStartPoint(startX, startY);
            setEndPoint(endX, endY);
        }

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

1. We have a two-dimensional array that contains lowercase letters.
2. The detectAllWords method must find all the words in the wordSearch array.
3. The element(startX, startY) must correspond to the first letter of the word, while the element(endX, endY) corresponds to the last letter.
text is the word itself, located between the start and end elements
4. All the words are in the array.
5. The words can be arranged horizontally, vertically, and diagonally, both forward and backward.
6. The main method is not tested.

Requirements:

The Solution class must have a detectAllWords method.
The Solution class must contain a static Word class.
The Solution class must not have static fields.
The detectAllWords method must be static.
The detectAllWords method must be public.
The detectAllWords method should return the list of all words in the word search (according to the task conditions).

package com.codegym.task.task20.task2027; import java.util.ArrayList; import java.util.Arrays; import java.util.List; import java.util.Optional; /* Word search */ public class Solution { public static void main(String[] args) { int[][] wordSearch = new int[][]{ {'f', 'd', 'e', 'e', 'l', 'k'}, {'u', 's', 'a', 'm', 'e', 'o'}, {'l', 'n', 'g', 'r', 'o', 'v'}, {'m', 'l', 'e', 'm', 'o', 'h'}, {'p', 'o', 'e', 'e', 'j', 'j'} }; detectAllWords(wordSearch, "home", "same", "rad", "jo", "ome", "emas", "rme").forEach(System.out::println); /* Expected result home - (5, 3) - (2, 0) same - (1, 1) - (4, 1) */ } public static List<Word> detectAllWords(int[][] wordSearch, String... words) { List<Word> array = new ArrayList<>(); for (String word : words) { char[] wordToDetect = word.toCharArray(); for (int row = 0; row < wordSearch.length; row ++) { for (int column = 0; column < wordSearch[0].length; column ++) { if (wordSearch[row][column] == wordToDetect[0]) { detectWord(wordSearch, wordToDetect, row, column).ifPresent(array::addAll); } } } } return array; } public static Optional<List<Word>> detectWord(int[][] wordSearch, char[] word, int row, int column) { int length = word.length; int stepRow = row + length > wordSearch.length ? -1 : 1; int stepColumn = column + length > wordSearch[0].length ? -1 : 1; boolean rowAxe = true, columnAxe = true, bothAxe = true; boolean rowAxeReverse = row + length == wordSearch.length; boolean columnAxeReverse = column + length == wordSearch[0].length; for (int index = 0; index < length; index ++) { if (rowAxe && !(wordSearch[row + stepRow * index][column] == word[index])) { rowAxe = false; } if (rowAxeReverse && !(wordSearch[row - stepRow * index][column] == word[index])) { rowAxeReverse = false; } if (columnAxe && !(wordSearch[row][column + stepColumn * index] == word[index])) { columnAxe = false; } if (columnAxeReverse && !(wordSearch[row][column - stepColumn * index] == word[index])) { columnAxeReverse = false; } if (bothAxe && !(wordSearch[row + stepRow * index][column + stepColumn * index] == word[index])) { bothAxe = false; } if (!rowAxe && !rowAxeReverse && !columnAxe && !columnAxeReverse && !bothAxe) { return Optional.empty(); } } List<Word> array = new ArrayList<>(); if (rowAxe) { Word detected = new Word(String.valueOf(word)); detected.setStartPoint(column, row); detected.setEndPoint(column, row + stepRow * (length - 1)); array.add(detected); } if (rowAxeReverse) { Word detected = new Word(String.valueOf(word)); detected.setStartPoint(column, row); detected.setEndPoint(column, row - stepRow * (length - 1)); array.add(detected); } if (columnAxe) { Word detected = new Word(String.valueOf(word)); detected.setStartPoint(column, row); detected.setEndPoint(column + stepColumn * (length - 1), row ); array.add(detected); } if (columnAxeReverse) { Word detected = new Word(String.valueOf(word)); detected.setStartPoint(column, row); detected.setEndPoint(column - stepColumn * (length - 1), row ); array.add(detected); } if (bothAxe) { Word detected = new Word(String.valueOf(word)); detected.setStartPoint(column, row); detected.setEndPoint(column + stepColumn * (length - 1), row + stepRow * (length - 1)); array.add(detected); } return Optional.of(array); } 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); } } }

Comments (2)

Popular
New
Old

You must be signed in to leave a comment

Guadalupe Gagnon

Level 37 , Tampa, United States

29 October 2020, 13:28

useful

Have you tested your code with any palindromes? Such as "racecar" or "hannah"?

Dyrits

Level 22

29 October 2020, 13:39

solution

I figure out my problem. The diagonals were only going one way... Both positives on the two axes or both negatives. I modified my code a lot and added another constructor to Word in order to make it shorter. To be sure to check all the axes, I loop over the two axes, with 2 different way each time on diagonals.