Python Program to Calculate nCr and nPr

In combinatorics, nCr and nPr are essential formulas used to calculate combinations and permutations. They represent the number of ways to select and arrange objects from a set. nCr refers to combinations, where order does not matter, while nPr refers to permutations, where order does matter.

The permutation refers to the arrangement of objects in a specific order. A combination refers to the selection of objects without taking order in reference. In this article, we are going to learn how we can calculate nCr and nPr in Python using different approaches.

Formulas for nCr and nPr

The formulas for nCr and nPr are as follows ?

Combination (nCr): n! / (r! × (n?r)!)
Permutation (nPr): n! / (n?r)!

Where, n: Total number of objects, r: Number of objects to select or arrange, !: Factorial of a number.

Using the Direct Formula Approach

In this approach, we use the direct formula to calculate nCr and nPr. In Python, we can manually implement the factorial calculation formula ?

Steps for Implementation

• Define a function to calculate the factorial of a number.
• Inside the function write the logic to calculate permutation and combination.
• Use the factorial function to calculate nCr and nPr using their respective formulas.
• Output the result.

Example

def factorial(n):
    if n == 0 or n == 1:
        return 1
    return n * factorial(n - 1)

def calculate_nCr(n, r):
    return factorial(n) // (factorial(r) * factorial(n - r))

def calculate_nPr(n, r):
    return factorial(n) // factorial(n - r)

n = 6
r = 2
nCr = calculate_nCr(n, r)
nPr = calculate_nPr(n, r)

print(f"nCr for n={n} and r={r} is: {nCr}")
print(f"nPr for n={n} and r={r} is: {nPr}")

nCr for n=6 and r=2 is: 15
nPr for n=6 and r=2 is: 30

Using Python's math Module

In this approach, we use Python's built-in math module to efficiently calculate the factorial of the number. It provides an optimized function for factorial calculation ?

Steps for Implementation

• Import the factorial function from the math module.
• Use the nCr and nPr formulas directly.
• Output the result.

Example

from math import factorial

def calculate_nCr(n, r):
    return factorial(n) // (factorial(r) * factorial(n - r))

def calculate_nPr(n, r):
    return factorial(n) // factorial(n - r)

n = 7
r = 3
nCr = calculate_nCr(n, r)
nPr = calculate_nPr(n, r)

print(f"nCr for n={n} and r={r} is: {nCr}")
print(f"nPr for n={n} and r={r} is: {nPr}")

nCr for n=7 and r=3 is: 35
nPr for n=7 and r=3 is: 210

Using math.comb and math.perm Functions

In this approach, we use Python functions comb and perm directly to find permutation and combination. In Python 3.8 and later, the math module introduced the comb and perm functions ?

Steps for Implementation

• Import the comb and perm functions from the math module.
• Use these functions to directly calculate nCr and nPr.
• Output the result.

Example

from math import comb, perm

n = 10
r = 4
nCr = comb(n, r)
nPr = perm(n, r)

print(f"nCr for n={n} and r={r} is: {nCr}")
print(f"nPr for n={n} and r={r} is: {nPr}")

nCr for n=10 and r=4 is: 210
nPr for n=10 and r=4 is: 5040

Using Recursive Approach

In this approach, we use a recursive method to calculate permutation and combination. This approach uses recursion to compute the factorial values for the formulas. This is an alternate method, but it is less efficient than the direct approach ?

Steps for Implementation

• Define a recursive function for calculating the factorial.
• Use the recursive factorial function to compute permutation and combination.
• Output both results.

Example

def recursive_factorial(n):
    if n == 0 or n == 1:
        return 1
    return n * recursive_factorial(n - 1)

def calculate_nCr_nPr_recursive(n, r):
    nCr = recursive_factorial(n) // (recursive_factorial(r) * recursive_factorial(n - r))
    nPr = recursive_factorial(n) // recursive_factorial(n - r)
    return nCr, nPr

n = 4
r = 2
nCr, nPr = calculate_nCr_nPr_recursive(n, r)

print(f"The value of nCr (C({n},{r})) is: {nCr}")
print(f"The value of nPr (P({n},{r})) is: {nPr}")

The value of nCr (C(4,2)) is: 6
The value of nPr (P(4,2)) is: 12

Comparison

Conclusion

Use math.comb() and math.perm() for the most efficient calculations in Python 3.8+. For older versions, use math.factorial() with manual formulas for better performance than recursive approaches.