arrays - 连接4个对角线赢支票

Question

我在测试Ruby Connect 4游戏中的对角线胜利我一直在用一个硬编码的二维阵列进行测试：

grid_array = [
["B", ".", ".", ".", ".", ".", ".", "."],
[".", "B", ".", ".", ".", ".", ".", "."],
[".", ".", "B", ".", ".", ".", ".", "."],
[".", ".", ".", "B", ".", ".", ".", "."],
[".", ".", ".", "X", "M", ".", ".", "."],
[".", ".", ".", ".", "X", "M", ".", "."],
[".", ".", ".", ".", ".", "X", "M", "."],
[".", ".", ".", ".", ".", ".", "X", "M"]
]

这个方法的内环正确地工作（正确地识别出 'M'或 'B'分别是赢家，但是当我试图将对角线检查移过列或用外环向上移动行以获取 'X'作为赢家值时，我就卡住了。

def nw_diagonal_win (playing_board)
  row = 7
  while row < playing_board.size && row >= 0

    row = 7
    column = 7
    piece_count = 0

    while (row < playing_board.size && column < playing_board[row].size && column >= 0)

      if playing_board[row][column] == 'M'
        piece_count += 1

        if piece_count == 4
          puts "Player is the winner in a diagonal!"
        end

        puts piece_count.inspect

      else
        piece_count = 0
        puts "No winner."
      end

      row += 1
      column += 1
    end

    row -= 1
  end
end

编辑以添加：
一个“赢家”在连接4套相邻的4件（水平，垂直，或对角线）在我的游戏中，这由 'X'和 '0'表示碎片从网格中的一个列的顶部“掉落”到该列中最底部的可用空间棋子可以堆叠成一列，但不能“漂浮”在棋盘中间。对角线可以从左上角到右下角，也可以从右上角到左下角只有当棋子在网格内不间断（没有环绕）时，才会发生赢球。
想一想更大版本的tic-tac-toe，其中的移动必须先在最下面一行进行，然后才能在上面一行进行，像盒子一样堆叠。连续四次（水平、垂直或对角线）获胜。
针对史蒂夫的回答建议，如下：

def top_left_diagonal (playing_board, player_piece)
  row = 0
  while row < playing_board.size - 3
    piece_count = 0
    column = 0
    while column < playing_board[row].size - 3 && playing_board[row][column] == player_piece
      if (playing_board[row][column] == playing_board[row + piece_count][column + piece_count])
        piece_count += 1
      else
        piece_count = 0
      end
      column += 1
    end
    if piece_count == 4
      puts "Diagonal winner!"
    end
    row += 1
  end
end

Answer 1

假设我们有

grid = [
  %w| . . . . . . |,
  %w| . . . w w . |,
  %w| . . . w b . |,
  %w| b . w . b . |,
  %w| w w . w b b |,
  %w| b w b b w b |
]
  #=> [[".", ".", ".", ".", ".", "."], 
  #    [".", ".", ".", "w", "w", "."],
  #    [".", ".", ".", "w", "b", "."],
  #    ["b", ".", "w", ".", "b", "."],
  #    ["w", "w", ".", "w", "b", "b"],
  #    ["b", "w", "b", "b", "w", "b"]]

是的，这只是6x6，但解决方案没有不同。
首先，由于数组很小，我们不必担心计算效率，所以我们可以集中精力于代码效率。
我们先看看每排有没有四个。
检查行

def four_in_a_row_by_row(arr)
  arr.each do |row|
    a = row.each_cons(4).find { |a| a.uniq.size == 1 && a.first != '.' }
    return a.first unless a.nil?        
  end
  nil
end

如果一行中有四个 w，则此方法返回 w，如果一行中有四个 b，则返回 b，否则返回 nil。
注意，此方法不要求 arr.size == grid.size或 arr的所有元素具有相同的大小它只检查任何元素是否有四个或四个连续的 'w'。这在以后会有意义的。
例如，传递给块的 'b'的最后一个元素如下。

