Ruby：递归函数应该从子数组返回最大值数组的问题

以下函数用于接收数组数组并返回其子数组的最大值

def temp(list)
  if list.all? { |i| i.kind_of?(Array) }
    return(list.each { |j| j.max })
  else
    return(list)
  end
end

因此，给出如下列表和函数调用：

x = [[1, 2], [3, 4]]

temp(x)

它应该返回[2,4]，但它只返回原始数组[[1,2]，[3,4]]。我想知道这里出了什么问题

---

谢谢

在对列表的每个成员运行代码块后，您将返回列表本身。相反，您可以在函数中创建另一个列表，并将

max

值推送到该列表中，然后返回它

def temp(list)
  if list.all? { |i| i.kind_of?(Array) }
    maxlist=[]
    list.each { |j| maxlist << j.max }
    return maxlist
  else
    return(list)
  end
end

x = [[1, 2], [3, 4]]

puts temp(x)

def温度（列表）
如果是全部？{| i | i.kind_？（数组）}
maxlist=[]
list.each{| j | maxlist在对列表的每个成员运行代码块后，您将返回列表本身。相反，您可以在函数内创建另一个列表，并将
max
值推送到该列表内，返回它

def temp(list)
  if list.all? { |i| i.kind_of?(Array) }
    maxlist=[]
    list.each { |j| maxlist << j.max }
    return maxlist
  else
    return(list)
  end
end

x = [[1, 2], [3, 4]]

puts temp(x)

def温度（列表）
if list.all？{| i | i.kind_of？（数组）}
maxlist=[]
list.each{j|maxlist
每个
对数组的每个元素进行操作，然后返回（原始）数组。需要的方法是
map
：

def temp(list)
  if list.all? {|i| i.kind_of?(Array) }
    list.map {|j| j.max }
  else
    list
  end
end

x = [[1, 2], [3, 4]]
temp(x)
# => [2, 4]

但是，显式类型检查在Ruby中并不惯用，Ruby更喜欢duck类型。不要检查
i
是否是数组；只检查它是否响应
max
：

def temp(list)
  return list unless list.all? {|i| i.respond_to?(:max) }
  list.map(&:max)
end

each
对数组的每个元素进行操作，然后返回（原始）数组。您需要的方法是
map
：

def temp(list)
  if list.all? {|i| i.kind_of?(Array) }
    list.map {|j| j.max }
  else
    list
  end
end

x = [[1, 2], [3, 4]]
temp(x)
# => [2, 4]

但是，显式类型检查在Ruby中并不惯用，Ruby更喜欢duck类型。不要检查
i
是否是数组；只检查它是否响应
max
：

def temp(list)
  return list unless list.all? {|i| i.respond_to?(:max) }
  list.map(&:max)
end

如果您放宽了
all？
要求，那么

试试这个

def temp(list)
  list.map { |l| Array(l).max }
end

这是怎么回事


Array（l）
将数组转换为数组
并将其他对象转换为单元素数组
并将
nil
转换为空数组
因此，我们总是可以调用
max
如果您放宽了
all？
要求，那么

试试这个

def temp(list)
  list.map { |l| Array(l).max }
end

这是怎么回事


Array（l）
将数组转换为数组
并将其他对象转换为单元素数组
并将
nil
转换为空数组
因此，我们总是可以调用
max
我们甚至可以将其进一步简化为
list.map{each}[*each].max}
如果他们对处理混合数组很在行的话。我想他们可能是这样。我们甚至可以将其进一步简化为
list.map{each}[*each].max}
如果他们对处理混合数组很在行。我想他们可能是这样。你也可以做
list.map{l|l.send（l.respond_to？（：max）？：max：：self）}
来允许在同一级别混合数组和标量。@MarkReed或
list.map{l.respond_to？（：max）？l.max:l}
。你可以使用
list.map{code>all.[*l].max}
如果我们放宽了
all.
的要求。不，太清楚了。
list.map{code>l.send%i{max本身}。查找{s}l.respond_to？s}
public_-send
比
send
更受欢迎，不？你也可以做
list.map{l.send:max}
允许在同一级别混合数组和标量。@MarkReed或
list.map{l|l.response_to？（：max）？l.max:l}
。如果我们放松
all？
要求，您可以使用
list.map{l{l}[*l].max}
。不，太清楚了。
list.map{l}l.send%i{max本身如何{| s | l.回应| s}
；-）
public\u send
比
send
更受欢迎，不是吗？初始化一个空列表，然后使用
每个
附加到列表中是非常不明智的。
map
是您应该在这里使用的。@meagar当然！我对Ruby还不是很有经验，只是在阅读了Jordan的答案后才想起这个方法。不是我不认为在它之后编辑我的列表是公平的！初始化一个空列表，然后使用
每个
附加到它上面是非常不公平的。
映射
是你应该在这里使用的。@meagar当然！我对Ruby还不是很有经验，只是在阅读Jordan的答案后才想起这个方法。我认为编辑我的列表是不公平的在它之后！你通常更喜欢
Array（l）
，它几乎不涉及任何杂音，而不是
[*l]
，后者是一种非常昂贵的将数组转换为自身的方法，在功能上是一种无操作。你通常更喜欢
Array（l）
，它几乎不涉及杂音，而不是
[*l]
这是一种非常昂贵的将数组转换为自身的方法，从功能上讲是不可操作的。