Program to calculate value of nCr

Given two numbers N and r, The task is to find the value of ^NC_r . Combinations represent the number of ways to choose r elements from a set of n distinct elements, without regard to the order in which they are selected. The formula for calculating combinations is :

C(n,r) = n! / r! * (n-r) !

Where :

• (n!) represents the factorial of n .
• (r!) represents the factorial of r .

Examples :

Input: N = 5, r = 2
Output: 10 
Explanation: The value of ⁵C₂ is 10

Input: N = 3, r = 1
Output: 3

Program to Calculate the value of nCr

Approach 1 : Using Factorial

The total number of ways for selecting r elements out of n options are ⁿC_r = (n!) / (r! * (n-r)!)
where n! = 1 * 2 * . . . * n.

Below is the Implementation of the above approach:

C++

// CPP program To calculate The Value Of nCr
#include <bits/stdc++.h>
using namespace std;


long nCr(int n, int r)
{
    return fact(n) / (fact(r) * fact(n - r));
}

// Returns factorial of n
long fact(int n)
{
      if(n==0)
      return 1;
    long res = 1;
    for (int i = 2; i <= n; i++)
        res = res * i;
    return res;
}

// Driver code
int main()
{
    int n = 5, r = 3;
    cout << nCr(n, r);
    return 0;
}

C

#include <stdio.h>

long factorial(int n) {
      if(n == 0  || n==1)
      return 1;
    long factorial = 1;
    for (int i = 2; i <= n; i++)
        factorial = factorial * i;
    return factorial;
}

long nCr(int n, int r) {
    return factorial(n) / (factorial(r) * factorial(n - r));
}

int main() {
    int n = 5, r = 3;
      printf("%d", nCr(n, r));
    return 0;
}

// This code was contributed by Omkar Prabhune

Java

// Java program To calculate 
// The Value Of nCr
import java.io.*;

public class GFG {

static long nCr(int n, int r)
{
    return fact(n) / (fact(r) *
                  fact(n - r));
}

// Returns factorial of n
static long fact(int n)
{
      if(n==0 || n==1)
      return 1;
    long res = 1;
    for (int i = 2; i <= n; i++)
        res = res * i;
    return res;
}

// Driver code
public static void main(String[] args)
{
    int n = 5, r = 3;
    System.out.println(nCr(n, r));
}
}

// This code is Contributed by
// Smitha Dinesh Semwal.

Python 3

# Python 3 program To calculate 
# The Value Of nCr

def nCr(n, r):

    return (fact(n) / (fact(r) 
                * fact(n - r)))

# Returns factorial of n
def fact(n):
    if n == 0 or n==1:
        return 1
    res = 1
    
    for i in range(2, n+1):
        res = res * i
        
    return res

# Driver code
n = 5
r = 3
print(int(nCr(n, r)))

# This code is contributed
# by Smitha and improved by naveenkumar30838

C#

// C# program To calculate 
// The Value Of nCr
using System;

class GFG {

static long nCr(int n, int r)
{
   return fact(n) / (fact(r) *
                 fact(n - r));
}

// Returns factorial of n
static long fact(int n)
{
      if(n==0 || n==1)
      return 1;
    long res = 1;
    for (int i = 2; i <= n; i++)
        res = res * i;
    return res;
}

   // Driver code
   public static void Main()
   {
      int n = 5, r = 3;
      Console.Write(nCr(n, r));
   }
}

// This code is Contributed by nitin mittal and improved by naveenkumar30838

Javascript

<script>

// Javascript program To calculate The Value Of nCr 

function nCr(n, r) 
{ 
    return fact(n) / (fact(r) * fact(n - r)); 
} 

// Returns factorial of n 
function fact(n) 
{ 
      if(n==0 || n==1)
      return 1;
    var res = 1; 
    for (var i = 2; i <= n; i++) 
        res = res * i; 
    return res; 
} 

// Driver code 
var n = 5, r = 3; 
document.write(nCr(n, r)); 


</script>

PHP

<?php
// PHP program To calculate
// the Value Of nCr


function nCr( $n, $r)
{
    return fact($n) / (fact($r) * 
                  fact($n - $r));
}

// Returns factorial of n
function fact( $n)
{
      if($n == 0 || $n==1)
      return 1;
    $res = 1;
    for ( $i = 2; $i <= $n; $i++)
        $res = $res * $i;
    return $res;
}

    // Driver code
    $n = 5;
    $r = 3;
    echo nCr($n, $r);
    
// This code is contributed by vt_m.
?>

Output

10

Time Complexity: O(N)
Auxiliary Space: O(1)
Complexity Analysis:

The time complexity of the above approach is O(N).
This is because the function fact() has a time complexity of O(N), and it is called twice for each call to nCr().
The space complexity of the above approach is O(1).
Because the function does not make any recursive calls and only uses a constant amount of memory.

