Arrays 按螺旋顺序打印矩阵

我试图按螺旋顺序（顺时针）打印数组，但我的代码无法正确打印

我的阵列是：

a = [
      [2,  4,  6,  8],
      [5,  9, 12, 16],
      [2, 11,  5,  9],
      [3,  2,  1,  8]
    ]

我的解决方案：

def print_circ(arr, row, col)
  t = 0
  b = row - 1
  l = 0
  r = col - 1
  dir = 0
  while t <= b and l <= r do
    if dir == 0
      for i in l..r
        puts arr[t][i]
      end
      t += 1
    end
    if dir == 1
      for i in t..b
        puts arr[i][r]
      end
      r -= 1
    end
    if dir == 2
      for i in r..l
        puts arr[b][i]
      end
      b -= 1
    end
    if dir == 3
      for i in b..t
        puts arr[i][l]
      end
      l += 1
    end
    dir = (dir+1)%4
  end
end

---

有人能帮我理解我的代码有什么问题吗？

你的代码中的错误在

r..l

和

b..t

，其中

r

大于

l

，而

b

大于

t

。定义从较高整数到较低整数的范围时，该范围实际上为空。例如：

irb> (0..3).to_a
 => [0, 1, 2, 3]
irb> (3..0).to_a
 => []

---

要修复反向迭代代码，可以将r..l中i的

循环更改为
（l..r）。反转每个do | i |。。。结束
代码中的错误位于
r..l
和
b..t
，其中
r
大于
l
，
b
大于
t
。定义从较高整数到较低整数的范围时，该范围实际上为空。例如：

irb> (0..3).to_a
 => [0, 1, 2, 3]
irb> (3..0).to_a
 => []

要修复反向迭代代码，可以将r..l中i的
循环更改为
（l..r）。反转每个do | i |。。。结束
在递减循环中应使用
downto

以下是您的代码修复：

def print_circ(arr, row, col)
  t = 0
  b = row - 1
  l = 0
  r = col - 1
  dir = 0

  while t <= b and l <= r do

    if dir == 0
      for i in l..r
        puts arr[t][i]
      end
      t += 1
    end

    if dir == 1
      for i in t..b
        puts arr[i][r]
      end
      r -= 1
    end

    if dir == 2
      for i in r.downto(l)
        puts arr[b][i]
      end
      b -= 1
    end

    if dir == 3
      for i in b.downto(t)
        puts arr[i][l]
      end
      l += 1
    end

    dir = (dir+1)%4

  end

end

print_circ([[2,4,6,8],[5,9,12,16],[2,11,5,9],[3,2,1,8]], 4, 4)

def打印循环（arr、row、col）
t=0
b=第1行
l=0
r=col-1
dir=0
而t则应在递减循环中使用
downto

以下是您的代码修复：

def print_circ(arr, row, col)
  t = 0
  b = row - 1
  l = 0
  r = col - 1
  dir = 0

  while t <= b and l <= r do

    if dir == 0
      for i in l..r
        puts arr[t][i]
      end
      t += 1
    end

    if dir == 1
      for i in t..b
        puts arr[i][r]
      end
      r -= 1
    end

    if dir == 2
      for i in r.downto(l)
        puts arr[b][i]
      end
      b -= 1
    end

    if dir == 3
      for i in b.downto(t)
        puts arr[i][l]
      end
      l += 1
    end

    dir = (dir+1)%4

  end

end

print_circ([[2,4,6,8],[5,9,12,16],[2,11,5,9],[3,2,1,8]], 4, 4)

def打印循环（arr、row、col）
t=0
b=第1行
l=0
r=col-1
dir=0
而你的代码问题已经解决了。我只是想为您的代码提供一个更地道的版本：

def each_spiral_value(arr)
  t = 0
  b = arr.size - 1
  l = 0
  r = arr.first.size - 1
  dir = [:right, :down, :left, :up].cycle

  while t <= b && l <= r
    case dir.next
    when :right
      l.upto(r) { |i| yield arr[t][i] }
      t += 1
    when :down
      t.upto(b) { |i| yield arr[i][r] }
      r -= 1
    when :left
      r.downto(l) { |i| yield arr[b][i] }
      b -= 1
    when :up
      b.downto(t) { |i| yield arr[i][l] }
      l += 1
    end
  end
end

each_spiral_value(a) { |v| puts v }

您的代码问题已经解决。我只是想为您的代码提供一个更地道的版本：

def each_spiral_value(arr)
  t = 0
  b = arr.size - 1
  l = 0
  r = arr.first.size - 1
  dir = [:right, :down, :left, :up].cycle

  while t <= b && l <= r
    case dir.next
    when :right
      l.upto(r) { |i| yield arr[t][i] }
      t += 1
    when :down
      t.upto(b) { |i| yield arr[i][r] }
      r -= 1
    when :left
      r.downto(l) { |i| yield arr[b][i] }
      b -= 1
    when :up
      b.downto(t) { |i| yield arr[i][l] }
      l += 1
    end
  end
end

each_spiral_value(a) { |v| puts v }

我不确定是谁首先回答的，因为我编辑了代码，因为错误对齐。哦，好吧……谢谢你提供关于唐托的信息@heng使用了相反的方法，但我只是想知道是否也可以在.each do循环中实现downto？如果是这样的话，你介意分享一个例子吗？
for i in r.downto（l）
——我觉得
for
和
downto
的组合很奇怪。由于
downto
已经提供了迭代，您只需使用
r.downto（l）do | i |
。我不确定是谁首先回答了这个问题，因为我编辑了代码，因为错误对齐。哦，好吧……谢谢你提供关于唐托的信息@heng使用了相反的方法，但我只是想知道是否也可以在.each do循环中实现downto？如果是这样的话，你介意分享一个例子吗？
for i in r.downto（l）
——我觉得
for
和
downto
的组合很奇怪。由于
downto
已经提供了迭代，您只需使用
r.downto（l）do | i |
。感谢您对Ruby中范围的说明！您的解释是正确的，但建议的解决方案不起作用：
（3..0）。请将每个都反转。to\u a
也为空。这是因为
reverse\u each
基于
each
（已为空）构建一个临时数组，然后以相反的顺序迭代该（空）数组。@Stefan这就是为什么我没有建议
（3..0）。reverse\u each
。我提出了
（0..3）。在这种情况下，将每个
反向，用
l=0
和
r=3
。）@你说的对，我忽略了你将
r..l
更改为
l..r
。感谢你对Ruby中范围的澄清！您的解释是正确的，但建议的解决方案不起作用：
（3..0）。请将每个都反转。to\u a
也为空。这是因为
reverse\u each
基于
each
（已为空）构建一个临时数组，然后以相反的顺序迭代该（空）数组。@Stefan这就是为什么我没有建议
（3..0）。reverse\u each
。我提出了
（0..3）。在这种情况下，将每个
反向，用
l=0
和
r=3
。）@对，我忽略了您将
r..l
更改为
l..r
。在Ruby中，您应该避免使用C或Java风格的
，对于
循环，使用迭代器，这样您就不必关心数组限制。我添加了一个更具Rubyesque风格的解决方案。在Ruby中，对于
循环，应该避免使用C或Java风格的
，使用迭代器，这样就不用担心数组限制。我添加了一个更加鲁比式的解决方案。