Arrays 连接4个对角Win Check

我正在测试Ruby Connect 4游戏中的对角胜利。我一直在使用硬编码2D阵列进行测试：

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

---

我在玩一个类似的网格，为了填字游戏，我想出了一个得到对角线的方法。我做了一些改动以适应connect 4。 这不是一个完整的答案，但我希望它能有所帮助

首先，我想将网格映射为坐标：

grid_map = grid_array.map.with_index{ |line, y| line.map.map.with_index { |e, x| [e, x, y] } }

然后用两种方法来恢复矩阵的所有对角线，无论如何，应该有一个更好的解决方案

第一个方向仅取对角线的一半：

def half_diagonals(matrix)
  max_y = matrix[0].size
  max_x = matrix.size
  diagonals = []
  (0...max_x).each do |x_start|
    x = x_start
    y = 0
    diagonal = [matrix[x][y]]
    while  x < max_x - 1 and y < max_y - 1 do
      x += 1
      y += 1
      diagonal << matrix[x][y]
    end
    diagonals << diagonal
  end
  # only in diagonals with at least four spots
  return diagonals.select{ |d| d.size >= 4 }
end

现在，需要检查每个对角线是否有赢家，因此请定义一种方法：

def check_diagonal(diagonal, empty_spot = ".")
  check = diagonal.chunk_while { |s1, s2| s1[0] == s2[0] }.map { |e| [e.count, e[0][0], e.map{ |ee| ee[1..-1]}] }
  return detected = check.detect { |e| e[0] == 4 and e[1] != empty_spot }
  # it returns the first four detected
end

现在调用grid_map上的方法，以获得连接的四个的计数、颜色和坐标：

diagonals(grid_map).map { |diagonal| check_diagonal(diagonal) }.compact
#=> [[4, "B", [[0, 0], [1, 1], [2, 2], [3, 3]]], [4, "X", [[3, 4], [4, 5], [5, 6], [6, 7]]]]

---

由于check.detect，四个M没有返回。

我在玩一个类似的网格，用于填字游戏，并想出了一种获得对角线的方法。我做了一些改动以适应connect 4。 这不是一个完整的答案，但我希望它能有所帮助

首先，我想将网格映射为坐标：

grid_map = grid_array.map.with_index{ |line, y| line.map.map.with_index { |e, x| [e, x, y] } }

然后用两种方法来恢复矩阵的所有对角线，无论如何，应该有一个更好的解决方案

第一个方向仅取对角线的一半：

def half_diagonals(matrix)
  max_y = matrix[0].size
  max_x = matrix.size
  diagonals = []
  (0...max_x).each do |x_start|
    x = x_start
    y = 0
    diagonal = [matrix[x][y]]
    while  x < max_x - 1 and y < max_y - 1 do
      x += 1
      y += 1
      diagonal << matrix[x][y]
    end
    diagonals << diagonal
  end
  # only in diagonals with at least four spots
  return diagonals.select{ |d| d.size >= 4 }
end

现在，需要检查每个对角线是否有赢家，因此请定义一种方法：

def check_diagonal(diagonal, empty_spot = ".")
  check = diagonal.chunk_while { |s1, s2| s1[0] == s2[0] }.map { |e| [e.count, e[0][0], e.map{ |ee| ee[1..-1]}] }
  return detected = check.detect { |e| e[0] == 4 and e[1] != empty_spot }
  # it returns the first four detected
end

现在调用grid_map上的方法，以获得连接的四个的计数、颜色和坐标：

diagonals(grid_map).map { |diagonal| check_diagonal(diagonal) }.compact
#=> [[4, "B", [[0, 0], [1, 1], [2, 2], [3, 3]]], [4, "X", [[3, 4], [4, 5], [5, 6], [6, 7]]]]

---

由于check.detect的原因，四个M没有返回。

如果存在获胜对角线，则起始位置必须在第[0-3]行和第[0-3]列的范围内。任何从左上角方框外开始的对角线都没有足够的右下位置，无法连续四个

因此，实际上需要一个while行<4和while列<4的嵌套循环

对于每个行-列组合，假设该值不是。然后，您可以将您的计件计数设置为1，然后执行计数器1到3，并检查playing_board[行+计数器][列+计数器]是否等于playing_board[行][列]的值，如果是，则增加您的计件计数