Approach 2 : Using Recursion

The idea is to use a recursive function to calculate the value of nCr. The base cases are:

• if r is greater than n, return 0 (there are no combinations possible)
• if r is 0 or r is n, return 1 (there is only 1 combination possible in these cases)

For other values of n and r, the function calculates the value of nCr by adding the number of combinations possible by including the current element and the number of combinations possible by not including the current element.

Below is the Implementation of the above approach:

C++

#include <iostream>
using namespace std;

int nCr(int n, int r)
{
    if (r > n)
        return 0;
    if (r == 0 || r == n)
        return 1;
    return nCr(n - 1, r - 1) + nCr(n - 1, r);
}

int main()
{

    cout << nCr(5, 3); // Output: 10
    return 0;
}

// This code is contributed by Susobhan Akhuli

Java

import java.util.*;

class GFG {
    public static int nCr(int n, int r)
    {
        if (r > n)
            return 0;
        if (r == 0 || r == n)
            return 1;
        return nCr(n - 1, r - 1) + nCr(n - 1, r);
    }

    public static void main(String[] args)
    {
        System.out.println(nCr(5, 3)); // Output: 10
    }
}

// This code is contributed by Prasad Kandekar(prasad264)

Python3

def nCr(n, r):
    if r > n:
        return 0
    if r == 0 or r == n:
        return 1
    return nCr(n-1, r-1) + nCr(n-1, r)


print(nCr(5, 3))  # Output: 10

# This code is contributed by Susobhan Akhuli

C#

using System;

public class GFG {
    static public int nCr(int n, int r)
    {
        if (r > n)
            return 0;
        if (r == 0 || r == n)
            return 1;
        return nCr(n - 1, r - 1) + nCr(n - 1, r);
    }

    static public void Main(string[] args)
    {
        Console.WriteLine(nCr(5, 3)); // Output: 10
    }
}

// This code is contributed by Prasad Kandekar(prasad264)

Javascript

function nCr(n, r) {
    if (r > n)
        return 0;
    if (r === 0 || r === n)
        return 1;
    return nCr(n-1, r-1) + nCr(n-1, r);
}

console.log(nCr(5, 3)); // Output: 10

// This code is contributed by Prasad Kandekar(prasad264)

Output

10

Time Complexity: O(2^N)
Auxiliary Space: O(N²)

Approach 3 : Using Binomial Coefficient formula

• A binomial coefficient C(n, k) can be defined as the coefficient of X^k in the expansion of (1 + X)ⁿ.
• A binomial coefficient C(n, k) also gives the number of ways, disregarding order, that k objects can be chosen from among n objects; more formally, the number of k-element subsets (or k-combinations) of an n-element set.

Iterative way of calculating ^NC_R.    using binomial coefficient formula.

C++

#include <iostream>
using namespace std;
int main() {
        int n = 5;
        int r = 2;
        double sum = 1;
  // Calculate the value of n choose r using the binomial coefficient formula
        for(int i = 1; i <= r; i++){
            sum = sum * (n - r + i) / i;
        }
        cout<<(int)sum<<endl;

    return 0;
}

Java

import java.util.*;

public class BinomialCoefficient {

    public static void main(String[] args)
    {

        int n = 5;
        int r = 2;
        double sum = 1;

        // Calculate the value of n choose r using the
        // binomial coefficient formula
        for (int i = 1; i <= r; i++) {
            sum = sum * (n - r + i) / i;
        }

        // Print the result after converting it to an
        // integer
        System.out.println((int)sum);
    }
}

Python3

n = 5
r = 2
sum = 1

# Calculate the value of n choose r using the binomial coefficient formula
for i in range(1, r+1):
    sum = sum * (n - r + i) / i

print(int(sum))
# This code is contributed by divyansh2212

C#

using System;

// C# code implementation 
class HelloWorld {

    static void Main() {
        int n = 5;
        int r = 2;
        double sum = 1;
  // Calculate the value of n choose r using the binomial coefficient formula
        for(int i = 1; i <= r; i++){
            sum = sum * (n - r + i) / i;
        }
        Console.WriteLine((int)sum);
    }
}

// The code is contributed by Arushi jindal. 

Javascript

let n = 5;
let r = 2;
let sum = 1;

// Calculate the value of n choose r using the binomial coefficient formula
for(let i = 1; i <= r; i++){
  sum = sum * (n - r + i) / i;
}

console.log(Math.floor(sum));

// This code is contributed by prasad264

Output

10

Time complexity : O(r)
Space complexity : O(1)

Approach 4 : Using Logarithmic Formula

Logarithmic formula for nCr is an alternative to the factorial formula that avoids computing factorials directly and it’s more efficient for large values of n and r. It uses the identity log(n!) = log(1) + log(2) + … + log(n) to express the numerator and denominator of the nCr in terms of sums of logarithms which allows to calculate the nCr using the Logarithmic operations. This approach is faster and very efficient.

The logarithmic formula for nCr is:

nCr = exp( log(n!) – log(r!) – log((n-r)!) )

Below is the implementation of above approach:

C++

#include <bits/stdc++.h>
using namespace std;

// Calculates the binomial coefficient nCr using the logarithmic formula
int nCr(int n, int r) {
    // If r is greater than n, return 0
    if (r > n) return 0;
    // If r is 0 or equal to n, return 1
    if (r == 0 || n == r) return 1;
    // Initialize the logarithmic sum to 0
    double res = 0;
    // Calculate the logarithmic sum of the numerator and denominator using loop
    for (int i = 0; i < r; i++) {
        // Add the logarithm of (n-i) and subtract the logarithm of (i+1)
        res += log(n-i) - log(i+1);
    }
    // Convert logarithmic sum back to a normal number
    return (int)round(exp(res));
}

int main() {
    // Calculate nCr for n = 5 and r = 2
    int n = 5;
    int r = 2;
    cout << nCr(n, r) << endl;
    return 0;
}

Java

import java.util.*;

public class GFG {
    // Calculates the binomial coefficient nCr using the logarithmic formula
    static int nCr(int n, int r) {
        // If r is greater than n, return 0
        if (r > n)
            return 0;
        // If r is 0 or equal to n, return 1
        if (r == 0 || n == r)
            return 1;
        // Initialize the logarithmic sum to 0
        double res = 0;
        // Calculate the logarithmic sum of the numerator and denominator using loop
        for (int i = 0; i < r; i++) {
            // Add the logarithm of (n-i) and subtract the logarithm of (i+1)
            res += Math.log(n - i) - Math.log(i + 1);
        }
        // Convert logarithmic sum back to a normal number
        return (int) Math.round(Math.exp(res));
    }

    public static void main(String[] args) {
        // Calculate nCr for n = 5 and r = 2
        int n = 5;
        int r = 2;
        System.out.println(nCr(n, r));
    }
}

Python

import math

#  Calculates the binomial coefficient nCr using the logarithmic formula
def nCr(n, r):
    # If r is greater than n, return 0
    if r > n:
        return 0
    
    # If r is 0 or equal to n, return 1
    if r == 0 or n == r:
        return 1
    # Initialize the logarithmic sum to 0
    res = 0
    
    # Calculate the logarithmic sum of the numerator and denominator using loop
    for i in range(r):
        # Add the logarithm of (n-i) and subtract the logarithm of (i+1)
        res += math.log(n-i) - math.log(i+1)
    # Convert logarithmic sum back to a normal number
    return round(math.exp(res))

# Test case
n = 5
r = 2
print(nCr(n, r))

C#

using System;

namespace BinomialCoefficient
{
    class Program
    {
        // Calculates the binomial coefficient nCr using the logarithmic formula
        static int nCr(int n, int r)
        {
            // If r is greater than n, return 0
            if (r > n) return 0;
            // If r is 0 or equal to n, return 1
            if (r == 0 || n == r) return 1;
            // Initialize the logarithmic sum to 0
            double res = 0;
            // Calculate the logarithmic sum of the numerator and denominator using loop
            for (int i = 0; i < r; i++)
            {
                // Add the logarithm of (n-i) and subtract the logarithm of (i+1)
                res += Math.Log(n - i) - Math.Log(i + 1);
            }
            // Convert logarithmic sum back to a normal number
            return (int)Math.Round(Math.Exp(res));
        }

        static void Main(string[] args)
        {
            // Calculate nCr for n = 5 and r = 2
            int n = 5;
            int r = 2;
            Console.WriteLine(nCr(n, r));
        }
    }
}

Javascript

// Calculates the binomial coefficient nCr using the logarithmic formula
function nCr(n, r) {
    // If r is greater than n, return 0
    if (r > n) return 0;
    
    // If r is 0 or equal to n, return 1
    if (r === 0 || n === r) return 1;
    
    // Initialize the logarithmic sum to 0
    let res = 0;
    
    // Calculate the logarithmic sum of the numerator and denominator using loop
    for (let i = 0; i < r; i++) {
        // Add the logarithm of (n-i) and subtract the logarithm of (i+1)
        res += Math.log(n - i) - Math.log(i + 1);
    }
    
    // Convert logarithmic sum back to a normal number
    return Math.round(Math.exp(res));
}

// Test case
const n = 5;
const r = 2;
console.log(nCr(n, r));

Output

10

Time Complexity: O(r)

Auxiliary Space: O(1)

Approach 5 : Using Efficient Computation of Combinations

