在 Ruby 中迭代无限序列

我正在尝试解决欧拉项目问题 #12：

三角形数字序列是通过添加自然数生成的数字。所以第 7 个三角形数将是 1 + 2 + 3 + 4 + 5 + 6 + 7 = 28. 前十个术语是：
1, 3, 6, 10, 15, 21, 28, 36, 45, 55, ...
让我们列出前七个三角形数字的因子：
 1: 1
 3: 1,3
 6: 1,2,3,6
10: 1,2,5,10
15: 1,3,5,15
21: 1,3,7,21
28: 1,2,4,7,14,28
我们可以看到 28 是第一个超过 5 的三角形数因子。第一个三角形数超过五的值是多少一百个除数？

这是我使用 Ruby 提出的解决方案：

triangle_number = 1
(2..9_999_999_999_999_999).each do |i|
  triangle_number += i
  num_divisors = 2 # 1 and the number divide the number always so we don't iterate over the entire sequence
  (2..( i/2 + 1 )).each do |j|
    num_divisors += 1 if i % j == 0
  end
  if num_divisors == 500 then
    puts i
    break
  end
end

我不应该使用像 9_999_999_999_999_999_999 这样的任意大数字。如果我们有一个像一些函数式语言一样的Math.INFINITY序列会更好。如何在 Ruby 中生成惰性无限序列？

几个答案很接近，但我实际上没有看到有人使用无限范围。Ruby很好地支持他们。

Inf = Float::INFINITY # Ruby 1.9
Inf = 1.0/0 # Ruby before 1.9
(1..Inf).include?(2305843009213693951)
# => true
(1..Inf).step(7).take(3).inject(&:+)
# => 24.0

在您的情况下

(2..Inf).find {|i| ((2..( i/2 + 1 )).select{|j| i % j == 0}.count+2)==42 }
=> 2880

您的蛮力方法很粗糙，可能需要很长时间才能完成。

在 Ruby>= 1.9 中，您可以创建一个 Enumerator 对象，该对象生成您喜欢的任何序列。下面是一个产生无限整数序列的方法：

#!/usr/bin/ruby1.9
sequence = Enumerator.new do |yielder|
  number = 0
  loop do
    number += 1
    yielder.yield number
  end
end
5.times do
  puts sequence.next
end
# => 1
# => 2
# => 3
# => 4
# => 5

或：

sequence.each do |i|
  puts i
  break if i >= 5
end

或：

sequence.take(5).each { |i| puts i }

Programming Ruby 1.9(又名"The Pickaxe Book"(，第3版，第83页，有一个三角形数字枚举器的例子。修改上面的枚举器以生成三角形数字应该很容易。我会在这里这样做，但这会逐字重现示例，可能超过"合理使用"所允许的。

Infinity 在 Float 上定义 (Ruby 1.9(

a = Float::INFINITY
puts a #=> Infinity
b = -a
puts a*b #=> -Infinity, just toying
1.upto(a) {|x| break if x >10; puts x}

Ruby 的当前版本非常支持生成器：

sequence = 1.step

在 Ruby 2.6 中，这变得容易得多：

(1..).each {|n| ... }

来源： https://bugs.ruby-lang.org/issues/12912

这最好作为一个简单的循环。

triangle_number = 1
i  = 1
while num_divisors < 500
  i += 1
  triangle_number += i
  # ...
end
puts i

正如 Amadan 提到的，您可以使用闭包：

triangle = lambda { t = 0; n = 1; lambda{ t += n; n += 1; t } }[]
10.times { puts triangle[] }

不要真的认为它比循环慢得多。您也可以在类对象中保存状态，但需要更多键入：

class Tri
  def initialize
    @t = 0
    @n = 1
  end
  def next
    @t += n
    @n += 1
    @t
  end
end
t = Tri.new
10.times{ puts t.next }

添加：

对于那些喜欢 longjmps 的人：

require "generator"
tri =
  Generator.new do |g|
    t, n = 0, 1
    loop do
      t += n
      n += 1
      g.yield t
    end
  end
puts (0..19).map{ tri.next }.inspect

基于Wayne的出色回答，并本着Ruby精神，用最少的字符做事，这里有一个稍微更新的版本：

sequence = Enumerator.new { |yielder| 1.step { |num| yielder.yield num } }

显然，它不能解决原始的欧拉问题，但有利于生成无限的整数序列。绝对适用于Ruby> 2.0。享受！

在 2018 年圣诞节，Ruby 引入了无限范围，为这个问题提供了一种简单的新方法。

这是通过省略范围中的最后一个字符来实现的，例如：

(1..)
(1...)
(10..)
(Time.now..)

或者使用 Jonas Elfström 的解决方案进行更新：

(2..).find { |i| ((2..( i / 2 + 1 )).select { |j| i % j == 0 }.count + 2) == 42 }

希望这对某人有用！

我相信

纤维(我相信在 Ruby 1.9 中添加(可能接近你想要的。请参阅此处以获取一些信息或仅搜索 Ruby 纤维

相关内容

最新更新

热门标签：