Четыре строки подряд

В настоящее время я работаю над базовыми четырьмя подряд играми, но я скорее придерживаюсь логики.

В настоящее время у меня есть этот multidimensional array, который представляет плату

[ [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0] ] 

0 будет представлять собой пустой слот, а 1 и 2 – игрок. Итак, скажем, через некоторое время вы получите этот массив:

 [ [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0], [0, 0, 0, 1, 1, 0, 0], [0, 0, 1, 2, 2, 2, 0], [0, 1, 2, 2, 1, 2, 0] ] 

Как я могу написать логику, чтобы проверить, есть ли четыре подряд? Вычисление его для горизонтальных и вертикальных выглядит довольно легко (хотя все еще выясняется наилучшим образом), но как бы это сделать для диагональных линий?

Лучше всего разделить пространство поиска на четыре:

  • вертикали;
  • по горизонтали;
  • право и вниз;
  • прямо и вверх.

затем ограничьте начальную и конечную координаты в зависимости от направления.

Например, предположим, что ваш массив находится в board[row=0-5][col=0-6] с board[0][0] в верхнем левом углу.

Первая вертикальная (петли включены с обоих концов в этом псевдокоде):

 for row = 0 to 2: for col = 0 to 6: if board[row][col] != 0 and board[row][col] == board[row+1][col] and board[row][col] == board[row+2][col] and board[row][col] == board[row+3][col]: return board[row][col] 

Это ограничивает возможности только тех, которые не простираются от края доски, проблема большинства решений, когда они упрощаются, проверяя каждую ячейку и выходя из нее во всех направлениях. Под этим я подразумеваю, что нет точки, проверяющей стартовую строку 3, просто потому, что это будет включать строки 3, 4, 5 и 6 (последние не существуют).

Аналогично, для горизонтальной:

 for row = 0 to 5: for col = 0 to 3: if board[row][col] != 0 and board[row][col] == board[row][col+1] and board[row][col] == board[row][col+2] and board[row][col] == board[row][col+3]: return board[row][col] 

Для правого и правого, а затем справа и вверх:

 for row = 0 to 2: for col = 0 to 3: if board[row][col] != 0 and board[row][col] == board[row+1][col+1] and board[row][col] == board[row+2][col+2] and board[row][col] == board[row+3][col+3]: return board[row][col] for row = 3 to 5: for col = 0 to 3: if board[row][col] != 0 and board[row][col] == board[row-1][col+1] and board[row][col] == board[row-2][col+2] and board[row][col] == board[row-3][col+3]: return board[row][col] 

Теперь вы могли бы объединить эти два, сделав for col = 0 to 3 внешним циклом и делать это один раз, а не два раза, но я предпочитаю держать их отдельно (с подходящими комментариями), чтобы их было легче понять. Однако, если вы зависимы от производительности, вы можете попробовать:

 for col = 0 to 3: for row = 0 to 2: if board[row][col] != 0 and board[row][col] == board[row+1][col+1] and board[row][col] == board[row+2][col+2] and board[row][col] == board[row+3][col+3]: return board[row][col] for row = 3 to 5: if board[row][col] != 0 and board[row][col] == board[row-1][col+1] and board[row][col] == board[row-2][col+2] and board[row][col] == board[row-3][col+3]: return board[row][col] 

Затем, если в четырех возможных направлениях не было найдено ни одного выигрыша, просто верните 0 вместо победителя 1 или 2 .

Так, например, ваша типовая доска:

 row 0 [0, 0, 0, 0, 0, 0, 0] 1 [0, 0, 0, 0, 0, 0, 0] 2 [0, 0, 0, 1, 1, 0, 0] 3 [0, 0, 0, 1, 1, 0, 0] 4 [0, 0, 1, 2, 2, 2, 0] 5 > [0, 1, 2, 2, 1, 2, 0] ^ 0 1 2 3 4 5 6 <- col 

будет обнаруживать победителя в правом и верхнем циклах, где начальная ячейка была {5,1} потому что {5,1} , {4,2} , {3,3} и {2,4} все установлены в 1 .

Некоторое время назад я разработал четыре подряд игры. Вот fragment кода, чтобы проверить условие выигрыша, которое равно четырем в строке: (Это на языке C)

 int checkWinOrLose(int grid[][7],int result,int rowNum) { // For checking whether any win or lose condition is reached. Returns 1 if win or lose is reached. else returns 0 // grid[][] is the 6X7 matrix // result is the column number where the last coin was placed // rowNum is the row number where the last coin was placed int player=grid[rowNum][result]; if(rowNum<=2 && grid[rowNum+1][result]==player && grid[rowNum+2][result]==player && grid[rowNum+3][result]==player) // 4 in a row vertically return 1; else { int count=1,i,j; for(i=result+1;i<7;i++) { // 4 in a row horizontally if(grid[rowNum][i]!=player) break; count++; } for(i=result-1;i>=0;i--) { // 4 in a row horizontally if(grid[rowNum][i]!=player) break; count++; } if(count>=4) return 1; count=1; for(i=result+1,j=rowNum+1;i<7 && j<6;i++,j++) { // 4 in a row diagonally if(grid[j][i]!=player) break; count++; } for(i=result-1,j=rowNum-1;i>=0 && j>=0;i--,j--) { // 4 in a row diagonally if(grid[j][i]!=player) break; count++; } if(count>=4) return 1; count=1; for(i=result+1,j=rowNum-1;i<7 && j>=0;i++,j--) { // 4 in a row diagonally if(grid[j][i]!=player) break; count++; } for(i=result-1,j=rowNum+1;i>=0 && j<6;i--,j++) { // 4 in a row diagonally if(grid[j][i]!=player) break; count++; } if(count>=4) return 1; } return 0; }