row =  ["b", "w", "b", "b", "w", "b"]

然后我们计算

enum0 = row.each_cons(4)
  #=> #<Enumerator: ["b", "w", "b", "b", "w", "b"]:each_cons(4)>

和

enum1 = enum0.find
  #=> #<Enumerator: #<Enumerator: ["b", "w", "b", "b", "w", "b"]:each_cons(4)>:find>

arr可以看作是一个复合枚举器，尽管ruby并没有这样定义它。
我们可以将此枚举数转换为数组，以查看将传递给块的元素。

enum1.to_a
  #=> [["b", "w", "b", "b"], ["w", "b", "b", "w"], ["b", "b", "w", "b"]]

见 Enumerable#each_cons。
第一个元素被传递到块，并进行以下计算。

    a = enum1.next
    u = a.uniq
    u.size == 1

因此，我们不需要计算 enum1 a.first != '.'的其余两个元素被传递到块中，并为每个元素计算 enum1，这表示在最后一行中没有四个元素。
我们快结束了！
“等等”，你说，我们只检查了行还有柱子和所有的对角线敬请期待。。。
检查列
这个很简单。

four_in_a_row_by_row(grid.transpose)
  #=> nil

检查对角线（从左上到右下）
这里我们需要做的就是构造一个包含对角线的数组 nil，然后应用 'w'。首先确定包含第一列中长度 'b'或更大的元素的对角线：

(0..grid.size-4).map { |i| (0..grid.size-1-i).map { |j| grid[i+j][j] } }
  #=> [[".", ".", ".", ".", "b", "b"], [".", ".", "w", "w", "w"], [".", ".", ".", "b"]]

类似地，识别包含第一行中元素的对角线，除 arr之外，长度 four_in_a_row(arr)或更大的元素：

(1..grid.first.size-4).map { |j| (0..grid.size-j-1).map { |i| grid[i][j+i] } }
  #=> [[".", ".", "w", "b", "b"], [".", "w", "b", "."]]

def diagonals(grid)
  (0..grid.size-4).map { |i| (0..grid.size-1-i).map { |j| grid[i+j][j] } }.
    concat((1..grid.first.size-4).map { |j| (0..grid.size-j-1).map { |i| grid[i][j+i] } })
end

arr = diagonals(grid)
  #=> [[".", ".", ".", ".", "b", "b"], [".", ".", "w", "w", "w"], [".", ".", ".", "b"],
  #    [".", ".", "w", "b", "b"], [".", "w", "b", "."]]

four_in_a_row_by_row(arr)
  #=> nil

检查前对角线（从左到右上）
我们可以进行与计算对角线相同的推理，但由于计算效率在这里并不重要，有一种更简单的方法：计算通过“旋转” 490度获得的阵列对角线。

def rotate90(grid)
  ncols = grid.first.size
  grid.each_index.with_object([]) { |i,a| a << ncols.times.map { |j| grid[j][ncols-1-i] } }
end

arr = rotate90(grid)
  #=> [[".", ".", ".", ".", "b", "b"],
  #    [".", "w", "b", "b", "b", "w"],
  #    [".", "w", "w", ".", "w", "b"],
  #    [".", ".", ".", "w", ".", "b"],
  #    [".", ".", ".", ".", "w", "w"],
  #    [".", ".", ".", "b", "w", "b"]]
arr1 = diagonals(arr)
  #=> [[".", "w", "w", "w", "w", "b"], [".", "w", ".", ".", "w"],
  #    [".", ".", ".", "b"], [".", "b", ".", ".", "w"], [".", "b", "w", "b"]]
four_in_a_row_by_row(arr1)
  #=> "w"

把所有的东西放在一起

def four_in_a_row(grid)
  four_in_a_row_by_row(grid) ||
  four_in_a_row_by_row(grid.transpose) ||
  four_in_a_row_by_row(diagonals(grid)) ||
  four_in_a_row_by_row(diagonals(rotate90(grid)))
end

four_in_a_row_by_row(grid) 
  #=> "w"