Question

我想取一个整数并将其四舍五入为5的下一个倍数。

input:    output:
0    ->   0
2    ->   5
3    ->   5
12   ->   15
21   ->   25
30   ->   30
-2   ->   0
-5   ->   -5
etc.

我下面的函数说明可被10整除的数字，但是我不知道如何针对可被5整除的数字进行处理。这是我到目前为止所拥有的；

    def round_to_next_5(n)
      if n % 5 == 0
        return n
      else 
        return n.round(-1)
      end
    end

Answer 1

一个人可以写(16/5.0).ceil*5 #=> 20，但是对于大整数，四舍五入是一个问题：

(1000000000000001/5.0).ceil*5
  #=> 1000000000000005   # correct
(10000000000000001/5.0).ceil*5
  #=> 10000000000000000  # incorrect

因此，我宁愿使用整数运算。

def round_up(n, increment)
  increament*((n+increment-1)/5)
end

(-10..15).each { |n| puts "%s=>%s" % [n, round_up(n,5)] }

-10=>-10
 -9=> -5  -8=>-5  -7=>-5  -6=>-5  -5=>-5
 -4=>  0  -3=> 0  -2=> 0  -1=> 0   0=> 0
  1=>  5   2=> 5   3=> 5   4=> 5   5=> 5
  6=> 10   7=>10   8=>10   9=>10  10=>10
 11=> 15  12=>15  13=>15  14=>15  15=>15

Answer 2

这是我能想到的最简单的解决方案（非常类似于您的实现）

def up_to_nearest_5(n)
  return n if n % 5 == 0
  rounded = n.round(-1)
  rounded > n ? rounded : rounded + 5
end

当Integer#round被赋予负数时，它将舍入第n个（在这种情况下为1）最低有效位，就好像它是十进制值一样。例如

1254.round(-1) 
#=> 1250
1254.round(-2)
#=> 1300

因此，我们只看数字是否为5的因子，否则返回该数字；如果将其四舍五入则返回四舍五入的数字；如果将其四舍五入则返回四舍五入的数字。

不过，您也可以使用BigDecimal标准库进行精确数学运算，这样该方法看起来就像

require 'bigdecimal'
def up_to_nearest_5(n)
  BigDecimal(n)./(5).ceil * 5
end

Answer 3

使用以下表达式构建您的方法：(44 / 5.0).round(0) * 5.0。它为我返回45.0。

Answer 4

这是我解决此问题的代码：

def to_nearest_5(int)
    until -int%5 == 0
        int += 1
    end
    return int
end

对于整数数组：

def to_nearest_5(arr)
    arr.each do |int|
        until -int%5 == 0
            int += 1
        end
        return int
    end
end

Answer 5

已经发布了一些正确的解决方案，但这是我的没有乘法/除法的 - 只有一个模（理论上应该运行得更快，但这不是我的目标）：

def round_up_to_multiple_of(n, m)
  (n - 1) + m - (n - 1) % m
end

p [0, 2, 3, 12, 21, 30, -2, -5].map { |n| [n, round_up_to_multiple_of(n, 5)] }
#=> [[0, 0], [2, 5], [3, 5], [12, 15], [21, 25], [30, 30], [-2, 0], [-5, -5]]

以下是四舍五入到最接近的倍数的方法（这是我试图做的并发现了这个问题）：

def round_down_to_multiple_of(n, m)
  (n + 1) - (n + 1) % m
end

p [0, 2, 3, 12, 21, 30, -2, -5].map { |n| [n, round_down_to_multiple_of(n, 5)] }
#=> [[0, 0], [2, 0], [3, 0], [12, 10], [21, 20], [30, 30], [-2, -5], [-5, -5]]

红宝石舍入整数至最接近的5的倍数

5 个答案: