⚡️ Speed up function binomial_coefficient by 14,816%

[codeflash-ai]

📄 14,816% (148.16x) speedup for binomial_coefficient in src/math/combinatorics.py

⏱️ Runtime : 61.2 milliseconds → 410 microseconds (best of 250 runs)

📝 Explanation and details

The optimized code achieves a 14,815% speedup (from 61.2ms to 410μs) by adding memoization via @cache decorator to eliminate redundant recursive calculations.

What Changed

Added from functools import cache and decorated the function with @cache to memoize results of previous computations.

Why This Improves Runtime

The original recursive implementation exhibits exponential time complexity O(2^n) due to overlapping subproblems. For example, when computing binomial_coefficient(10, 5), the same values like binomial_coefficient(7, 3) are calculated multiple times through different recursive paths. The line profiler shows 1,175,075 total function calls for a single test execution.

With @cache, each unique (n, k) pair is computed only once and cached. Subsequent calls with the same arguments return the cached result in O(1) time, reducing overall complexity to O(n*k) - the number of unique subproblems.

Performance Impact Analysis

The annotated tests reveal dramatic improvements for non-trivial cases:

• test_repeated_small_computation_many_times_loop_1000: Computing binomial_coefficient(10, 5) 1,000 times improved from 27.8ms to 87.1μs (31,797% faster) - the cache makes subsequent identical calls essentially free
• test_binomial_coefficient_row_15_middle: Computing binomial_coefficient(15, 7) improved from 693μs to 12.4μs (5,486% faster) for the first call, then to 125ns for the cached second call
• test_bulk_varied_pairs_up_to_1000_items: Processing 1,000 different pairs improved from 29.4ms to 111μs (26,269% faster) due to cache hits from overlapping subproblems

Base cases (k=0 or k=n) show 20-50% slower performance due to cache overhead, but this is negligible compared to the massive gains in recursive cases.

Real-World Benefit

The function appears to be a standalone combinatorics utility. While we don't have explicit call-site references showing it in hot paths, the test patterns (repeated computations, loops of 1000 iterations, bulk processing) strongly suggest usage patterns where:

