CODEWITHSUNDEEP
pythonpython-2.7python-2.x
Gocht
Gocht

Reputation: 10256

Integer division to next integer

As you may know, if you do:

>>> 11/2
# 5

And

>>> 11/2.0
# 5.5

I'd like to get 6 in this case. I tried with:

>>> 11//2
# 5

And

>>> 11//2.0
# 5.0

The last one gives the prev integer. I'd like to get the next integer. Even is the result is like x.1 I'd like to get (x+1).

How can I do this?

Upvotes: 3

Views: 1856

Answers (3)

ShadowRanger
ShadowRanger

Reputation: 155418

Generally more efficient than doing both modulus and division work, it's easy to convert floor division:

x // y

into ceil division (and unlike using math.ceil, it runs no risk of getting incorrect results due to floating point imprecision for large values):

(x + y - 1) // y

If x is exactly divisible by y, then adding y - 1 changes nothing; the floor division makes the end result unchanged. If it's not evenly divisible, this increases it above the next multiple, getting you ceil division with only a single division operation instead of two (division is expensive; doing it twice is doubly expensive), and no floating point precision issues.

The above doesn't work for negative y, but there is a solution that does work for it (at the expense of appearing more magical):

-(-x // y)

By flipping the sign on x first, you change the rounding behavior to work in the opposite direction after flipping the sign again at the end. So for x == 5 and y == -2, this second solution produces -2 (the ceiling of -2.5) correctly. It's typically more efficient than the original solution, but it's not as obvious how it works, so I can't strictly recommend it over the clearer solution when the divisor is known to be positive.

Upvotes: 3

user2357112
user2357112

Reputation: 280838

rounded_up = x // y + bool(x % y)

We add 1 if the division produces a nonzero remainder. This has the benefit of not introducing floating-point imprecision, so it'll be correct in extreme cases where math.ceil produces the wrong answer.

We can also perform the operation with floor division and two negations:

rounded_up = -(-x // y)

The floor of -x/y is the negative of the ceiling of x/y, so negating again produces the ceiling of x/y. Again, we avoid floating-point rounding error by performing all operations in integer arithmetic.

Upvotes: 3

letsc
letsc

Reputation: 2567

Use math.ceil

>>> import math
>>> math.ceil(11/2.0)
6.0
>>>

Upvotes: 1

Related Questions