有什么辦法可以從較大的陣列/矩陣創建2 x 2陣列/矩陣

Question

Ruby的新手，目前正在學習。

我不確定是否應該為此使用數組或矩陣。

我有數組

[['J','O','I','J','O'],
 ['I','J','O','J','O'],
 ['I','I','J','I','J']]

我想找出您在圖像中看到的以下內容。

['J', 'O']
['I', 'J'] 

我當時以為是使用Ruby Matrix，但是我不確定是否可以將原始數組/矩陣划分為2到2的小矩陣塊，以及是否與[J, O], [I, J]匹配。

還是應該使用數組並遍歷。

我感謝任何投入。

Answer 1

您可以定義以下內容：

def find_in_matrix(matrix, target)
  (0..matrix.length-target.length).to_a.product(
    (0..matrix.first.length-target.first.length).to_a).select do |x, y|
    (0...target.length).to_a.product(
      (0...target.first.length).to_a).all? do |test_x, test_y|
      matrix[x+test_x][y+test_y] == target[test_x][test_y]
    end
  end
end

matrix = [["J", "O", "I", "J", "O"], 
          ["I", "J", "O", "J", "O"], 
          ["I", "I", "J", "I", "J"]]

target = [["J", "O"],
          ["I", "J"]]

find_in_matrix(matrix, target)
 => [[0, 0], [1, 1], [1, 3]] 

該解決方案簡單地越過的所有子矩陣matrix與target的大小，並且選擇那些等於它。

Answer 2

不是直接回答問題，也不是獲得匹配位置的有效方法：

matrix = [
  %w(J O I J O),
  %w(I J O J O),
  %w(I I J I J)
]

target = [
  %w(J O),
  %w(I J)
]

matrix.each_cons(target.length).each_with_index do |sub, row|
  sub.map{|a| a.each_cons(target[0].length).to_a}.tap do |sub|
    head = sub.shift
    head.zip(*sub).each_with_index do |m, col|
      if m == target
        puts "#{row}, #{col}"
      end
    end
  end
end

Answer 3

我建議您使用Matrix＃minor方法來執行此操作。

碼

require 'matrix'

def find_in_matrix(arr,sub)
  sub_nrows = sub.size
  sub_ncols = sub.first.size
  rows      = Array[*0..arr.size-sub_nrows]
  cols      = Array[*0..arr.first.size-sub_ncols]
  arr_m     = Matrix[*arr]
  sub_m     = Matrix[*sub]
  rows.product(cols).select {|i,j| arr_m.minor(i,sub_nrows,j,sub_ncols)==sub_m}
end

例

arr = [['J','O','I','J','O'],
       ['I','J','O','J','O'],
       ['I','I','J','I','J']]

sub = [['J', 'O'],
       ['I', 'J']]

find_in_matrix(arr,sub)                    #=> [[0, 0], [1, 1], [1, 3]]
find_in_matrix(arr, [['O'], ['J']])        #=> [[0, 1], [1, 2], [1, 4]]
find_in_matrix(arr, [['O']])               #=> [[0, 1], [0, 4], [1, 2], [1, 4]]
find_in_matrix(arr, [['I','J','O']])       #=> [[0, 2], [1, 0]]
find_in_matrix(arr, [['I','J'],['J','O']]) #=> []
find_in_matrix(arr, [[]])                  #=> [[0, 0], [0, 1],...,[0, 5]] 
                                           #    [1, 0], [1, 1],...,[1, 5]]
                                           #    [2, 0], [2, 1],...,[2, 5]]

說明

對於上面的示例：

sub_nrows = sub.size                              #=> 2
sub_ncols = sub.first.size                        #=> 2
rows      = Array[*0..(arr.size-sub_nrows)]       #=> [0, 1]
cols      = Array[*0..(arr.first.size-sub_ncols)] #=> [0, 1, 2, 3]
arr_m     = Matrix[*arr]
  #=> Matrix[["J", "O", "I", "J", "O"], ["I", "J", "O", "J", "O"],
  #          ["I", "I", "J", "I", "J"]]
sub_m     = Matrix[*sub]
  #=> Matrix[["J", "O"], ["I", "J"]]

a = rows.product(cols)
  #=> [[0, 0], [0, 1], [0, 2], [0, 3], [1, 0], [1, 1], [1, 2], [1, 3]]
a.select {|i,j| arr_m.minor(i,sub_nrows,j,sub_ncols)==sub_m}
  #=> [[0, 0], [1, 1], [1, 3]]

考慮select的a的第一個元素進入塊： [0, 0] （即，塊變量i和j都被賦值為零）。 因此，我們計算：

arr_m.minor(i,sub_nrows,j,sub_ncols) #=> arr_m.minor(0,2,0,2) 
  #=> Matrix[["J", "O"], ["I", "J"]]

如

arr_m.minor(0,2,0,2) == sub_m

[0, 0] 。 在另一方面，對於元件[1, 2]的a ， i => 1, j => 2 ，因此：

arr_m.minor(i,sub_nrows,j,sub_ncols) #=> arr_m.minor(1,2,2,2) 
  #=> Matrix[["O", "J"], ["J", "I"]]

不等於sub_m ，因此未選擇元素[1, 2] 。

請注意， Matrix#minor具有兩種形式。 我使用了帶有四個參數的表格。 另一種形式采用兩個范圍作為參數。