package com.javarush.task.task20.task2027;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
/*
Кроссворд
*/
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, "same");
/*333
Ожидаемый результат
home - (5, 3) - (2, 0)
same - (1, 1) - (4, 1)
*/
}
public static List<Word> detectAllWords(int[][] crossword, String... words) {
List<Word> arr = new ArrayList<>();
arr.addAll(checkByDiagonal(crossword,words));
arr.addAll(checkByX(crossword,words));
arr.addAll(checkByY(crossword,words));
for(Word w : arr) System.out.println(w);
return arr;
}
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);
}
}
public static List<Word> checkByX(int[][] crossword, String... words) {
List<Word> list = new ArrayList<Word>();
for (int i = 0; i < crossword.length; i++) {
StringBuffer buf = new StringBuffer();
for (int j = 0; j <= crossword.length; j++) {
buf.append((char) crossword[i][j]);
}
for (int k = 0; k < words.length; k++) {
if (buf.toString().contains(words[k])) {
int first = buf.indexOf(words[k]);
int start_x = first;
int end_x = (first + words[k].length() - 1);
Word wordl = new Word(words[k]);
wordl.setStartPoint(start_x,i);
wordl.setEndPoint(end_x,i);
list.add(wordl);
}
//reversed word
StringBuffer rev = new StringBuffer();
String word = rev.append(words[k]).reverse().toString();
if(buf.toString().contains(word)){
int first = buf.indexOf(word);
int start_x = (first + word.length() - 1);
int end_x = first;
Word wordl = new Word(words[k]);
wordl.setStartPoint(start_x,i);
wordl.setEndPoint(end_x,i);
list.add(wordl);
}
}
}
return list;
}
//*****************************************************************************
//*****************************************************************************
//*****************************************************************************
//*****************************************************************************
//*****************************************************************************
public static List<Word> checkByY(int[][] crossword, String... words) {
List<Word> list = new ArrayList<Word>();
for (int i = 0; i <= crossword.length; i++) {
StringBuffer buf = new StringBuffer();
for (int j = 0; j < crossword.length;j++) {
buf.append((char) crossword[j][i]);
}
for (int k = 0; k < words.length; k++) {
if (buf.toString().contains(words[k])) {
int first = buf.indexOf(words[k]);
int start_y = first;
int end_y = (first + words[k].length() - 1);
Word wordl = new Word(words[k]);
wordl.setStartPoint(i,start_y);
wordl.setEndPoint(i,end_y);
list.add(wordl);
}
//reversed word
StringBuffer rev = new StringBuffer();
String word = rev.append(words[k]).reverse().toString();
if(buf.toString().contains(word)){
int first = buf.indexOf(word);
int start_y = (first + word.length() - 1);
int end_y = first;
Word wordl = new Word(words[k]);
wordl.setStartPoint(i,start_y);
wordl.setEndPoint(i,end_y);
list.add(wordl);
}
}
}
return list;
}
//*****************************************************************************
//*****************************************************************************
//*****************************************************************************
//*****************************************************************************
//*****************************************************************************
public static ArrayList<Word> checkByDiagonal(int[][] crossword, String... words) {
//by left
ArrayList<Word> list = new ArrayList<Word>();
for (int i = 0; i < crossword.length; i++) {
StringBuffer left = new StringBuffer();
StringBuffer right = new StringBuffer();
int m = 0;
for(int j = 0;j <= crossword.length;j++ ){
try {
right.append((char) crossword[j][i + j]);
}catch (IndexOutOfBoundsException e){}
try {
left.append((char) crossword[j + i][j]);
m++;
}catch (IndexOutOfBoundsException e){}
}
//left
for (int k = 0; k < words.length; k++) {
if (left.toString().contains(words[k]) && i != 0) {
int start_x = left.indexOf(words[k]);
int end_x = start_x+words[k].length()-1;
int start_y = (crossword.length-1)-(left.length()-1)+start_x;
int end_y = start_y+(end_x-start_x);
Word wordl = new Word(words[k]);
wordl.setStartPoint(start_x,start_y);
wordl.setEndPoint(end_x,end_y);
list.add(wordl);
}
//reversed word
StringBuffer rev = new StringBuffer();
String word = rev.append(words[k]).reverse().toString();
if(left.toString().contains(word) && i != 0){
int start_x = left.indexOf(word);
int end_x = start_x+word.length()-1;
int start_y = (crossword.length-1)-(left.length()-1)+start_x;
int end_y = start_y+(end_x-start_x);
Word wordl = new Word(words[k]);
wordl.setStartPoint(end_x,end_y);
wordl.setEndPoint(start_x,start_y);
list.add(wordl);
}
}
//right
for (int k = 0; k < words.length; k++) {
if (right.toString().contains(words[k])) {
int start_x = i+right.indexOf(words[k]);
int end_x = start_x+(words[k].length()-1);
int start_y = right.indexOf(words[k]);
int end_y = start_y+(words[k].length()-1);
Word wordl = new Word(words[k]);
wordl.setStartPoint(start_x,start_y);
wordl.setEndPoint(end_x,end_y);
list.add(wordl);
}
//reversed word
StringBuffer rev = new StringBuffer();
String word = rev.append(words[k]).reverse().toString();
if(right.toString().contains(word)){
int start_x = i+right.indexOf(word);
int end_x = start_x+(word.length()-1);
int start_y = right.indexOf(word);
int end_y = start_y+(word.length()-1);
Word wordl = new Word(words[k]);
wordl.setStartPoint(end_x,end_y);
wordl.setEndPoint(start_x,start_y);
list.add(wordl);
}
}
}
//by left
//*******
int[][] reverse = reverseArray(crossword);
//*****************************************************************************************************
//*****************************************************************************************************
//*****************************************************************************************************
for (int i = 0; i < reverse.length; i++) {
StringBuffer left = new StringBuffer();
StringBuffer right = new StringBuffer();
for(int j = 0;j <= reverse.length;j++){
try {
right.append((char) reverse[j][i + j]);
}catch (IndexOutOfBoundsException e){}
try {
left.append((char) reverse[j + i][j]);
}catch (IndexOutOfBoundsException e){}
}
//left
for (int k = 0; k < words.length; k++) {
if (left.toString().contains(words[k]) && i != 0) {
int start_x = left.indexOf(words[k]);
int end_x = start_x+words[k].length()-1;
int start_y = (crossword.length-1)-(left.length()-1)+start_x;
int end_y = start_y+(end_x-start_x);
Word wordl = new Word(words[k]);
wordl.setStartPoint(crossword[0].length-1-start_x,start_y);
wordl.setEndPoint(crossword[0].length-1-end_x,end_y);
list.add(wordl);
}
//reversed word
StringBuffer rev = new StringBuffer();
String word = rev.append(words[k]).reverse().toString();
if(left.toString().contains(word) && i != 0){
int start_x = left.indexOf(word);
int end_x = start_x+word.length()-1;
int start_y = (crossword.length-1)-(left.length()-1)+start_x;
int end_y = start_y+(end_x-start_x);
Word wordl = new Word(words[k]);
wordl.setStartPoint(crossword[0].length-1-end_x,end_y);
wordl.setEndPoint(crossword[0].length-1-start_x,start_y);
list.add(wordl);
}
}
//right
for (int k = 0; k < words.length; k++) {
if (right.toString().contains(words[k])) {
int start_x = i+right.indexOf(words[k]);
int end_x = start_x+(words[k].length()-1);
int start_y = right.indexOf(words[k]);
int end_y = start_y+(words[k].length()-1);
Word wordl = new Word(words[k]);
wordl.setStartPoint(crossword[0].length-1-start_x,start_y);
wordl.setEndPoint(crossword[0].length-1- end_x,end_y);
list.add(wordl);
}
//reversed word
StringBuffer rev = new StringBuffer();
String word = rev.append(words[k]).reverse().toString();
if(right.toString().contains(word)){
int start_x = i+right.indexOf(word);
int end_x = start_x+(word.length()-1);
int start_y = right.indexOf(word);
int end_y = start_y+(word.length()-1);
Word wordl = new Word(words[k]);
wordl.setStartPoint(crossword[0].length-1-end_x,end_y);
wordl.setEndPoint(crossword[0].length-1-start_x,start_y);
list.add(wordl);
}
}
}
return list;
//*****************************************************************************************************//
//*****************************************************************************************************//
//*****************************************************************************************************//
}
public static int[][] reverseArray(int[][] crossword) {
int[][] reverse = new int[crossword.length][crossword[0].length];
for(int i = 0;i < crossword.length;i++){
for(int k = 0,j = crossword.length ;k <= crossword.length;k++,j--){
reverse[i][k] = crossword[i][j];
}
}
return reverse;
}
}
blsw
34 уровень
Проходит все тесты, включая пользовательские с комментов, но валидатор как ни странно отказывается принимать)
Обсуждается
Комментарии (5)
- популярные
- новые
- старые
Для того, чтобы оставить комментарий Вы должны авторизоваться
blsw Enterprise Java Developer в IELLO
21 июня 2019, 12:52
спасибо за помошь буду бороться до смерти)
0
blsw Enterprise Java Developer в IELLO
21 июня 2019, 10:53
убрал повторы ситуация не изменилась, валидатор всеравно упорно отказывается принимать
0
Денис Java Developer
21 июня 2019, 11:52
Жаль :( хорошая была теория. Успехов в борьбе с Валидатором. Я решал используя несколько другой подход, потому вряд ли еще что то смогу подсказать с ходу.
0
blsw Enterprise Java Developer в IELLO
21 июня 2019, 10:18
Понял спасибо сейчас попробую убрать все повторы и довесть свое решение до ума)
0
Денис Java Developer
21 июня 2019, 10:05
Привет, я не уверен что именно это причина недовольства валидатора, но кое что меня смущает в твоем решении, а именно:
Как то очень уж много раз слово S с одними и теми же координатами упоминается в массиве. Попробуй устроить какую ни будь дедупликацию и перепроверить.
Вообще задачу можно было решить менее громоздко. Возьмем массив наших букв, и начнем искать в нем первую букву нужного слова, предположим мы ее нашли. Что же делать дальше? Самое простое это проверить, нет ли в округе второй буквы этого слова. Если и вторая буква найдена то можно двигаться дальше в указанном направлении до тех пор пока либо слово не будет найдено, либо же цепочка правильных букв не оборвется. Ну и так можно крутить "солнышко" до победного.
Если будет интересно - могу скинуть свой вариант решения этой задчи.
0