---

在计数器1到3循环之外，如果计件数为4，则有一个赢家。

如果有赢家对角线，则起始位置必须在第[0-3]行和第[0-3]列的范围内。任何从左上角方框外开始的对角线都没有足够的右下位置，无法连续四个

因此，实际上需要一个while行<4和while列<4的嵌套循环

对于每个行-列组合，假设该值不是。然后，您可以将您的计件计数设置为1，然后执行计数器1到3，并检查playing_board[行+计数器][列+计数器]是否等于playing_board[行][列]的值，如果是，则增加您的计件计数

在计数器1到3的循环外，如果计件数为4，则您有一个赢家。

假设我们有

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，但解决方案也一样

首先，由于数组很小，我们不必担心计算效率，所以我们可以专注于代码效率

让我们首先检查每行中是否有四个

检查行

如果一行中有四个w，则此方法返回w；如果一行中有四个b，则返回b；否则返回nil

对于arr=grid，我们发现没有一行在一行中包含四个“b”或“w”

four_in_a_row_by_row(grid)
  #=> nil

four_in_a_row_by_row(arr)
  #=> nil

four_in_a_row_by_row(arr1)
  #=> "w"

请注意，此方法不要求arr.size==grid.size，也不要求arr的所有元素大小相同。它只是检查一行中是否有任何元素有四个“ws”或四个“bs”。这将在以后具有重要意义

例如，传递给块的arr的最后一个元素如下所示

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

然后我们计算

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

将第一个元素传递给块，并进行以下计算

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

因此，我们不需要先计算a。enum1的其余两个元素被传递到块，并为每个元素计算nil，这表示在最后一行的“ws”或“bs”行中没有四个元素

我们快完成了

等等，你说，我们只检查了行！还有柱子和所有的对角线！请继续关注

检查列

这个很简单

four_in_a_row_by_row(grid.transpose)
  #=> nil

这里

检查从左上到右下的对角线

这里我们需要做的就是构造一个包含对角线的数组arr，然后在数组arr中应用四个。首先确定包含第一列中长度为4或更大的元素的对角线。这包括以下对角线

[grid[0][0], grid[1][1], grid[2][2], grid[3][3], grid[4][4],grid[5][5]] 
[grid[1][0], grid[2][1], grid[3][2], grid[4][3], grid[5][4]] 
[grid[2][0], grid[3][1], grid[4][2], grid[5][3]] 

[grid[0][1], grid[1][2], grid[2][3], grid[3][4], grid[4][5]] 
[grid[0][2], grid[1][3], grid[2][4], grid[3][5]] 

不必考虑在第一列中包含元素的其余对角线，因为它们包含少于4个元素：

[grid[3][0], grid[4][1], grid[5][2]] 
[grid[4][0], grid[5][1]] 
[grid[5][0]] 

我们可以得到前三条对角线，如下所示

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

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

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

def four_in_a_row_by_row(arr)
  row = arr.find { |row| four_in_a_row(row) }
  row.nil? ? nil : four_in_a_row(row)
end

类似地，标识包含第一行中元素的对角线（网格[0][0]除外），其长度为4或更大。那些是对角线

[grid[0][0], grid[1][1], grid[2][2], grid[3][3], grid[4][4],grid[5][5]] 
[grid[1][0], grid[2][1], grid[3][2], grid[4][3], grid[5][4]] 
[grid[2][0], grid[3][1], grid[4][2], grid[5][3]] 

[grid[0][1], grid[1][2], grid[2][3], grid[3][4], grid[4][5]] 
[grid[0][2], grid[1][3], grid[2][4], grid[3][5]] 

除网格[0][0]之外，第一行中包含元素的其余对角线包含的元素少于4个。我们得到的对角线如下

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

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

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

def four_in_a_row_by_row(arr)
  row = arr.find { |row| four_in_a_row(row) }
  row.nil? ? nil : four_in_a_row(row)
end

因此，我们可以得到所有对角线的数组，如下所示

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

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

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

def four_in_a_row_by_row(arr)
  row = arr.find { |row| four_in_a_row(row) }
  row.nil? ? nil : four_in_a_row(row)
end

我们看到没有一条对角线包含四条直线

four_in_a_row_by_row(grid)
  #=> nil

four_in_a_row_by_row(arr)
  #=> nil

four_in_a_row_by_row(arr1)
  #=> "w"

检查从左到右上方的前对角线

我们可以进行与计算对角线相同的推理，但由于计算效率在这里并不重要，有一种更简单的方法：计算网格旋转90度获得的阵列对角线

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

我们看到，没有一条前对角线包含四个连续的元素

four_in_a_row_by_row(grid)
  #=> nil

four_in_a_row_by_row(arr)
  #=> nil

four_in_a_row_by_row(arr1)
  #=> "w"

把它们放在一起

四行中四行的交替计算

一行一行地写四个字母，如下所示

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

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

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

def four_in_a_row_by_row(arr)
  row = arr.find { |row| four_in_a_row(row) }
  row.nil? ? nil : four_in_a_row(row)
end

如果首选，第0行？无：行中的四个可以替换为

four_in_a_row(row) unless row.nil?

假设我们有

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，但解决方案也一样

首先，由于数组很小，我们不必担心计算效率，所以我们可以专注于代码效率

让我们首先检查每行中是否有四个

检查行

如果一行中有四个w，则此方法返回w；如果一行中有四个b，则返回b；否则返回nil

对于arr=grid，我们发现没有一行在一行中包含四个“b”或“w”

four_in_a_row_by_row(grid)
  #=> nil

four_in_a_row_by_row(arr)
  #=> nil

four_in_a_row_by_row(arr1)
  #=> "w"

请注意，此方法不要求arr.size==grid.size，也不要求arr的所有元素大小相同。它只是检查一行中是否有任何元素有四个“ws”或四个“bs”。这将在以后具有重要意义

例如，传递给块的arr的最后一个元素如下所示

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

然后我们计算

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

将第一个元素传递给块，并进行以下计算

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

因此，我们不需要先计算a。enum1的其余两个元素被传递到块，并为每个元素计算nil，这表示在最后一行的“ws”或“bs”行中没有四个元素

我们快完成了

等等，你说，我们只检查了行！还有柱子和所有的对角线！请继续关注

检查列

这个很简单

four_in_a_row_by_row(grid.transpose)
  #=> nil

这里

检查从左上到右下的对角线

这里我们需要做的就是构造一个包含对角线的数组arr，然后在数组arr中应用四个。首先确定包含第一列中长度为4或更大的元素的对角线。这包括以下对角线

[grid[0][0], grid[1][1], grid[2][2], grid[3][3], grid[4][4],grid[5][5]] 
[grid[1][0], grid[2][1], grid[3][2], grid[4][3], grid[5][4]] 
[grid[2][0], grid[3][1], grid[4][2], grid[5][3]] 

[grid[0][1], grid[1][2], grid[2][3], grid[3][4], grid[4][5]] 
[grid[0][2], grid[1][3], grid[2][4], grid[3][5]] 

不必考虑在第一列中包含元素的其余对角线，因为它们包含少于4个元素：

[grid[3][0], grid[4][1], grid[5][2]] 
[grid[4][0], grid[5][1]] 
[grid[5][0]] 

我们可以得到前三条对角线，如下所示

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

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

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

def four_in_a_row_by_row(arr)
  row = arr.find { |row| four_in_a_row(row) }
  row.nil? ? nil : four_in_a_row(row)
end

类似地，标识包含第一行中元素的对角线（网格[0][0]除外），其长度为4或更大。那些是对角线

[grid[0][0], grid[1][1], grid[2][2], grid[3][3], grid[4][4],grid[5][5]] 
[grid[1][0], grid[2][1], grid[3][2], grid[4][3], grid[5][4]] 
[grid[2][0], grid[3][1], grid[4][2], grid[5][3]] 

[grid[0][1], grid[1][2], grid[2][3], grid[3][4], grid[4][5]] 
[grid[0][2], grid[1][3], grid[2][4], grid[3][5]] 

除网格[0][0]之外，第一行中包含元素的其余对角线包含的元素少于4个。我们得到的对角线如下

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

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

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

def four_in_a_row_by_row(arr)
  row = arr.find { |row| four_in_a_row(row) }
  row.nil? ? nil : four_in_a_row(row)