The formula for nCr is = n! / r! * (n-r) ! . Let’s imagine r > n-r (or can take reverse ) . Logic here is since in n! and r! we are going to calculate the factorial of r numbers twice and which is no use i.e they will just cancel out each other , so we don’t calculate them instead we would calculate the product of number from (r , n] and product of numbers from 1 to n-r and divide them (here r can be imagined as the maximum of r , n-r ) . Below is the code for above implementation

C++

#include <iostream>

// calculate multiplication of natural numbers from start to end 
double Multiplier(int start, int end)
{
    if (start == end) {
        return start;
    }
    else {
        double res = 1;
        while (start <= end) {
            res *= start;
            start++;
        }
        return res;
    }
}

double nCR(int n, int r)
{
    if (n < r) {
        return -1;
    }
    else if (n == r || r == 0) {
        return 1;
    }
    else {
        int max_val = std::max(r, n - r);
        int min_val = std::min(r, n - r);
        double numerator = Multiplier(max_val + 1, n);
        double denominator = Multiplier(1, min_val);
        return numerator / denominator;
    }
}

int main()
{
    int n = 20005;
    int r = 25;
    std::cout << nCR(n, r) << std::endl;
    return 0; 
  // contributed by Naveen (naveenkumar30838)
}

Java

/*package whatever //do not write package name here */

import java.io.*;

class GFG {
    public static double nCR(int n, int r)
    {
        if (n < r) {
            return -1;
        }
        if (n == r || r == 0) {
            return 1;
        }
        int max = Math.max(r, n - r);
        int min = Math.min(r, n - r);
        return (double)(Multiplier(max + 1, n)
                        / Multiplier(1, min));
    }
    // calculate multiplication of natural numbers from start to end 
    public static double Multiplier(int start, int end)
    {
        if (start == end) {
            return start;
        }
        double res = 1;
        while (start <= end) {
            res *= start;
            start++;
        }
        return res;
    }
    public static void main(String[] args)
    {
        System.out.println(
            nCR(20005, 25)); // ans 2.1443850196899737E82
        // Code contributed by Naveen (naveenkumar30838)
    }
}

Python

def nCR(n, r):
    if n < r:
        return -1
    if n == r or r == 0:
        return 1
    max_val = max(r, n - r)
    min_val = min(r, n - r)
    return Multiplier(max_val + 1, n) / Multiplier(1, min_val)

   # calculate multiplication of natural numbers from start to end 
def Multiplier(start, end):
    if start == end:
        return start
    res = 1
    while start <= end:
        res *= start
        start += 1
    return res


print(nCR(20005, 25))
#contributed by Naveen (naveenkumar30838) 
# ans 21443850196899739431852611539526726818562627337667639676891232267646561961531437300

C#

using System;

class GFG {
    static double nCR(int n, int r)
    {
        if (n < r) {
            return -1;
        }
        else if (n == r || r == 0) {
            return 1;
        }
        else {
            int max_val = Math.Max(r, n - r);
            int min_val = Math.Min(r, n - r);
            double numerator = Multiplier(max_val + 1, n);
            double denominator = Multiplier(1, min_val);
            return numerator / denominator;
        }
    }
    // calculate multiplication of natural numbers from start to end 
    static double Multiplier(int start, int end)
    {
        if (start == end) {
            return start;
        }
        else {
            double res = 1;
            while (start <= end) {
                res *= start;
                start++;
            }
            return res;
        }
    }

    static void Main(string[] args)
    {
        int n = 20005;
        int r = 25;
        Console.WriteLine($ "{nCR(n, r)}");
      // Contributed by Naveen(naveenkumar30838) 
     // ans 2.1443850196899737E82
      
    }
}

Output : 2.1443850196899737E82

Time complexity : O(n)

Space complexity : O(1)

Complexity Analysis : In every case (including worst case ) we have to calculate the multiplier from (n-r) and from (1 to r ) which give run in linear time giving a total time complexity of O(n-r +r ) = O(n) . Since no extra space is used so space complexity if O(1) . Since we have eliminated the repeated steps so it is a more optimized solution and hence it can be used for handling large values .

More Efficient Solutions:
Dynamic Programming | Set 9 (Binomial Coefficient)
Space and time efficient Binomial Coefficient
All Articles on Binomial Coefficient

Conclusion

In conclusion, nCr can be efficiently computed using several approaches, including factorial computation, recursion, binomial coefficient formula, logarithmic formula, and an optimized method that eliminates redundant calculations. Each approach has its own time and space complexity considerations, with the optimized solution being particularly suitable for handling large values due to its linear time complexity and constant space complexity. Additionally, further exploration of dynamic programming techniques and space-time efficient binomial coefficient calculations offer more efficient solutions for handling complex scenarios .