使Int四舍五入到最接近的值

Question

我有两个Int值(它们必须是Int ),当在一个等式中时，我希望它们四舍五入到最近的值；

var Example = Int()
var secondExample = Int()

Example = (secondExample / 7000)

此等式使变量示例始终四舍五入到最小值。例如，数字如下所示；

var Example = Int()
var secondExample : Int = 20000

Example = (20000 / 7000)

20000 / 7000 等于 2.857...但变量示例显示 2。

如何使示例四舍五入到最接近的数字而不将其更改为双精度

Answer 1

看看马丁的回答！他的想法很好，所以我扩展了他的负数解

func divideAndRound(n: Int, _ d: Int) -> Int {
    let sn = n < 0 ? -1 : 1
    let sd = d < 0 ? -1 : 1
    let s = sn * sd
    let n = n * sn
    let d = d * sd
    return (2 * n + d)/(2 * d) * s
}

divideAndRound(1, 2) // 1
divideAndRound(1, 3) // 0
divideAndRound(-1, 2) // -1
divideAndRound(-1, 3) // 0
divideAndRound(1, -2) // -1
divideAndRound(1, -3) // 0

唯一的麻烦是（2*n d）可能会溢出并且代码会崩溃。

更新！借助儿童数学

func divr(a: Int, _ b: Int)->Int {
    return (a % b) * 2 / b  + a / b
}

它应该适用于除0分母之外的任何Int:-）。

Answer 2

对于非负整数，以下函数在纯整数运算中给出所需结果：

func divideAndRound(numerator: Int, _ denominator: Int) -> Int {
    return (2 * numerator + denominator)/(2 * denominator)
}

示例：

print(20000.0/7000.0) // 2.85714285714286
print(divideAndRound(20000, 7000)) // 3 (rounded up)

print(10000.0/7000.0) // 1.42857142857143
print(divideAndRound(10000, 7000)) // 1 (rounded down)

这个想法是

 a   1   2 * a + b
 - + - = ---------
 b   2     2 * b

以下是任意符号整数的可能实现，它也不会溢出：

func divideAndRound(num: Int, _ den: Int) -> Int {
    return num / den + (num % den) / (den / 2 + den % 2)
}

（基于@user3441734的更新解决方案，因此我们现在的答案之间有一个参考循环：）

还有一个ldiv函数，它计算除法的商和余数，因此最后一个函数也可以实现为

func divideAndRound(num: Int, _ den: Int) -> Int {
    let div = ldiv(num, den)
    let div2 = ldiv(den, 2)
    return div.quot + div.rem / (div2.quot + div2.rem)
}

(我没有测试哪个版本更快。)