ruby-如何从字符串数组中生成可能的字母顺序组合？

我有一个字符串数组：

["ABC", "GHI"]

我想要所有的字母组合，从左到右读，即

["AG", "AH", "AI", "BG", "BH", "BI", "CG", "CH", "CI"]

但不是

"GA", "GB", "HA", etc.

"DAG", "GAD" or "GFA"

同样地

["ABC", "DEF", "GHI"]

应该产生

["ADG", "ADH", "ADI", "AEG", "AEH", "AEI", "AFG", "AFH", "AFI", "BDG", "BDH", 
"BDI", "BEG", "BEH", "BEI", "BFG", "BFH", "BFI", "CDG", "CDH", "CDI", "CEG", 
"CEH", "CEI", "CFG", "CFH" "CFI"]

但不是

"GA", "GB", "HA", etc.

"DAG", "GAD" or "GFA"

这就是您需要的：

a = ["ABC","DEF", "GHI"]
a.map(&:chars).reduce(&:product).map(&:join)

顺便说一下，您在示例输出中犯了一些错误，根据您的规范，不应该有以E或F开头的字符串。所以我想你不是说“ECH”、“ECI”、“FCG”、“FCH”、“FCI”，而是说“CEH”、“CEI”、“CFG”、“CFH”、“CFI”

编辑：

chars

返回一个枚举数，而不是数组，在Ruby 2.0之前的版本中，没有

product

方法。因此，在这些版本中，只需使用

来

a.map(&:chars).map(&:to_a).reduce(&:product).map(&:join)

与@ggPeti解决方案相比的基准：

t = Time.now
50000.times do
  a.map(&:chars).reduce(&:product).map(&:join)
end
puts Time.now - t
# => 2.037303374

t = Time.now
50000.times do
  first, *rest = a.map{|s| s.each_char.to_a}
  first.product(*rest).map(&:join)
end
puts Time.now - t
# => 1.670047516

def doit(b)
  recurse(b.map(&:chars))
end

def recurse(a)
  (a.size==2 ? a.first.product(a.last) :a.shift.product(recurse a)).map(&:join)
end

doit(["ABC", "DEF", "GHI"])  
  #=> ["ADG", "ADH", "ADI", "AEG", "AEH", "AEI", "AFG", "AFH", "AFI",
  #    "BDG", "BDH", "BDI", "BEG", "BEH", "BEI", "BFG", "BFH", "BFI",
  #    "CDG", "CDH", "CDI", "CEG", "CEH", "CEI", "CFG", "CFH", "CFI"] 

doit(["ABC", "DE", "FGHI"])
  #=> ["ADF", "ADG", "ADH", "ADI", "AEF", "AEG", "AEH", "AEI",
  #    "BDF", "BDG", "BDH", "BDI", "BEF", "BEG", "BEH", "BEI",
  #    "CDF", "CDG", "CDH", "CDI", "CEF", "CEG", "CEH", "CEI"]

递归解决方案：

t = Time.now
50000.times do
  a.map(&:chars).reduce(&:product).map(&:join)
end
puts Time.now - t
# => 2.037303374

t = Time.now
50000.times do
  first, *rest = a.map{|s| s.each_char.to_a}
  first.product(*rest).map(&:join)
end
puts Time.now - t
# => 1.670047516

def doit(b)
  recurse(b.map(&:chars))
end

def recurse(a)
  (a.size==2 ? a.first.product(a.last) :a.shift.product(recurse a)).map(&:join)
end

doit(["ABC", "DEF", "GHI"])  
  #=> ["ADG", "ADH", "ADI", "AEG", "AEH", "AEI", "AFG", "AFH", "AFI",
  #    "BDG", "BDH", "BDI", "BEG", "BEH", "BEI", "BFG", "BFH", "BFI",
  #    "CDG", "CDH", "CDI", "CEG", "CEH", "CEI", "CFG", "CFH", "CFI"] 

doit(["ABC", "DE", "FGHI"])
  #=> ["ADF", "ADG", "ADH", "ADI", "AEF", "AEG", "AEH", "AEI",
  #    "BDF", "BDG", "BDH", "BDI", "BEF", "BEG", "BEH", "BEI",
  #    "CDF", "CDG", "CDH", "CDI", "CEF", "CEG", "CEH", "CEI"]

在这种情况下，为什么只使用
flat\u map
而不使用
map
？这是一个错误，同时将其编辑掉了。实际上，
平面地图
也可以，只是不需要。好吧，酷。我很好奇，知道了
:product
和
:flat\u map
做什么。我不知道我能做到。干杯这是可行的，但我认为应该有一种更有效的方法。用什么标准衡量效率？这是一个易于阅读、易于理解的短行代码，程序员需要5秒钟来编写。除了要求的输出，您从未在问题中陈述过任何其他内容。请接受我的回答，因为这确实有效，如果您有特定需求，请提交一个新的答案。您指定的数组遵循什么规则尚不清楚。另外，您编写了您想要的组合，但这似乎与您想要的是
“AG”
，而不是
“GA”
相矛盾。问题不清楚。请：）@sawa有道理。也不清楚是什么决定了组合的长度。你只想知道字符串数组的长度吗？我刚开始写这样的东西。。为什么不使用
#split
？@ArupRakshit而不是
每个字符
？这是一种更为间接的方法。@sawa那么
s.scan（/。/）
会是什么样子呢？如果它工作，那么您不需要键入-
s.each_char.to_a
。：-）@我不是在打代码高尔夫。我优先考虑概念上的简单性，而不是减少必须键入的字符数。顺便说一句，在我的基准测试中，使用
map（&:chars）
比
map{s}快10%左右。我想你的意思是“非破坏性”。（但是，当然，由于
map
是非破坏性的，
dup
是不需要的
：）
）-2对我来说，安德鲁，但是-1对你来说，因为你第一次没有看到。你给了自己-1。。你真大胆p+1看起来不错，虽然我尝试了一个长单词，但得到了
doit（[“MUMMIFICATION”]）SystemStackError:堆栈级别太深