Question

我有一个数组数组，表示坐标值，如下所示：

cells = [ [0,0], [0,1] ]

数组中的每个数组都是X和Y值。所以，如果我想改变这一点，那么每个单元格上都会X+1。我可以把它表达为像这样的单元格：

delta = [1,0]

现在，我想要做的是将该值合并到每个单元格中，以便每个单元格的X值与delta值相加，因此在这种情况下，最终输出应为：

new_cells = [ [1,0], [1,1] ]

这是迄今为止我能想到的最好的，看起来真的很重：

cells = [[0,0],[0,1]]
delta = [1,0]
cells.each do |cell|
  cell[0] = cell[0] + delta[0]
  cell[1] = cell[1] + delta[1]
end
# Now cells = [[1,0],[1,1]]

是否有一种更简洁的单行方法可以将数组加到数组链中的每个数组上，或者上面是解决该问题的最佳解决方案？

Answer 1

我认为您最好的解决方案是识别单元格和增量是一种不同的数据类型，如果它不是数组，您可以更清楚地操作：

Cell = Struct.new(:x, :y) do 
  def + other
    Cell.new(self.x + other.x, self.y + other.y)
  end
end

# cells is some array of Cell objects
# delta is some Cell object

cells.map! {|cell| cell + delta}

Answer 2

下面：

cells = cells.map {|c| [c[0] + delta[0], c[1] + delta[1]] }

Answer 3

cells.map! {|x, y| [x + delta[0], y + delta[1]] }

请注意，如果其他人对单元格数组或数组中包含的单元格之一有引用，则Linuxios的答案，我的答案和解决方案都会产生不同的效果。只有您的答案会修改原始单元格，因此使用我的解决方案或Linuxios解决方案时，参考可能仍然指向旧数据。

Answer 4

cells.map {|cell| cell.zip(delta).map{|x, y| x + y }}

我认为这比其他已经提出的解决方案更清洁。

Answer 5

以下是您不必担心将单元格键与delta的匹配：

cells = cells.map {|cell| [cell,delta].transpose.map {|value| value.reduce(:+)}}

一步一步：

cells = cells.map { |cell|         # => [0,0]

  combined = [cell, delta]         # => [[0,0], [1,0]]

  transposed = combined.transpose  # => [[0, 1], [0, 0]]

  new_c = transposed.map { |value| # => [0, 1]

    value.reduce(:+)               # => 1, => 0

  }

  new_c                            # => [1,0] As expected for first cell.
}

cells                              # => [[1,0],[1,1]] Final result

使用另一个样本数据：

cells = [[0,0],[1,1],[2,2]]
delta = [1,1]
plug  = Proc.new {
  cells = cells.map { |cell| [cell, delta].transpose.map { |value| value.reduce(:+) } }
}

plug.call # => [[1, 1], [2, 2], [3, 3]]
plug.call # => [[2, 2], [3, 3], [4, 4]]
plug.call # => [[3, 3], [4, 4], [5, 5]]
plug.call # => [[4, 4], [5, 5], [6, 6]]
plug.call # => [[5, 5], [6, 6], [7, 7]]

另一个：

cells = [[0,0,0],[0,1,2],[1,2,3],[2,3,4]]
delta = [3,2,1]

plug.call # => [[3, 2, 1],   [3, 3, 3],   [4, 4, 4],   [5, 5, 5]]
plug.call # => [[6, 4, 2],   [6, 5, 4],   [7, 6, 5],   [8, 7, 6]]
plug.call # => [[9, 6, 3],   [9, 7, 5],   [10, 8, 6],  [11, 9, 7]]
plug.call # => [[12, 8, 4],  [12, 9, 6],  [13, 10, 7], [14, 11, 8]]
plug.call # => [[15, 10, 5], [15, 11, 7], [16, 12, 8], [17, 13, 9]]

希望这能更好地回答你的问题。

Ruby：组合数组值

5 个答案: