我如何反转二维数组（RUBY）中的单个（和特定）列

Question

RUBY目标是从四个区域中的每个区域中获取最大值并获得它们的总和。

更新我想出了一个解决方案，我很抱歉混淆了。 事实证明，该矩阵是一个 2n x 2n 矩阵，因此实际上它可能大于或小于 4x4。 我在下面编写的解决方案适用于所有测试用例。 这是问题的链接

我尝试做 matrix.transpose 然后我尝试反转特定的数组，这不适用于所有边缘情况。 这是代码

def flippingMatrix(matrix)
    2.times do
        matrix = matrix.transpose
        matrix = matrix.map do |array|
            if (array[-1] == array.max) || (array[-2] == array.max)
                array.reverse
            else
                array
            end
        end    
    end
    return matrix[0][0] + matrix[0][1] + matrix[1][0] + matrix[1][1]
end

我放弃并尝试了下面的方法，在我看来，它也适用于大多数边缘情况，但不是全部。 但是当我打印结果或 spot_1、spot_2、spot_3 或 spot_4 时，请记住我得到一个错误（ undefined method `[]' for nil:NilClass (NoMethodError) ）我得到了正确的答案。 有谁知道为什么会这样？

这是一个失败的矩阵

[
[517, 37, 380, 3727], 
[3049, 1181, 2690, 1587], 
[3227, 3500, 2665, 383], 
[4041, 2013, 384, 965]
]
**expected output: 12,881 (this fails)**
**because 4041 + 2013 + 3227 + 3500 = 12,881**

这是一个通过的矩阵

[
[112, 42, 83, 119],
[56, 125, 56, 49],
[15, 78, 101, 43],
[62, 98, 114, 108],
] 
**expected output: 414 (this passes)**

这是代码

def flippingMatrix(matrix)
    # Write your code here 
    spot_1 = [matrix[0][0] , matrix[0][3] , matrix[3][0] , matrix[3][3]].max
    spot_2 = [matrix[0][1] , matrix[0][2] , matrix[3][1] , matrix[3][2]].max
    spot_3 = [matrix[1][0] , matrix[1][3] , matrix[2][0] , matrix[2][3]].max
    spot_4 = [matrix[1][1] , matrix[1][2] , matrix[2][1] , matrix[2][2]].max
    return (spot_1 + spot_2 + spot_3 + spot_4)
end 

Answer 1

这是我要做的：

matrix1 = [
[517, 37, 380, 3727], 
[3049, 1181, 2690, 1587], 
[3227, 3500, 2665, 383], 
[4041, 2013, 384, 965]
]

matrix2 = [
[112, 42, 83, 119],
[56, 125, 56, 49],
[15, 78, 101, 43],
[62, 98, 114, 108],
] 

def matrix_test(m)
  mt = m.transpose  #used for checking columns (Zone C)

  z_a = [m.first.first, m.first.last, m.last.first, m.last.last].max  #first and last elements of first and last rows
  z_b = (m.first[1..-2] + m.last[1..-2]).max  #middle elements of first and last rows
  z_c = (mt.first[1..-2] + mt.last[1..-2]).max  #middle elements of first and last columns
  z_d = m[1..-2].map {|arr| arr[1..-2]}.flatten.max  #middle elements of middle rows

  sum = z_a+z_b+z_c+z_d
end

matrix_test(matrix1)
#=> 12781

matrix_test(matrix2) 
#=>  414

这种方法也可以用于更大的矩阵。

Answer 2

我将回答您的问题，同时提出另一种获得所需金额的方法。

认为

arr = [
  [  1,   30,   40,   2],
  [300, 4000, 1000, 200],
  [400, 3000, 2000, 100],
  [  4,   10,   20,   3]
]

我们看到所需的返回值为4444 。 这对应于

A B B A
C D D C
C D D C
A B B A

首先创建三个辅助方法。

---

计算四个内部元素中的最大值

def mx(arr)
  [arr[1][1], arr[1][2], arr[2][1], arr[2][2]].max
end

mx(arr)
  #=> 4000

这是“D”值中的最大值。

---

反转前两行和最后两行

def row_flip(arr)
  [arr[1], arr[0], arr[3], arr[2]]
end

row_flip(arr)
  #=> [[300, 4000, 1000, 200],
  #    [  1,   30,   40,   2],
  #    [  4,   10,   20,   3],
  #    [400, 3000, 2000, 100]]

这允许我们使用方法mx来获得最大的“B”值。

---

反转前两列和后两列

def column_flip(arr)
  row_flip(arr.transpose).transpose
end

column_flip(arr)
  #= [[  30,   1,   2,   40],
  #   [4000, 300, 200, 1000],
  #   [3000, 400, 100, 2000],
  #   [  10,   4,   3,   20]]

这允许我们使用方法mx来获得最大的“C”值。

---

我们看到“A”值的最大值等于

t =  row_flip(column_flip(arr))
  #=> [[4000, 300, 200, 1000],
  #    [  30,   1,   2,   40],
  #    [  10,   4,   3,   20],
  #    [3000, 400, 100, 2000]]   

mx(column_flip(t))
  #=> 4

因此可以如下计算最大值的总和。

def sum_max(arr)
  t = column_flip(arr) 
  mx(arr) + mx(row_flip(arr)) + mx(t) +    mx(row_flip(t))
end

sum_max(arr)
  #=> 4444

Answer 3

啊，我想出了一个可以回答所有边缘情况的答案。 我最初在 Javascript 中看到了类似的东西，然后把它变成了 Ruby。 显然，一些隐藏的边缘情况（被隐藏的）并非都是 4 乘 4，有些更小，有些更大，这就是 nil 错误的原因。

这是解决方案：

def flippingMatrix(m)
    l = matrix.length - 1
    sm = (matrix.length/2).floor()
    total = []
    
    for i in 0...sm
        for j in 0...sm
            total << [m[i][j], m[l-i][j], m[i][l-j], m[l-i][l-j]].max
        end
    end
    
    return total.sum
end

谢谢大家的支持。 我希望这可以在不久的将来帮助某人。