end

因此，我们可以得到所有对角线的数组，如下所示

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

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

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

def four_in_a_row_by_row(arr)
  row = arr.find { |row| four_in_a_row(row) }
  row.nil? ? nil : four_in_a_row(row)
end

我们看到没有一条对角线包含四条直线

four_in_a_row_by_row(grid)
  #=> nil

four_in_a_row_by_row(arr)
  #=> nil

four_in_a_row_by_row(arr1)
  #=> "w"

检查从左到右上方的前对角线

我们可以进行与计算对角线相同的推理，但由于计算效率在这里并不重要，有一种更简单的方法：计算网格旋转90度获得的阵列对角线

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

我们看到，没有一条前对角线包含四个连续的元素

four_in_a_row_by_row(grid)
  #=> nil

four_in_a_row_by_row(arr)
  #=> nil

four_in_a_row_by_row(arr1)
  #=> "w"

把它们放在一起

四行中四行的交替计算

一行一行地写四个字母，如下所示

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

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

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

def four_in_a_row_by_row(arr)
  row = arr.find { |row| four_in_a_row(row) }
  row.nil? ? nil : four_in_a_row(row)
end

如果首选，第0行？无：行中的四个可以替换为

four_in_a_row(row) unless row.nil?

---

我提出了一个在测试中似乎有效的解决方案。它从右下角到左上角，从8x8网格中第7行第7列开始。我还创建了从左下角到右上角的前对角线

我已经测试了一段时间，没有发现任何错误，但是我很想知道是否有人在上面戳洞

我非常感谢你们所有人——你们的解决方案和建议让我走到了这一步

def nw_diagonal_win (playing_board, player_piece)
    row = 7
    column = 7
    piece_count = 0
    while row < playing_board.size && row >= 0 && column < playing_board[row].size && column >= 0
      if playing_board[row][column] == player_piece
        piece_count += 1
        column -= 1
        row -= 1
      else
        piece_count = 0
        column -= 1
        if column < 3
          row -= 1
          column = 7
        end
      end
        if piece_count == 4
          puts "Player #{player_piece} is the winner in a diagonal!"
        end
    end
end

---

我提出了一个在测试中似乎有效的解决方案。它从右下角到左上角，从8x8网格中第7行第7列开始。我还创建了从左下角到右上角的前对角线

我已经测试了一段时间，没有发现任何错误，但是我很想知道是否有人在上面戳洞

我非常感谢你们所有人——你们的解决方案和建议让我走到了这一步

def nw_diagonal_win (playing_board, player_piece)
    row = 7
    column = 7
    piece_count = 0
    while row < playing_board.size && row >= 0 && column < playing_board[row].size && column >= 0
      if playing_board[row][column] == player_piece
        piece_count += 1
        column -= 1
        row -= 1
      else
        piece_count = 0
        column -= 1
        if column < 3
          row -= 1
          column = 7
        end
      end
        if piece_count == 4
          puts "Player #{player_piece} is the winner in a diagonal!"
        end
    end
end

---

对于位置i处的元件，j设t=i-j。那么位置p，q处的元素是

---

---

