Round with integer division

Question

Есть ли простой, питонический способ округления до ближайшего целого числа без использования плавающей запятой? Я хотел бы сделать следующее, но с целочисленной арифметики:

skip = int(round(1.0 * total/surplus)) 

==============

@John: Плавающая точка не воспроизводимы на разных платформах. Если вы хотите, чтобы ваш код проходил тесты на разных платформах, вам нужно избегать с плавающей запятой (или добавить некоторые хакеры для espilon в свои тесты и надеяться, что это сработает). Вышеприведенное может быть достаточно простым, чтобы оно было одинаковым на большинстве/на всех платформах, но я бы предпочел не делать это определение, так как легче избежать плавающей точки в целом. Как это «не в духе Питона»?

Answer 1

Вы можете сделать это довольно просто:

(n + d // 2) // d, где n является делимым и d является делителем.

Альтернатива как (((n << 1) // d) + 1) >> 1 или эквивалент (((n * 2) // d) + 1) // 2 может замедлиться в последнем CPythons, где int реализуется как старый long.

Простой способ имеет 3 переменных доступа, 1 постоянную нагрузку и 3 целых операции. Сложные методы выполняют 2 переменных доступа, 3 постоянные нагрузки и 4 целых операции. Целые операции, вероятно, потребуют времени, которое зависит от размеров задействованных чисел. Переменные обращения к локальным функциям не связаны с поиском.

Если вы действительно desparate для скорости, делайте тесты. В противном случае, KISS.

Answer 2

skip = (((total << 1) // surplus) + 1) >> 1 

Подвижные вещи, оставленные на один бит эффективно умножает на два, перекладывая вещи вправо на один бит делит на два округление вниз. Добавление одного из них делает так, что «округление» фактически округляется, если результат был бы выше десятичной части .5.

Это в основном так же, как если бы вы написали ...

skip = int((1.0*total/surplus) + 0.5) 

кроме всего multplied на 2, а затем разделенном на 2, который является то, что вы можете сделать с целочисленной арифметикой (поскольку бит сдвигает дон 't требуется плавающая точка).

Answer 3

Это должно работать также:

def rint(n): 
    return (int(n+.5) if n > 0 else int(n-.5)) 

Answer 4

Просто заботиться о округление правила, прежде чем вы когда-нибудь разделить. Для простейшего круглого половинной до:

if total % surplus < surplus/2: 
    return total/surplus 
else: 
    return (total/surplus) + 1 

Tweak немного, если вам нужно сделать правильный круглый к четно.

Answer 5

Еще один забавный способ:

q, r = divmod(total, surplus) 
skip = q + int(bool(r)) 

Answer 6

Вдохновленный zhmyh's answer ответ, который

q, r = divmod(total, surplus) 
skip = q + int(bool(r)) # rounds to next greater integer (always ceiling) 

, я придумал следующее решение:

q, r = divmod(total, surplus) 
skip = q + int(2 * r >= surplus) # rounds to nearest integer (floor or ceiling) 

Поскольку ОП спросил для округления до ближайший всего числа, zh Решение mhs на самом деле немного некорректно, потому что оно всегда округляется до следующего большего размера, в то время как мое решение работает так же востребовано.

(Если вы чувствуете, что мой ответ должен лучше бы был изменить или комментарий на ответ zhmh, позвольте мне отметить, что мое Рекомендованное редактировать для этого было отклонено, так как он должен лучше бы комментарий, но я не имеют достаточно репутацию еще для комментирования)

в случае вам интересно, как divmod определяется: по его documentation

для целых чисел, результат такой же, как (a // b, a % b).

Поэтому мы придерживаемся целочисленной арифметики, как того требует ОП.