对于大的k，我们可以通过利用两个基本事实来显着减少工作：
如果p 是素数，则p 在n! 的素因式分解中的指数由(n - s_p(n)) / (p-1) 给出，其中s_p(n) 是n 在基本p 表示（所以对于p = 2，它是popcount）。因此p 在choose(n,k) 的素因数分解中的指数是(s_p(k) + s_p(n-k) - s_p(n)) / (p-1)，特别是当且仅当在基数p 中执行加法时k + (n-k) 没有进位（指数是携带次数）。
威尔逊定理：p 是素数，当且仅当(p-1)! ≡ (-1) (mod p)。
p 在n! 的因式分解中的指数通常由下式计算
long long factorial_exponent(long long n, long long p)
{
long long ex = 0;
do
{
n /= p;
ex += n;
}while(n > 0);
return ex;
}
p 对choose(n,k) 的整除性检查并不是绝对必要的，但首先进行检查是合理的，因为通常是这样，然后工作量就会减少：
long long choose_mod(long long n, long long k, long long p)
{
// We deal with the trivial cases first
if (k < 0 || n < k) return 0;
if (k == 0 || k == n) return 1;
// Now check whether choose(n,k) is divisible by p
if (factorial_exponent(n) > factorial_exponent(k) + factorial_exponent(n-k)) return 0;
// If it's not divisible, do the generic work
return choose_mod_one(n,k,p);
}
现在让我们仔细看看n!。我们将数字≤ n 分成p 的倍数，并且数字与p 互质。与
n = q*p + r, 0 ≤ r < p
p 的倍数贡献了p^q * q!。与p 互质的数字为0 ≤ j < q 贡献了(j*p + k), 1 ≤ k < p 的乘积，以及(q*p + k), 1 ≤ k ≤ r 的乘积。
对于与p 互质的数字，我们只对以p 为模的贡献感兴趣。每个完整的运行j*p + k, 1 ≤ k < p 都与(p-1)! 模p 一致，因此它们总共产生(-1)^q 模p 的贡献。最后一次（可能）不完整的运行产生r! modulo p。
所以如果我们写
n = a*p + A
k = b*p + B
n-k = c*p + C
我们得到
choose(n,k) = p^a * a!/ (p^b * b! * p^c * c!) * cop(a,A) / (cop(b,B) * cop(c,C))
其中cop(m,r) 是与p 互质的所有数字的乘积，它们是≤ m*p + r。
有两种可能，a = b + c 和 A = B + C，或者 a = b + c + 1 和 A = B + C - p。
在我们的计算中，我们已经预先排除了第二种可能性，但这不是必须的。
在第一种情况下，p 的显式权力取消了，我们只剩下
choose(n,k) = a! / (b! * c!) * cop(a,A) / (cop(b,B) * cop(c,C))
= choose(a,b) * cop(a,A) / (cop(b,B) * cop(c,C))
p 除以 choose(n,k) 的任何幂都来自choose(a,b) - 在我们的例子中，不会有，因为我们之前已经消除了这些情况 - 而且，虽然 cop(a,A) / (cop(b,B) * cop(c,C)) 不需要是整数（考虑例如choose(19,9) (mod 5))，当考虑表达式模p时，cop(m,r) 减少到(-1)^m * r!，所以，由于a = b + c，(-1) 取消，我们只剩下
choose(n,k) ≡ choose(a,b) * choose(A,B) (mod p)
在第二种情况下，我们发现
choose(n,k) = choose(a,b) * p * cop(a,A)/ (cop(b,B) * cop(c,C))
因为a = b + c + 1。最后一位的进位表示A < B，所以取模p
p * cop(a,A) / (cop(b,B) * cop(c,C)) ≡ 0 = choose(A,B)
（我们可以用模逆的乘法代替除法，或者将其视为有理数的同余，这意味着分子可以被p整除）。反正我们又找到了
choose(n,k) ≡ choose(a,b) * choose(A,B) (mod p)
现在我们可以重复 choose(a,b) 部分。
示例：
choose(144,6) (mod 5)
144 = 28 * 5 + 4
6 = 1 * 5 + 1
choose(144,6) ≡ choose(28,1) * choose(4,1) (mod 5)
≡ choose(3,1) * choose(4,1) (mod 5)
≡ 3 * 4 = 12 ≡ 2 (mod 5)
choose(12349,789) ≡ choose(2469,157) * choose(4,4)
≡ choose(493,31) * choose(4,2) * choose(4,4
≡ choose(98,6) * choose(3,1) * choose(4,2) * choose(4,4)
≡ choose(19,1) * choose(3,1) * choose(3,1) * choose(4,2) * choose(4,4)
≡ 4 * 3 * 3 * 1 * 1 = 36 ≡ 1 (mod 5)
现在实现：
// Preconditions: 0 <= k <= n; p > 1 prime
long long choose_mod_one(long long n, long long k, long long p)
{
// For small k, no recursion is necessary
if (k < p) return choose_mod_two(n,k,p);
long long q_n, r_n, q_k, r_k, choose;
q_n = n / p;
r_n = n % p;
q_k = k / p;
r_k = k % p;
choose = choose_mod_two(r_n, r_k, p);
// If the exponent of p in choose(n,k) isn't determined to be 0
// before the calculation gets serious, short-cut here:
/* if (choose == 0) return 0; */
choose *= choose_mod_one(q_n, q_k, p);
return choose % p;
}
// Preconditions: 0 <= k <= min(n,p-1); p > 1 prime
long long choose_mod_two(long long n, long long k, long long p)
{
// reduce n modulo p
n %= p;
// Trivial checks
if (n < k) return 0;
if (k == 0 || k == n) return 1;
// Now 0 < k < n, save a bit of work if k > n/2
if (k > n/2) k = n-k;
// calculate numerator and denominator modulo p
long long num = n, den = 1;
for(n = n-1; k > 1; --n, --k)
{
num = (num * n) % p;
den = (den * k) % p;
}
// Invert denominator modulo p
den = invert_mod(den,p);
return (num * den) % p;
}
要计算模逆，可以使用费马（所谓的小）定理
如果p 是质数且a 不能被p 整除，则a^(p-1) ≡ 1 (mod p)。
并将逆计算为a^(p-2) (mod p)，或使用适用于更广泛参数范围的方法、扩展欧几里得算法或连分数展开式，它为您提供任何互质（正）整数对的模逆：
long long invert_mod(long long k, long long m)
{
if (m == 0) return (k == 1 || k == -1) ? k : 0;
if (m < 0) m = -m;
k %= m;
if (k < 0) k += m;
int neg = 1;
long long p1 = 1, p2 = 0, k1 = k, m1 = m, q, r, temp;
while(k1 > 0) {
q = m1 / k1;
r = m1 % k1;
temp = q*p1 + p2;
p2 = p1;
p1 = temp;
m1 = k1;
k1 = r;
neg = !neg;
}
return neg ? m - p2 : p2;
}
就像计算 a^(p-2) (mod p) 一样，这是一个 O(log p) 算法，对于某些输入，它明显更快（实际上是 O(min(log k, log p))，所以对于小的 k 和大的 p，它要快得多），对于其他输入它是慢一点。
总的来说，这种方式我们最多需要计算 O(log_p k) 个二项式系数以 p 为模，其中每个二项式系数最多需要 O(p) 次运算，总复杂度为 O(p*log_p k)操作。
当k 明显大于p 时，这比O(k) 解决方案要好得多。对于k <= p，它减少为O(k) 解决方案，但有一些开销。