多次迭代

Question

有没有写这样的代码更简单，更清洁的方式：

(1..10).each do |i| 
    (1..10).each do |j| 
    (1..10).each do |k| 
     (1..10).each do |l| 
     puts "#{i} #{j} #{k} #{l}" 
     end 
    end 
    end 
end 

理想我可以做这样的事情......

(1..10).magic(4) { |i, j, k, l| puts "#{i} #{j} #{k} #{l}" } 

甚至更​​好.. 。

magic(10, 4) { |i, j, k, l| puts "#{i} #{j} #{k} #{l}" } 

如果有没有内置的东西，怎么会写我喜欢最后一个方法？

Answer 1

如果你在Ruby 1.9的，你可以这样做：

range = (1..10).to_a 
range.repeated_permutation(4) do |set| 
    puts set.join(" ") 
end 

在Ruby 1.8：

range = (1..10).to_a 
range.product(range, range, range).each do |set| 
    puts set.join(" ") 
end 

Answer 2

dmarkow的解决方案（我相信）物化的范围，并且至少在理论上，使用更多的内存比你需要。这里有一个办法做到这一点，而不将范围：

def magic(ranges, &block) 
    magic_ = lambda do |ranges, args, pos, block| 
    if pos == ranges.length 
     block.call(*args) 
    else 
     ranges[pos].each do |i| 
     args[pos] = i 
     magic_.call(ranges, args, pos+1, block) 
     end 
    end 
    end 
    magic_.call(ranges, [nil]*ranges.length, 0, block) 
end 

magic([1..10] * 4) do |a,b,c,d| 
    puts [a, b, c, d].inspect 
end 

这就是说，性能是一个棘手的事情，我不知道Ruby的效率如何与函数调用，所以也许坚持的库函数是最快的方法去。

更新：采取了Phrogz的建议，并把magic_内magic。 （更新：采取了Phrogz的建议再次，并希望这次与lambda而不是def正确）。

更新：Array#product返回Array，所以我假设完全物化。我没有Ruby 1.9.2，但是MladenJablanović指出Array#repeated_permutation可能不会实现整个事情（尽管最初的范围是to_a）。

Answer 3

我已经采取改变你magic参数的假设下，该基地10是比较常见的和可选顺序的自由：

def magic(digits,base=10) 
    raise "Max magic base of 36" unless base <= 36 
    (base**digits).times do |i| 
    str = "%#{digits}s" % i.to_s(base) 
    parts = str.scan(/./).map{ |n| n.to_i(base)+1 } 
    yield *parts 
    end 
end 

magic(3,2){ |a,b,c| p [a,b,c] } 
#=> [1, 1, 1] 
#=> [1, 1, 2] 
#=> [1, 2, 1] 
#=> [1, 2, 2] 
#=> [2, 1, 1] 
#=> [2, 1, 2] 
#=> [2, 2, 1] 
#=> [2, 2, 2] 

magic(2,16){ |a,b| p [a,b] } 
#=> [1, 1] 
#=> [1, 2] 
#=> [1, 3] 
#=> ... 
#=> [16, 15] 
#=> [16, 16] 

说明：

通过翻译原来的问题从1..10到0..9并连接数字，我们看到输出正在计数，并访问每个数字。

0000 
0001 
0002 
... 
0010 
0011 
0012 
... 
9997 
9998 
9999

这就是我上面的代码所做的。它从0计数到（基于数字的数目并且允许每数位值）的最大数量，并为每个数它：

1. 的数字转换成适当的“基础”：
   i.to_s(base)            # e.g. 9.to_s(8) => "11", 11.to_s(16) => "b"

2. String#%用途到垫字符串到正确的字符数：
   "%#{digits}s" % ...     # e.g. "%4s" % "5" => "   5"

3. 打开此单字符串转换成单个字符的字符串的数组S：
   str.scan(/./)           # e.g. " 31".scan(/./) => [" ","3","1"]
   注意，在Ruby 1.9的，这是更好地与str.chars

4. 完成转换每个单字符的字符串返回到一个号码：
   n.to_i(base)            # e.g. "b".to_i(16) => 11, " ".to_i(3) => 0

5. 增加1到每个这些数字，因为愿望是从1开始而不是0

6. 将这个新的数组数组作为参数Ø块，每块的PARAM一个数字：
   yield *parts