在同一主对角线上，当且仅当p-q=t。变化的t产生所有的主对角线。除p+q=t外，每个前对角线上的元素具有类似的属性。请定义什么是“赢家”。很多读者，包括我在内，从来没有听说过这个游戏。你应该写一个函数，计算对角线上的点数，然后为每个对角线调用辅助函数。在n*n板上有2*n+n-1个对角线-两个方向，从第一行和第一行的每个元素开始column@CarySwoveland ... 我希望它到处都知道。。。或者至少是无限制的纸质版本。谢谢你们的帮助。如果我有任何澄清问题，我会回到评论中。@CarySwoveland我理解概念列7-第7行=0，因此对角线上的所有点都等于0 4,4；5，5等等，我只是不明白如何实现它。对于位置I处的元素，j让t=I-j。那么，位置p，q处的元素位于同一主对角线上，当且仅当p-q=t。变化的t产生所有的主对角线。除p+q=t外，每个前对角线上的元素具有类似的属性。请定义什么是“赢家”。很多读者，包括我在内，从来没有听说过这个游戏。你应该写一个函数，计算对角线上的点数，然后为每个对角线调用辅助函数。在n*n板上有2*n+n-1个对角线-两个方向，从第一行和第一行的每个元素开始column@CarySwoveland ... 我希望它到处都知道。。。或者至少是无限制的纸质版本。谢谢你们的帮助。如果我有任何澄清问题，我会回到评论中。@CarySwoveland我理解概念列7-第7行=0，因此对角线上的所有点都等于0 4,4；5，5等等，我只是不明白如何实现。我有点模糊，但我想我明白你的意思，史蒂夫。我写了一些代码，并将其添加到上述问题的末尾。你介意看一下吗？我在下面加了一个我想到的答案。它从r7、c7开始，从右下角移动到左上角。你认为有什么紧迫的问题吗？我已经测试了一段时间，我已经能够解决我遇到的问题。我认为你添加到问题中的代码不会起作用。我认为，如果工件数量增加，该列不需要增加。但是我看到你从卡里那里得到了一个答案，这在银行里通常是值得的。我有点模糊，但我想我理解你的意思，史蒂夫。我写了一些代码，并将其添加到上述问题的末尾。你介意看一下吗？我在下面加了一个我想到的答案。它从r7、c7开始，从右下角移动到左上角。你认为有什么紧迫的问题吗？我已经测试了一段时间，我已经能够解决我遇到的问题。我认为你添加到问题中的代码不会起作用。我认为，如果工件数量增加，该列不需要增加。但是我看到你从卡里那里得到了一个答案，而且在银行里这通常是值得的。谢谢！我真的对这个解决方案感兴趣，并将在这个项目之外更多地使用它！非常感谢。我真的对这个解决方案感兴趣，并将在这个项目之外更多地使用它！谢谢你的详细解释！我只是在学习Ruby，所以其中一些我不太理解，但我所能理解的帮助我想出了一个可行的解决方案。我已经添加了我的解决方案作为对此帖子的回答。如果你能给我任何建议或挖洞的话，我将不胜感激。要了解更多信息，物理玩具Connect4要求您将令牌插入顶部，然后重力将其降至最低位置。所以[4][2]位置的点和[3][2]位置的标记在物理上永远不会发生，除非，我猜，标记在下落时卡住了，这是我从未见过的happen@Christian，我做了编辑以澄清我的答案。如果回答了您的问题，请告诉我。0..2.map返回一个由三个元素组成的数组，映射为0、1和2。例如，考虑1。1被传递到块{| i | 0..grid.size-1-i.map{| j | grid[i+j][j]}，并且块变量i被设置为1。因此，i=1的块计算是0..grid.size-1-1.map{j | grid[1+j][j]}，它减少到0..4.map{j | grid[1+j][j]}，它等于[，，w，w，w]，因此i=1被映射到该5元素数组。对i=0和i=2进行了类似的计算。明白了吗？太好了，谢谢你花时间写这封信。在你的回答和评论之间，我只想抓住它：谢谢你的超级详细的解释！我只是在学习Ruby，所以其中一些我不太理解，但我所能理解的帮助我想出了一个可行的解决方案。我已经添加了我的解决方案作为对此帖子的回答。如果你能给我任何建议或挖洞的话，我将不胜感激。要了解更多信息，物理玩具Connect4要求您将代币插入顶部，然后重力将其放置在最低位置

---

叛乱。所以[4][2]位置的点和[3][2]位置的标记在物理上永远不会发生，除非，我猜，标记在下落时卡住了，这是我从未见过的happen@Christian，我做了编辑以澄清我的答案。如果回答了您的问题，请告诉我。0..2.map返回一个由三个元素组成的数组，映射为0、1和2。例如，考虑1。1被传递到块{| i | 0..grid.size-1-i.map{| j | grid[i+j][j]}，并且块变量i被设置为1。因此，i=1的块计算是0..grid.size-1-1.map{j | grid[1+j][j]}，它减少到0..4.map{j | grid[1+j][j]}，它等于[，，w，w，w]，因此i=1被映射到该5元素数组。对i=0和i=2进行了类似的计算。明白了吗？太好了，谢谢你花时间写这封信。在你的回答和评论之间，我只是想抓住它：