Как сделать, если операторы меньше и избежать использования слишком много циклов по той же причине в Java

Question

Этот код для одного из моих назначений (подключите четыре). Мне нужно, чтобы этот код содержал менее 25 строк, а также сокращать операторы if. Также на доске 6 рядов и 7 столбцов. Мой код пытается выяснить, победил ли человек.

Я пытался объединить все циклы в один цикл, но это не дает мне правильного ответа.

public static boolean determineWin(String[][] board) {
    boolean won = false;

    for (int i = 0; i < 6; i++) {
        for (int j = 0; j < 4; j++) {
            if (board[i][j] != ". ") {
                if (board[i][j].equals(board[i][j+1]) && board[i][j+1].equals(board[i][j+2]) && board[i][j+2].equals(board[i][j+3])) {
                    won = true;
                    break;
                }
            }
        }
    }

    for (int i = 5; i > 2; i--) {
        for (int j = 6; j > 2; j--) {
            if (board[i][j] != ". ") {
                if (board[i][j].equals(board[i-1][j-1]) && board[i-1][j-1].equals(board[i-2][j-2]) && board[i-2][j-2].equals(board[i-3][j-3])){
                    won = true;
                    break;
                }
            }
        }

        for (int j = 0; j < 4; j++) {
            if (board[i][j] != ". ") {
                if (board[i][j].equals(board[i-1][j+1]) && board[i-1][j+1].equals(board[i-2][j+2]) && board[i-2][j+2].equals(board[i-3][j+3])){
                    won = true;
                    break;
                }
            }
        }

        for (int j = 0; j < 7; j++) {
            if (board[i][j] != ". ") {
                if (board[i][j].equals(board[i-1][j]) && board[i-1][j].equals(board[i-2][j]) && board[i-2][j].equals(board[i-3][j])){
                    won = true;
                    break;
                }
            }
        }
    }

    return won;
}

Результат должен совпадать с приведенным выше кодом, но мне просто нужно, чтобы код был немного меньше (25 строк), а операторы if были короче.

Answer 1

Код выше неэффективен, потому что он имеет 4 отдельных цикла for (для отслеживания 4 направлений, в которых вы можете выиграть: 1) слева направо, 2) сверху вниз, 3) диагональ 4) диагональ / другое направление -AND- потому что операторы if должны проверять 4 последовательные позиции.

Чтобы оптимизировать решение, вы можете признать, что вы можете сохранить state для how many consecutive same pieces на каждой позиции на доске для каждого из 4 возможных направлений, которые вы можете выиграть (4 уникальных состояния).

Рассмотрим в качестве примера победу в горизонтальном направлении. При перемещении слева направо по одной и той же строке счетчик состояний увеличивается на 1, если фигура слева одинакова. Если когда-либо есть '.', Счетчик сбрасывается на 0. Если есть другой кусок, счетчик сбрасывается на 1. Вы находитесь в выигрышной позиции, если какой-либо из этих 4 счетчиков состояния достигает 4.

Приведенный ниже код завершен для выигрышных направлений по горизонтали (переменная состояния 0) и по вертикали (переменная состояния 1). Это оставлено как упражнение для завершения двух строк, которые представляют каждое из диагональных направлений (переменные состояния 2 и 3).

public static boolean determineWin(String[][] board) {

    int[][][] counters = new int[board[0].length+1][board.length+1][4];

    for (int y=0; y<board.length; y++) {
        for (int x=0; x<board[0].length; x++) {
            if (!board[y][x].equals(".")) {
                counters[y][x][0] = (x>0 && board[y][x].equals(board[y][x-1])) ? counters[y][x-1][0] + 1 : 1;
                counters[y][x][1] = (y>0 && board[y][x].equals(board[y-1][x])) ? counters[y-1][x][1] + 1 : 1;
                // Diagonal 1 TODO:  counters[y][x][2] = 
                // Diagonal 2 TODO:  counters[y][x][3] = 
                if (counters[y][x][0] == 4 || counters[y][x][1] == 4 || counters[y][x][2] == 4 || counters[y][x][3] == 4)
                    return true;
            }
        }
    }
    return false;
}