Ruby 中的数字运算（需要优化）

Ruby 可能不是最适合这种情况的语言，但我很乐意在我的终端中使用它，所以这就是我要使用的。

我需要处理从 1 到 666666 的数字，因此我找出包含 6 但不包含 7、8 或 9 的所有数字。第一个数字是6， 下一个16, then 26等等。 然后我需要像这样打印(6=6) (16=6) (26=6)当我有这样的范围时60 to 66我需要像这样打印(60 THRU 66=6)（SPSS 语法）。

我有这段代码并且它可以工作，但它既不美观也不高效，那么我该如何优化它呢？

（可能会出现愚蠢的代码）

class Array
  def to_ranges
    array = self.compact.uniq.sort
    ranges = []
    if !array.empty?
      # Initialize the left and right endpoints of the range
      left, right = array.first, nil
      array.each do |obj|
        # If the right endpoint is set and obj is not equal to right's successor 
        # then we need to create a range.
        if right && obj != right.succ
          ranges << Range.new(left,right)
          left = obj
        end
        right = obj
      end
      ranges << Range.new(left,right) unless left == right
    end
    ranges
  end
end

write = ""
numbers = (1..666666).to_a

# split each number in an array containing it's ciphers
numbers = numbers.map { |i| i.to_s.split(//) }

# delete the arrays that doesn't contain 6 and the ones that contains 6 but also 8, 7 and 9
numbers = numbers.delete_if { |i| !i.include?('6') }
numbers = numbers.delete_if { |i| i.include?('7') }
numbers = numbers.delete_if { |i| i.include?('8') }
numbers = numbers.delete_if { |i| i.include?('9') }

# join the ciphers back into the original numbers
numbers = numbers.map { |i| i.join }

numbers = numbers.map { |i| i = Integer(i) }

# rangify consecutive numbers
numbers = numbers.to_ranges

# edit the ranges that go from 1..1 into just 1
numbers = numbers.map do |i|
  if i.first == i.last
    i = i.first
  else
    i = i
  end
end

# string stuff
numbers = numbers.map { |i| i.to_s.gsub(".."," thru ") }

numbers = numbers.map { |i| "(" + i.to_s + "=6)"}

numbers.each { |i| write << " " + i }

File.open('numbers.txt','w') { |f| f.write(write) }

正如我所说，它适用于甚至数百万的数字 - 但我想要一些关于如何变得更漂亮和更高效的建议。

我删除了之前的尝试parlez-vous-ruby？并弥补了这一点。我知道有一个优化版本x3ro的优秀例子.

$,="\n"
puts ["(0=6)", "(6=6)", *(1.."66666".to_i(7)).collect {|i| i.to_s 7}.collect do |s|
    s.include?('6')? "(#{s}0 THRU #{s}6=6)" : "(#{s}6=6)"
end ]

与x3ro版本相比

...减少到三行

... 速度提高 204.2 倍（达到 66666666）

...具有字节相同的输出

它使用了我所有的优化想法

• 基于模 7 数字的 gen 数字（因此基数为 7 的数字）
• 生成最后一个数字“智能”：这就是压缩范围的原因

那么...时间安排是怎样的？这是使用 8 位数字进行测试（达到 66666666 或 823544 行输出）：

$ time ./x3ro.rb >  /dev/null

real    8m37.749s
user    8m36.700s
sys 0m0.976s

$ time ./my.rb >  /dev/null

real    0m2.535s
user    0m2.460s
sys 0m0.072s

虽然演技确实不错，但是甚至不接近C优化版本 https://stackoverflow.com/questions/5680725/number-crunching-in-ruby-optimisation-needed/5682791#5682791我之前发布过：我无法将 my.rb 运行到 6666666666 (6x10) 因为内存不足。当运行到9位数时，这是比较结果：

sehe@meerkat:/tmp$ time ./my.rb >  /dev/null

real    0m21.764s
user    0m21.289s
sys 0m0.476s

sehe@meerkat:/tmp$ time ./t2 > /dev/null

real    0m1.424s
user    0m1.408s
sys 0m0.012s

C 版本仍然快了 15 倍……考虑到它在裸机上运行，​​这是公平的。

希望你喜欢它，如果只是为了学习 Ruby，我可以请你投票吗:)

(你能说我很自豪吗？这是我第一次接触Ruby；我两小时前开始了红宝石公案......)

编辑@johndouthat:

很不错！ Base7 的使用非常巧妙，这对于您的第一次 Ruby 试用来说是一个很棒的工作:)

以下是对代码片段的轻微修改，可以让您测试 10 多个数字而不会出现 OutOfMemory 错误：

puts ["(0=6)", "(6=6)"]
(1.."66666666".to_i(7)).each do |i| 
  s = i.to_s(7)
  puts s.include?('6') ? "(#{s}0 THRU #{s}6=6)" : "(#{s}6=6)"
end

# before:
real    0m26.714s
user    0m23.368s
sys 0m2.865s
# after
real    0m15.894s
user    0m13.258s
sys 0m1.724s