10

假设我有以下任何数字：

230957 或 83487 或 4785

Ruby 中有什么方法可以分别将它们返回为 300000 或 90000 或 5000？

4

8 回答 8

7 
def round_up(number)
  divisor = 10**Math.log10(number).floor
  i = number / divisor
  remainder = number % divisor
  if remainder == 0
    i * divisor
  else
    (i + 1) * divisor
  end
end

用你的例子：

irb(main):022:0> round_up(4785)
=> 5000    
irb(main):023:0> round_up(83487)
=> 90000
irb(main):024:0> round_up(230957)
=> 300000
于 2010-08-03T21:41:20.087 回答
6 
def round_to_significant_digit(i, significant_digits = 1)
  exp = Math.log10(i).floor - (significant_digits - 1)
  (i / 10.0 ** exp).round * 10 ** exp
end

 >> [230957, 83487, 4785].collect{|i|round_to_significant_digit(i)}
 => [200000, 80000, 5000]

并获得额外的信用：

 >>  [230957, 83487, 4785].collect{|i|round_to_significant_digit(i, 2)}
 => [230000, 83000, 4800]
 >>  [230957, 83487, 4785].collect{|i|round_to_significant_digit(i, 3)}
 => [231000, 83500, 4790]
于 2011-10-08T07:01:37.637 回答
3

Math.round 接受负数。如果您只寻找最接近的 10 个，则可以执行(my_num).round(-1).

唯一的缺点是无法在此处合并 ceil，因此它并不总是四舍五入 -4.round(-1)将返回 0。

于 2013-10-31T21:10:25.043 回答
2

我实际上并没有在 Ruby 中进行任何编码，但是如果你先将它推到你想要的数字，你就可以使用标准的舍入函数来做到这一点。

例子：

230957 / 100000(the resolution you want) = 2.30957

Round2.30957 = 2或 Round to Ceiling/Round 值+ 0.5以使其达到上限值而不是下限值。

2 or 3 * 100000(the resolution you want) = 200000 or 300000 respectively.

希望这可以帮助！

于 2010-08-03T21:44:03.847 回答
2

在 Rails 中，您可能还喜欢 "number_to_human" 助手，它会自动选择一个合适的维度进行舍入。

http://api.rubyonrails.org/classes/ActionView/Helpers/NumberHelper.html#method-i-number_to_human

于 2012-07-17T12:30:00.580 回答
1

它看起来有点难看，但作为第一枪（每次都四舍五入） ......

>> (("230957".split("").first.to_i + 1).to_s + \
   ("0" * ("230957".size - 1))).to_i
=> 300000

更好（轮次正确）：

>> (230957 / 10 ** Math.log10(230957).floor) * \
   10 ** Math.log10(230957).floor
=> 200000
于 2010-08-03T21:39:40.420 回答
0

一个简单的建议：

def nearest_large_number value
  str = value.to_s.gsub(/^([0-9])/) { "#{$1}." }
  multiplicator = ("1" + "0" * str.split('.')[1].length).to_i
  str.to_f.ceil * multiplicator
end

要使用它：

nearest_large_number 230957
=> 300000
于 2014-05-21T16:24:10.240 回答
0

这是我的版本：

def round(num, nearest = nil, pivot = nil)
  negative = num < 0
  num = -num if negative
  precision = Math.log10(num).to_i rescue 1
  nearest ||= precision == 0 ? 10 : 10**precision
  pivot ||= nearest
  result = (num + pivot) / nearest * nearest
  negative ? -result : result
end

这种方法很脏，看起来很丑......但是......它处理了一些其他人没有的边缘情况，例如：

  • 0
  • 低于 10 的值
  • 负数
  • 可以更改枢轴点

以下是一些使用示例：

round(0)   # 0
round(1)   # 10
round(9)   # 10
round(10)  # 20
round(-10) # -20
round(100) # 1000

round(1, 1000)        # 1000
round(499, 1000, 500) # 0
round(500, 1000, 500) # 1000
于 2015-02-19T07:04:10.790 回答