2

我想到了几种不同的方法来生成以下数组：[1, 10, 100, 1_000, 10_000, 100_000, 1_000_000]

似乎可以以step一种优雅的方式使用该函数生成这个数组，但我无法弄清楚。将第二个参数传递给step函数并表示您想要最后一个值乘以 10 的东西：

0.step(1_000_000, ???).to_a

以下是我到目前为止提出的解决方案：

我不太喜欢这个inject解决方案，因为我更愿意指定1_000_000为上限：

(0..6).inject([]) { |memo, number| memo << 10**number; memo }

这是step我想出的丑陋解决方案：

result = []
0.step(6) {|number| result << 10 ** number}
result

while循环也感觉不对，但至少它让我指定了上界（而不是 Math.log10(upper_bound)）：

result = [1]
while result.last < 1_000_000
  result << result.last * 10
end
result

谢谢您的帮助。

4

3 回答 3

7

你有很多解决方案。map用这种方式怎么样。

7.times.map { |i| 10**i }
#=> [1, 10, 100, 1000, 10000, 100000, 1000000]

如果你想设置上限，你总是可以这样

1_000_000.to_s.size.times.map { |i| 10**i }
#=> [1, 10, 100, 1000, 10000, 100000, 1000000]
于 2013-07-24T00:40:23.777 回答
3

这个怎么样？

0.upto(Math.log10(1_000_000)).map { |i| 10**i }

它仅适用于 10 的幂，但它允许您指定上限，然后计算 10 的幂以进行迭代。

如果您想以上限领先，您可以通过以下方式轻松完成：

Math.log10(10_000_000).to_i.downto(0).map {|i| 10 ** i }.reverse

如果简洁真的很重要，您可以随时使用通用解决方案重新打开 Fixnum：

class Fixnum
  def by_powers_of(base = 10)
    0.upto(Math.log(self, base)).map {|i| base ** i }
  end
end

10_000_000.by_powers_of(10)
# => [1, 10, 100, 1000, 10000, 100000, 1000000, 10000000]

(64**2).by_powers_of(2)
# => [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096]
于 2013-07-24T00:54:28.640 回答
0 
class Integer

  def powers_upto(max)
    results = []
    exp = 0

    loop do
      result = self**exp
      break if result > max
      results << result
      exp += 1
    end

    results
  end

end



p 10.powers_upto(1_000_000)
p 2.powers_upto(11)

--output:--
[1, 10, 100, 1000, 10000, 100000, 1000000]
[1, 2, 4, 8]
于 2013-07-24T03:44:48.900 回答