Ruby 螺旋矩阵算法

在下面的问题中，我很难解释奇数输入情况：给定一个由m x n个元素（m行，n列）组成的矩阵，按螺旋顺序返回矩阵的所有元素

For example,
Given the following matrix:

[
 [ 1, 2, 3 ],
 [ 4, 5, 6 ],
 [ 7, 8, 9 ]
]
You should return [1,2,3,6,9,8,7,4,5].

我的代码适用于所有更大的测试用例，但在以下情况下失败

[[6,9,7]]

我不知道如何构造代码来处理这些输入。有人有想法吗

def spiral_order(matrix)
    return nil if matrix.nil? 
    return [] if matrix.empty?
    m = matrix.length - 1
    n = matrix.first.length - 1
    start_col = start_row = 0 
    end_col = n
    end_row = m
    visited = []
    iter = 0
    until start_row > end_row && start_col > end_col
        until iter > end_col
            visited << matrix[start_row][iter]
            iter+=1
        end
        start_row += 1
        iter = start_row

        until iter > end_row
            visited << matrix[iter][end_col]
            iter += 1
        end
        end_col -= 1
        iter = end_col

        until iter < start_col
            visited << matrix[end_row][iter]
            iter-=1
        end
        end_row -= 1
        iter = end_row

        until iter < start_row 
            visited << matrix[iter][start_col]
            iter -= 1
         end
         start_col += 1
         iter = start_col
    end

    visited
end

def螺旋顺序（矩阵）
如果matrix.nil，则返回nil？
如果矩阵为空，返回[]？
m=矩阵长度-1
n=矩阵.first.length-1
开始列=开始行=0
end_col=n
end_行=m
已访问=[]
iter=0
直到开始行>结束行和开始列>结束列
直到iter>结束
参观完罗夫街
这可以用一组简单得多的代码来解决。从矩阵中剥离最上面的一行，旋转矩阵，重复此操作直到为空

def spiral_order(matrix)
  m = matrix.dup
  result = []
  until m.size < 1
    result << m.shift
    m = m.transpose.reverse
  end
  result.flatten
end

>> matrix = [[1,2,3],[4,5,6],[7,8,9]]
>> spiral_order(matrix)
=> [1, 2, 3, 6, 9, 8, 7, 4, 5]

>> matrix = [[6,9,7]]
>> spiral_order(matrix)
=> [6, 9, 7]

def螺旋顺序（矩阵）
m=matrix.dup
结果=[]
直到m.尺寸<1
结果>矩阵=[[1,2,3]，[4,5,6]，[7,8,9]]
>>螺旋序（矩阵）
=> [1, 2, 3, 6, 9, 8, 7, 4, 5]
>>矩阵=[[6,9,7]]
>>螺旋序（矩阵）
=> [6, 9, 7]

如果您正在处理大型矩阵，并且希望避免多次重复，为了增加一点复杂性，您可以这样做：

def spiral_order(matrix)
  m = matrix.map(&:dup)
  result = []
  until m.size < 1
    result << m.shift
    result << m.map(&:pop)
    result << (m.pop || []).reverse
    result << m.map(&:shift).reverse
  end
  result.flatten.compact
end

def螺旋顺序（矩阵）
m=矩阵映射（&:dup）
结果=[]
直到m.尺寸<1
结果矩阵总是平方的吗？如果是这样，我认为您可以在数组上使用枚举选项。对于以下步骤，请打印该值，然后删除/pop以使其不被使用。1） 从索引2开始的每个数组中最上面一行（第2行）的最后一项的值。3） 底部数组使用反向，每个数组的第一项都是反向的。你们很接近了。您需要添加检查，以便无论何时将任一维度的大小减小到零（start\u col==end\u col，start\u row==end\u row），都可以立即从外部循环中断。目前，您的代码一直在尝试添加不应添加的元素。@Gene when end\u row==start\u row，这意味着此最后一行之外的所有元素都已被访问。但是，如果top_col和end_col之间存在差异，那么本专栏中的元素是否仍然需要访问？我就是这么想的。。因此，我没有包括break语句可能重复的Sorry应该有
start\u col>end\u col
和
start\u row>end\u row
。例如，在您的“坏”示例中，在您访问了“顶”行（在本例中是唯一一行）之后，
start\u row
将递增，因此
start\u row>end\u row
，这意味着您应该完成。当前的算法没有停止，所以它最终尝试访问不应该访问的元素。我稍微修改了一下，以避免对传递给该方法的矩阵进行变异。此算法不考虑维度，在传递空矩阵时返回
[[]]
。