Rename NChooseRModPrime to BinomialCoefficientModPrime, add tests

Rename for clarity, add input validation, clean up Javadoc, remove
main() and inline test helper. Add 10 JUnit 5 tests including BigInteger
reference validation and edge cases.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: williamfiset

src/main/java/com/williamfiset/algorithms/math/BUILD

@@ -63,13 +63,6 @@ java_binary(
     runtime_deps = [":math"],
 )
 
-# bazel run //src/main/java/com/williamfiset/algorithms/math:NChooseRModPrime
-java_binary(
-    name = "NChooseRModPrime",
-    main_class = "com.williamfiset.algorithms.math.NChooseRModPrime",
-    runtime_deps = [":math"],
-)
-
 # bazel run //src/main/java/com/williamfiset/algorithms/math:PrimeFactorization
 java_binary(
     name = "PrimeFactorization",

src/main/java/com/williamfiset/algorithms/math/BinomialCoefficientModPrime.java

@@ -0,0 +1,48 @@
+/**
+ * Computes the binomial coefficient C(n, r) mod p using Fermat's Little Theorem.
+ *
+ * Given a prime p, the binomial coefficient C(n, r) = n! / (r! * (n-r)!) can be computed modulo p
+ * by precomputing factorials mod p and using modular inverses for the denominator. Fermat's Little
+ * Theorem gives a^(p-1) ≡ 1 (mod p) for prime p, so the modular inverse of x is x^(p-2) mod p.
+ * Here we use the extended Euclidean algorithm via ModularInverse instead.
+ *
+ * Requires p to be prime so that modular inverses exist for all non-zero values mod p, and n < p
+ * so that factorials are non-zero mod p.
+ *
+ * Time Complexity: O(n) for factorial precomputation, O(log(p)) for each modular inverse.
+ *
+ * @author Rohit Mazumder, mazumder.rohit7@gmail.com
+ */
+package com.williamfiset.algorithms.math;
+
+public class BinomialCoefficientModPrime {
+
+  /**
+   * Computes C(n, r) mod p.
+   *
+   * @param n total items (must be >= 0 and < p).
+   * @param r items to choose (must be >= 0 and <= n).
+   * @param p a prime modulus.
+   * @return C(n, r) mod p.
+   * @throws IllegalArgumentException if parameters are out of range.
+   */
+  public static long compute(int n, int r, int p) {
+    if (n < 0 || r < 0 || r > n)
+      throw new IllegalArgumentException("Requires 0 <= r <= n, got n=" + n + ", r=" + r);
+    if (p <= 1)
+      throw new IllegalArgumentException("Modulus p must be > 1, got p=" + p);
+
+    if (r == 0 || r == n)
+      return 1;
+
+    long[] factorial = new long[n + 1];
+    factorial[0] = 1;
+    for (int i = 1; i <= n; i++)
+      factorial[i] = factorial[i - 1] * i % p;
+
+    return factorial[n]
+        % p * ModularInverse.modInv(factorial[r], p)
+        % p * ModularInverse.modInv(factorial[n - r], p)
+        % p;
+  }
+}

src/main/java/com/williamfiset/algorithms/math/NChooseRModPrime.java

@@ -69,3 +69,14 @@ java_test(
     runtime_deps = JUNIT5_RUNTIME_DEPS,
     deps = TEST_DEPS,
 )
+
+# bazel test //src/test/java/com/williamfiset/algorithms/math:BinomialCoefficientModPrimeTest
+java_test(
+    name = "BinomialCoefficientModPrimeTest",
+    srcs = ["BinomialCoefficientModPrimeTest.java"],
+    main_class = "org.junit.platform.console.ConsoleLauncher",
+    use_testrunner = False,
+    args = ["--select-class=com.williamfiset.algorithms.math.BinomialCoefficientModPrimeTest"],
+    runtime_deps = JUNIT5_RUNTIME_DEPS,
+    deps = TEST_DEPS,
+)

src/test/java/com/williamfiset/algorithms/math/BUILD

@@ -0,0 +1,88 @@
+package com.williamfiset.algorithms.math;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import java.math.BigInteger;
+import org.junit.jupiter.api.*;
+
+public class BinomialCoefficientModPrimeTest {
+
+  private static final int MOD = 1_000_000_007;
+
+  /** Computes C(n, r) mod p using BigInteger as a reference. */
+  private static long bigIntCnr(int n, int r, int p) {
+    BigInteger num = BigInteger.ONE;
+    BigInteger den = BigInteger.ONE;
+    for (int i = 0; i < r; i++) {
+      num = num.multiply(BigInteger.valueOf(n - i));
+      den = den.multiply(BigInteger.valueOf(i + 1));
+    }
+    return num.divide(den).mod(BigInteger.valueOf(p)).longValue();
+  }
+
+  @Test
+  public void rEqualsZero() {
+    assertThat(BinomialCoefficientModPrime.compute(10, 0, MOD)).isEqualTo(1);
+  }
+
+  @Test
+  public void rEqualsN() {
+    assertThat(BinomialCoefficientModPrime.compute(10, 10, MOD)).isEqualTo(1);
+  }
+
+  @Test
+  public void smallValues() {
+    assertThat(BinomialCoefficientModPrime.compute(5, 2, MOD)).isEqualTo(10);
+    assertThat(BinomialCoefficientModPrime.compute(6, 3, MOD)).isEqualTo(20);
+    assertThat(BinomialCoefficientModPrime.compute(10, 4, MOD)).isEqualTo(210);
+  }
+
+  @Test
+  public void knownLargeValue() {
+    // C(500, 250) mod 10^9+7 = 515561345
+    assertThat(BinomialCoefficientModPrime.compute(500, 250, MOD)).isEqualTo(515561345L);
+  }
+
+  @Test
+  public void symmetry() {
+    // C(n, r) == C(n, n-r)
+    assertThat(BinomialCoefficientModPrime.compute(100, 30, MOD))
+        .isEqualTo(BinomialCoefficientModPrime.compute(100, 70, MOD));
+  }
+
+  @Test
+  public void smallPrime() {
+    // C(6, 2) = 15, mod 7 = 1
+    assertThat(BinomialCoefficientModPrime.compute(6, 2, 7)).isEqualTo(1);
+  }
+
+  @Test
+  public void matchesBigInteger() {
+    int[] ns = {20, 50, 100, 200, 500};
+    for (int n : ns) {
+      for (int r = 0; r <= n; r += Math.max(1, n / 10)) {
+        long expected = bigIntCnr(n, r, MOD);
+        assertThat(BinomialCoefficientModPrime.compute(n, r, MOD)).isEqualTo(expected);
+      }
+    }
+  }
+
+  @Test
+  public void negativeNThrows() {
+    assertThrows(IllegalArgumentException.class,
+        () -> BinomialCoefficientModPrime.compute(-1, 0, MOD));
+  }
+
+  @Test
+  public void rGreaterThanNThrows() {
+    assertThrows(IllegalArgumentException.class,
+        () -> BinomialCoefficientModPrime.compute(5, 6, MOD));
+  }
+
+  @Test
+  public void invalidModulusThrows() {
+    assertThrows(IllegalArgumentException.class,
+        () -> BinomialCoefficientModPrime.compute(5, 2, 1));
+  }
+}