1. Repeated identical calls (same n,k values) occur frequently
2. Related computations (Pascal's triangle rows, symmetric pairs) benefit from shared subproblem caching
3. Interactive/iterative workloads that compute multiple binomial coefficients would see compounding benefits

This optimization is particularly valuable when the function is called multiple times in data analysis, probability calculations, or combinatorial algorithms where the same coefficients are needed repeatedly or where computing one coefficient creates cached values useful for subsequent computations.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 2462 Passed
⏪ Replay Tests	🔘 None Found
🔎 Concolic Coverage Tests	🔘 None Found
📊 Tests Coverage	100.0%

🌀 Click to see Generated Regression Tests

import math  # used to compare results against the standard library's combinatorics routine
from typing import (  # used for type annotations in comments and helper variables
    List,
    Tuple,
)

# imports
import pytest  # used for our unit tests
from src.math.combinatorics import binomial_coefficient


def test_base_cases_return_one():
    # Base case: k == 0 should always return 1 for any integer n
    codeflash_output = binomial_coefficient(0, 0)  # 209ns -> 333ns (37.2% slower)
    codeflash_output = binomial_coefficient(5, 0)  # 125ns -> 167ns (25.1% slower)
    codeflash_output = binomial_coefficient(100, 0)  # 84ns -> 83ns (1.20% faster)

    # Base case: k == n should always return 1
    codeflash_output = binomial_coefficient(0, 0)  # 83ns -> 125ns (33.6% slower)
    codeflash_output = binomial_coefficient(7, 7)  # 167ns -> 209ns (20.1% slower)
    codeflash_output = binomial_coefficient(20, 20)  # 83ns -> 166ns (50.0% slower)


def test_matches_math_comb_for_small_n():
    # For small values of n the function should match math.comb exactly.
    # This also implicitly verifies correctness of the recursion for many paths.
    for n in range(0, 11):  # n from 0 through 10 (inclusive)
        for k in range(0, n + 1):  # all valid k for a given n
            expected = math.comb(n, k)  # trusted standard library output
            codeflash_output = binomial_coefficient(n, k)
            actual = codeflash_output


def test_symmetry_property():
    # Binomial coefficients are symmetric: C(n, k) == C(n, n - k)
    # Test several values to ensure function respects symmetry
    test_cases: List[Tuple[int, int]] = [
        (5, 1),
        (5, 2),
        (10, 3),
        (10, 7),
        (12, 6),
    ]
    for n, k in test_cases:
        codeflash_output = binomial_coefficient(n, k)
        left = codeflash_output  # 128μs -> 6.92μs (1764% faster)
        codeflash_output = binomial_coefficient(n, n - k)
        right = codeflash_output  # 128μs -> 4.46μs (2788% faster)


def test_small_values_against_pascal_identity():
    # Verify Pascal's identity: C(n, k) == C(n-1, k-1) + C(n-1, k)
    # for a range of small n,k where both sides are defined.
    for n in range(1, 9):  # keep n small to avoid heavy recursion
        for k in range(1, n):  # interior values where k not 0 or n
            codeflash_output = binomial_coefficient(n, k)
            left = codeflash_output
            right = binomial_coefficient(n - 1, k - 1) + binomial_coefficient(n - 1, k)


def test_boolean_is_accepted_as_integer_subclass():
    # bool is a subclass of int in Python; True == 1 and False == 0.
    # The function should accept these and behave consistently with integer semantics.
    codeflash_output = binomial_coefficient(5, True)  # 1.12μs -> 1.75μs (35.7% slower)
    codeflash_output = binomial_coefficient(5, False)  # 167ns -> 208ns (19.7% slower)
    # As a sanity check, the numeric values should match math.comb where appropriate
    codeflash_output = binomial_coefficient(5, True)  # 625ns -> 125ns (400% faster)
    codeflash_output = binomial_coefficient(5, False)  # 125ns -> 83ns (50.6% faster)


def test_negative_n_with_k_zero_returns_one():
    # The implementation checks k == 0 before any other termination condition.
    # For negative n but k == 0, the function returns 1 (by the source code logic).
    codeflash_output = binomial_coefficient(-5, 0)  # 208ns -> 333ns (37.5% slower)
    codeflash_output = binomial_coefficient(-1, 0)  # 84ns -> 208ns (59.6% slower)


def test_zero_values_and_small_boundaries():
    # Check a few more boundary-related simple values for deterministic behavior.
    codeflash_output = binomial_coefficient(1, 0)  # 250ns -> 333ns (24.9% slower)
    codeflash_output = binomial_coefficient(1, 1)  # 167ns -> 209ns (20.1% slower)
    codeflash_output = binomial_coefficient(2, 1)  # 459ns -> 458ns (0.218% faster)


def test_repeated_small_computation_many_times_loop_1000():
    # Run the same moderately small binomial computation 1000 times to emulate
    # repeated workload and verify deterministic results and reasonable performance.
    n, k = 10, 5  # n small enough to compute quickly but nontrivial recursion
    expected = math.comb(n, k)
    for _ in range(1000):  # loop up to 1000 iterations as requested
        codeflash_output = binomial_coefficient(n, k)
        result = codeflash_output  # 27.8ms -> 87.1μs (31797% faster)


def test_bulk_varied_pairs_up_to_1000_items():
    # Create up to 1000 (n, k) pairs with small n (so each computation is fast)
    # and verify that the function matches math.comb for each pair.
    pairs: List[Tuple[int, int]] = []
    # Build a repeating sequence of valid (n,k) pairs for n up to 15.
    for i in range(1000):  # produce exactly 1000 items
        n = i % 16  # n cycles through 0..15
        k = (
            (i // 16) % (n + 1) if n >= 0 else 0
        )  # pick a valid k for that n deterministically
        # If computing k this way ever yields k > n due to integer division, clamp it.
        if k > n:
            k = n
        pairs.append((n, k))

    # Now verify all generated pairs against math.comb
    for n, k in pairs:
        codeflash_output = binomial_coefficient(n, k)  # 29.4ms -> 111μs (26269% faster)


def test_return_type_for_various_small_inputs():
    # Ensure returned type is int for multiple small inputs
    for n in range(0, 12):
        for k in range(0, n + 1):
            codeflash_output = binomial_coefficient(n, k)
            value = codeflash_output


# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import pytest
from src.math.combinatorics import binomial_coefficient


def test_binomial_coefficient_base_case_k_zero():
    # Test that C(n, 0) = 1 for any n >= 0
    codeflash_output = binomial_coefficient(0, 0)  # 209ns -> 375ns (44.3% slower)
    codeflash_output = binomial_coefficient(5, 0)  # 84ns -> 125ns (32.8% slower)
    codeflash_output = binomial_coefficient(10, 0)  # 83ns -> 83ns (0.000% faster)


def test_binomial_coefficient_base_case_k_equals_n():
    # Test that C(n, n) = 1 for any n >= 0
    codeflash_output = binomial_coefficient(0, 0)  # 208ns -> 292ns (28.8% slower)
    codeflash_output = binomial_coefficient(1, 1)  # 167ns -> 208ns (19.7% slower)
    codeflash_output = binomial_coefficient(5, 5)  # 125ns -> 125ns (0.000% faster)
    codeflash_output = binomial_coefficient(10, 10)  # 84ns -> 125ns (32.8% slower)


def test_binomial_coefficient_small_values():
    # Test simple binomial coefficients with small values
    # C(1, 0) = 1, C(1, 1) = 1
    codeflash_output = binomial_coefficient(1, 0)  # 250ns -> 375ns (33.3% slower)
    codeflash_output = binomial_coefficient(1, 1)  # 167ns -> 209ns (20.1% slower)

    # C(2, 0) = 1, C(2, 1) = 2, C(2, 2) = 1
    codeflash_output = binomial_coefficient(2, 0)  # 125ns -> 125ns (0.000% faster)
    codeflash_output = binomial_coefficient(2, 1)  # 458ns -> 500ns (8.40% slower)
    codeflash_output = binomial_coefficient(2, 2)  # 125ns -> 166ns (24.7% slower)


def test_binomial_coefficient_medium_values():
    # Test binomial coefficients with medium values
    # C(3, 1) = 3, C(3, 2) = 3
    codeflash_output = binomial_coefficient(3, 1)  # 709ns -> 1.17μs (39.2% slower)
    codeflash_output = binomial_coefficient(3, 2)  # 458ns -> 542ns (15.5% slower)

    # C(4, 2) = 6
    codeflash_output = binomial_coefficient(4, 2)  # 709ns -> 375ns (89.1% faster)

    # C(5, 2) = 10
    codeflash_output = binomial_coefficient(5, 2)  # 1.25μs -> 792ns (57.8% faster)

    # C(5, 3) = 10
    codeflash_output = binomial_coefficient(5, 3)  # 1.12μs -> 584ns (92.6% faster)


def test_binomial_coefficient_pascal_triangle_row_3():
    # Test entire row 3 of Pascal's triangle: [1, 3, 3, 1]
    codeflash_output = binomial_coefficient(3, 0)  # 209ns -> 375ns (44.3% slower)
    codeflash_output = binomial_coefficient(3, 1)  # 625ns -> 1.00μs (37.5% slower)
    codeflash_output = binomial_coefficient(3, 2)  # 375ns -> 458ns (18.1% slower)
    codeflash_output = binomial_coefficient(3, 3)  # 125ns -> 125ns (0.000% faster)


def test_binomial_coefficient_pascal_triangle_row_4():
    # Test entire row 4 of Pascal's triangle: [1, 4, 6, 4, 1]
    codeflash_output = binomial_coefficient(4, 0)  # 208ns -> 334ns (37.7% slower)
    codeflash_output = binomial_coefficient(4, 1)  # 750ns -> 1.17μs (35.7% slower)
    codeflash_output = binomial_coefficient(4, 2)  # 875ns -> 833ns (5.04% faster)
    codeflash_output = binomial_coefficient(4, 3)  # 500ns -> 292ns (71.2% faster)
    codeflash_output = binomial_coefficient(4, 4)  # 166ns -> 166ns (0.000% faster)


def test_binomial_coefficient_pascal_triangle_row_5():
    # Test entire row 5 of Pascal's triangle: [1, 5, 10, 10, 5, 1]
    codeflash_output = binomial_coefficient(5, 0)  # 208ns -> 333ns (37.5% slower)
    codeflash_output = binomial_coefficient(5, 1)  # 834ns -> 1.46μs (42.8% slower)
    codeflash_output = binomial_coefficient(5, 2)  # 1.38μs -> 1.12μs (22.2% faster)
    codeflash_output = binomial_coefficient(5, 3)  # 1.21μs -> 542ns (123% faster)
    codeflash_output = binomial_coefficient(5, 4)  # 583ns -> 333ns (75.1% faster)
    codeflash_output = binomial_coefficient(5, 5)  # 166ns -> 167ns (0.599% slower)


def test_binomial_coefficient_symmetry_property():
    # Test the symmetry property: C(n, k) = C(n, n-k)
    codeflash_output = binomial_coefficient(6, 2)  # 2.17μs -> 2.71μs (20.0% slower)
    codeflash_output = binomial_coefficient(7, 2)  # 2.46μs -> 625ns (293% faster)
    codeflash_output = binomial_coefficient(8, 3)  # 6.38μs -> 1.33μs (378% faster)


def test_binomial_coefficient_zero_zero():
    # Test the edge case C(0, 0) = 1
    codeflash_output = binomial_coefficient(0, 0)  # 209ns -> 333ns (37.2% slower)


def test_binomial_coefficient_n_one():
    # Test all cases where n = 1
    codeflash_output = binomial_coefficient(1, 0)  # 208ns -> 375ns (44.5% slower)
    codeflash_output = binomial_coefficient(1, 1)  # 167ns -> 250ns (33.2% slower)


def test_binomial_coefficient_larger_n_small_k():
    # Test with larger n but small k values
    # C(10, 1) = 10
    codeflash_output = binomial_coefficient(10, 1)  # 1.38μs -> 2.67μs (48.4% slower)

    # C(10, 2) = 45
    codeflash_output = binomial_coefficient(10, 2)  # 4.92μs -> 2.04μs (141% faster)


def test_binomial_coefficient_result_types():
    # Verify that the function returns an integer type
    codeflash_output = binomial_coefficient(5, 2)
    result = codeflash_output  # 1.58μs -> 2.21μs (28.3% slower)


def test_binomial_coefficient_return_value_positive():
    # Verify that all valid binomial coefficients are positive integers
    codeflash_output = binomial_coefficient(6, 3)  # 2.79μs -> 2.75μs (1.49% faster)
    codeflash_output = binomial_coefficient(7, 2)  # 2.50μs -> 1.04μs (140% faster)


def test_binomial_coefficient_large_factorization():
    # Test C(6, 3) = 20 which is 6!/(3!*3!)
    codeflash_output = binomial_coefficient(6, 3)  # 2.75μs -> 2.79μs (1.47% slower)


def test_binomial_coefficient_increasing_sequence():
    # Test that C(n, k) increases then decreases for fixed n
    # Row 6: [1, 6, 15, 20, 15, 6, 1] - should increase to middle then decrease
    row_6 = [binomial_coefficient(6, k) for k in range(7)]


def test_binomial_coefficient_pascal_triangle_row_10():
    # Test entire row 10 of Pascal's triangle with larger values
    # Row 10: [1, 10, 45, 120, 210, 252, 210, 120, 45, 10, 1]
    codeflash_output = binomial_coefficient(10, 0)  # 208ns -> 333ns (37.5% slower)
    codeflash_output = binomial_coefficient(10, 1)  # 1.29μs -> 2.54μs (49.2% slower)
    codeflash_output = binomial_coefficient(10, 2)  # 4.92μs -> 1.96μs (151% faster)
    codeflash_output = binomial_coefficient(10, 3)  # 12.7μs -> 1.46μs (772% faster)
    codeflash_output = binomial_coefficient(10, 4)  # 23.0μs -> 1.54μs (1389% faster)
    codeflash_output = binomial_coefficient(10, 5)  # 28.2μs -> 958ns (2844% faster)
    codeflash_output = binomial_coefficient(10, 6)  # 23.2μs -> 875ns (2548% faster)
    codeflash_output = binomial_coefficient(10, 7)  # 13.2μs -> 708ns (1766% faster)
    codeflash_output = binomial_coefficient(10, 8)  # 5.00μs -> 500ns (900% faster)
    codeflash_output = binomial_coefficient(10, 9)  # 1.04μs -> 334ns (212% faster)
    codeflash_output = binomial_coefficient(10, 10)  # 166ns -> 166ns (0.000% faster)


def test_binomial_coefficient_pascal_triangle_row_12():
    # Test row 12 of Pascal's triangle with larger numbers
    # C(12, 0) = 1
    codeflash_output = binomial_coefficient(12, 0)  # 208ns -> 333ns (37.5% slower)

    # C(12, 1) = 12
    codeflash_output = binomial_coefficient(12, 1)  # 1.50μs -> 3.50μs (57.1% slower)

    # C(12, 2) = 66
    codeflash_output = binomial_coefficient(12, 2)  # 6.88μs -> 2.12μs (224% faster)

    # C(12, 3) = 220
    codeflash_output = binomial_coefficient(12, 3)  # 22.8μs -> 2.17μs (954% faster)

    # C(12, 4) = 495
    codeflash_output = binomial_coefficient(12, 4)  # 52.3μs -> 1.58μs (3204% faster)

    # C(12, 5) = 792
    codeflash_output = binomial_coefficient(12, 5)  # 85.5μs -> 1.42μs (5934% faster)

    # C(12, 6) = 924 (peak for row 12)
    codeflash_output = binomial_coefficient(12, 6)  # 100μs -> 1.29μs (7640% faster)


def test_binomial_coefficient_symmetry_larger_values():
    # Test symmetry property with larger values
    # C(12, 3) should equal C(12, 9)
    codeflash_output = binomial_coefficient(12, 3)  # 23.2μs -> 6.50μs (258% faster)

    # C(12, 4) should equal C(12, 8)
    codeflash_output = binomial_coefficient(12, 4)  # 52.4μs -> 2.04μs (2466% faster)


def test_binomial_coefficient_row_15_middle():
    # Test middle value of row 15: C(15, 7) and C(15, 8)
    # These should be equal due to symmetry
    codeflash_output = binomial_coefficient(15, 7)  # 693μs -> 12.4μs (5486% faster)

    # The value should be 6435
    codeflash_output = binomial_coefficient(15, 7)  # 686μs -> 125ns (549033% faster)


def test_binomial_coefficient_multiple_rows_validation():
    # Validate multiple complete rows for correctness
    # Row 7: [1, 7, 21, 35, 35, 21, 7, 1]
    expected_row_7 = [1, 7, 21, 35, 35, 21, 7, 1]
    for k, expected_val in enumerate(expected_row_7):
        codeflash_output = binomial_coefficient(7, k)  # 15.4μs -> 6.33μs (143% faster)

    # Row 8: [1, 8, 28, 56, 70, 56, 28, 8, 1]
    expected_row_8 = [1, 8, 28, 56, 70, 56, 28, 8, 1]
    for k, expected_val in enumerate(expected_row_8):
        codeflash_output = binomial_coefficient(8, k)  # 28.9μs -> 2.38μs (1116% faster)


def test_binomial_coefficient_row_9_complete():
    # Test complete row 9 of Pascal's triangle
    # Row 9: [1, 9, 36, 84, 126, 126, 84, 36, 9, 1]
    codeflash_output = binomial_coefficient(9, 0)  # 208ns -> 375ns (44.5% slower)
    codeflash_output = binomial_coefficient(9, 1)  # 1.25μs -> 2.12μs (41.2% slower)
    codeflash_output = binomial_coefficient(9, 2)  # 4.08μs -> 1.88μs (118% faster)
    codeflash_output = binomial_coefficient(9, 3)  # 9.25μs -> 1.25μs (640% faster)
    codeflash_output = binomial_coefficient(9, 4)  # 13.8μs -> 1.08μs (1172% faster)
    codeflash_output = binomial_coefficient(9, 5)  # 14.2μs -> 1.17μs (1121% faster)
    codeflash_output = binomial_coefficient(9, 6)  # 9.21μs -> 667ns (1281% faster)
    codeflash_output = binomial_coefficient(9, 7)  # 3.92μs -> 458ns (755% faster)
    codeflash_output = binomial_coefficient(9, 8)  # 958ns -> 292ns (228% faster)
    codeflash_output = binomial_coefficient(9, 9)  # 125ns -> 125ns (0.000% faster)


def test_binomial_coefficient_loop_computation():
    # Compute multiple binomial coefficients in a loop to test robustness
    # Generate row 11: [1, 11, 55, 165, 330, 462, 462, 330, 165, 55, 11, 1]
    expected_row_11 = [1, 11, 55, 165, 330, 462, 462, 330, 165, 55, 11, 1]

    for k in range(len(expected_row_11)):
        codeflash_output = binomial_coefficient(11, k)
        result = codeflash_output  # 223μs -> 14.0μs (1490% faster)


def test_binomial_coefficient_many_calls():
    # Test the function with many repeated calls to verify consistency
    # Call each coefficient 10 times to ensure consistency
    test_cases = [(5, 2), (6, 3), (7, 4), (8, 2), (9, 3), (10, 5)]

    for n, k in test_cases:
        codeflash_output = binomial_coefficient(n, k)
        first_result = codeflash_output  # 47.9μs -> 8.00μs (498% faster)

        # Call multiple times and verify same result each time
        for _ in range(9):
            codeflash_output = binomial_coefficient(n, k)
            result = codeflash_output


def test_binomial_coefficient_pascal_property():
    # Test Pascal's triangle recurrence property: C(n, k) = C(n-1, k-1) + C(n-1, k)
    # for various values

    # C(8, 3) should equal C(7, 2) + C(7, 3)
    codeflash_output = binomial_coefficient(8, 3)  # 6.83μs -> 4.08μs (67.4% faster)

    # C(9, 4) should equal C(8, 3) + C(8, 4)
    codeflash_output = binomial_coefficient(9, 4)  # 14.2μs -> 1.12μs (1167% faster)

    # C(10, 5) should equal C(9, 4) + C(9, 5)
    codeflash_output = binomial_coefficient(10, 5)  # 28.1μs -> 1.04μs (2599% faster)


def test_binomial_coefficient_row_13_comprehensive():
    # Comprehensive test of row 13
    # Row 13: [1, 13, 78, 286, 715, 1287, 1716, 1716, 1287, 715, 286, 78, 13, 1]
    expected_row_13 = [1, 13, 78, 286, 715, 1287, 1716, 1716, 1287, 715, 286, 78, 13, 1]

    computed_row_13 = [binomial_coefficient(13, k) for k in range(14)]


def test_binomial_coefficient_monotonic_increase_to_middle():
    # Test that for a fixed n, C(n, k) monotonically increases until the middle
    # Test row 14
    row_14 = [binomial_coefficient(14, k) for k in range(15)]

    # First half should be monotonically increasing
    for i in range(7):
        pass


def test_binomial_coefficient_all_positive_results():
    # Verify all binomial coefficients for multiple rows are positive
    for n in range(11):
        for k in range(n + 1):
            codeflash_output = binomial_coefficient(n, k)
            result = codeflash_output


# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

from src.math.combinatorics import binomial_coefficient


def test_binomial_coefficient():
    binomial_coefficient(0, 0)

To edit these changes git checkout codeflash/optimize-binomial_coefficient-mlew2iwa and push.