Question

也许有人可以帮我解决这个问题。我有一个数组数组。内部阵列具有不同的大小（从2到4个元素）。

letters = [["A", "B"],["C", "D", "F", "G"],["H", "I", "J" ]]

我正在尝试在第一列元素[0]和元素[1]连接的每个数组的相同行中打印，因为第二列元素[0]，元素[1]，元素[2]作为第3列连接列元素[0]，元素[1]，元素[3]连接。元素2和3并不总是存在。

我想要的输出是这样的：

AB
CD CDF CDG
HI HIJ

我正在这样做，但我收到了这个错误。

letters.map{|x| puts x[0]+x[1] + "," + x[0]+x[1]+x[2] + "," + x[0]+x[1]+x[3]}
TypeError: no implicit conversion of nil into String
        from (irb):1915:in "+"
        from (irb):1915:in "block in irb_binding"
        from (irb):1915:in "map"
        from (irb):1915
        from /usr/bin/irb:11:in "<main>"

Answer 1

letters.each do |a,b,*rest|
  puts rest.each_with_object([a+b]) { |s,arr| arr << arr.first + s }.join(' ')
end

打印

AB
CD CDF CDG
HI HIJ

步骤如下。

假设

letters =  [["C", "D", "F", "G"],["H", "I", "J" ]]

然后

enum0 = letters.each
  #=> #<Enumerator: [["C", "D", "F", "G"], ["H", "I", "J"]]:each>

生成此枚举数的第一个元素并将其传递给块，并为三个块变量赋值。

a, b, *rest = enum0.next
  #=> ["C", "D", "F", "G"]
a
  #=> "C"
b 
  #=> "D"
rest
  #=> ["F", "G"]

接下来，我们获得

enum1 = rest.each_with_object([a+b])
  #=> rest.each_with_object(["CD"]) 
  #=> #<Enumerator: ["F", "G"]:each_with_object(["CD"])>

生成此枚举数的第一个元素并将其传递给块，并为块变量赋值。

s, arr = enum1.next
  #=> ["F", ["CD"]]
s
  #=> "F"
arr
  #=> ["CD"]

现在执行块计算。

arr << arr.first + s
  #=> arr << "CD" + "F"
  #=> ["CD", "CDF"]

生成enum1的第二个和最后一个元素并将其传递给块，并为块变量赋值并计算块。

s, arr = enum1.next
  #=> ["G", ["CD", "CDF"]]
arr << arr.first + s
  #=> ["CD", "CDF", "CDG"]

当尝试从enum1生成另一个元素时，我们获得了

enum1.next
  #StopIteration: iteration reached an end

Ruby通过突破块并返回arr来处理异常。然后加入arr的元素：

arr.join(' ')
  #=> "CD CDF CDG"

并打印。

现在生成enum0的第二个和最后一个元素，传递给块，并为三个块变量赋值。

a, b, *rest = enum0.next
  #=> ["H", "I", "J"]
a
  #=> "H"
b
  #=> "I"
rest
  #=> ["J"]

其余的计算方法类似。

有些读者可能不熟悉广泛使用的方法Enumerable#each_with_object。阅读文档，但请注意，这里产生的结果与编写如下的代码相同。

letters.each do |a,b,*rest|
  arr = [a+b]
  rest.each { |s| arr << arr.first + s }
  puts arr.join(' ')
end

通过使用each_with_object，我们避免使用语句arr = [a+b]和语句puts arr.join(' ')。这两个语句的功能当然在使用each_with_object的行中，但是当链接 each_with_object到join(' ')时，大多数Ruby用户更喜欢这个流程。另一个区别是arr的值仅限于each_with_object的块，这是一种很好的编程习惯。

Answer 2

看起来你想要加入前两个字母，然后把余下的笛卡尔积。

letters.each do |arr|
   first = arr.take(2).join
   rest = arr.drop(2)
   puts [first, [first].product(rest).map(&:join)].join(" ")
end

这提供了您指定的确切输出。

Answer 3

出于好奇，Enumerable#map - 只有解决方案。

letters = [["A", "B"],["C", "D", "F", "G"],["H", "I", "J" ]]

letters.map do |f, s, *rest|
  rest.unshift(nil).map { |l| [f, s, l].join }.join(' ')
end.each(&method(:puts))

#⇒ AB
#  CD CDF CDG
#  HI HIJ

在Ruby中打印同一行中不同大小的数组数组的元素

3 个答案: