c * i / (i – k)

can yield fractions however c is not random. It’s a product of consecutive numbers divided by another product of just as many, smaller consecutive numbers and i and (i – k) are the next numbers in those repective sequences. This is always an integer, in fact it is comb(i, i – k) (I got that wrong in the earlier post, when I said comb(n, i))

Also, I think when you say

There’s no reason k should be a whole divisor of c * i

you are assuming that c*i/(i-k) is whole if and only if k divides i. This is not the case e.g. c=5, i=6, k=2: 5 * 6 / (6 – 2) = 30/4 does not divide even though k does divide i. Also c=5, i=6, k=4: 30/2 = 15 despite the fact that k does not divide i. That kind of thing hold on the numerator e.g. (9 + x)/3 is only whole when 3 divides x.

The comment box ate my attempt to do a bit of maths and post my code, so I posted it over here.

c * i / (i – k)

can clearly result in fractions! There’s no reason k should be a whole divisor of c * i :-) You’re right about the last snippet! stupid typo.

c *= float(i) / (i – k)

to

c *= i
c /= i – k

and you’re done. You won’t get fractions because

comb(n, k) = comb(n, k – 1) * (n – k + 1) / k

(just write it out as factorials and cancel things)

so c in your loop takes the values

comb(n, 0)
comb(n, 1)
comb(n, 2)
…
comb(n, k)

which are, of course, all integers.

By the way, I think the last code snippet in the main post should be range(k + 1, n + 1).

k = max(k, n – k)

at the beginning to knock 50% off the expected number of loop iterations (assuming you’re calling it multiple times and all values of k are equally likely).

Without it, running this on k=0, …, n would loop 0 + 1 + 2 + … + n = n*(n+1)/2 times.

With it, that’s 2*(0 + 1 + 2 + … + n/2-1 + n/2) = (n/2) * (n/2+1) which is pretty much half of n*(n+1)/2 .

(I guess you know that you basically get this by estimating log(n!) with an integral.)

comb :: Rational -> Rational -> Rational
comb n k = prod $ map f [k+1..n]
where f i = i / (i – k)

but doing two loops and dividing the result has the advantage of allowing
you to do integer arithmetic only (at the expense of dealing with larger
numbers).

comb :: Integer -> Integer -> Integer
comb n k = x `div` y
where x = prod [k+1..n]
y = prod $ map (\i -> (i-k)) [k+1..n]

For my quick and unscientific test this is 30% faster doing comb 100000 50000.

It’s a good point that applying a little bit of brain to make calculations easier for a computer is often time well spent.

Mostly just wanted a correct illustrative snippet people could try on their own machine quickly.