Program to calculate value of nCr

Following are the common definitions of Binomial Coefficients. 

• 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.

Given two numbers N and r, The task is to find the value of ^NC_r 

Examples :

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

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

Approach: Below is the idea to solve the problem:

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;

int fact(int n);

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

// Returns factorial of n
int fact(int n)
{
      if(n==0)
      return 1;
    int 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>

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

int 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 int nCr(int n, int r)
{
    return fact(n) / (fact(r) *
                  fact(n - r));
}

// Returns factorial of n
static int fact(int n)
{
      if(n==0)
      return 1;
    int 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:
        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

C#

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

class GFG {

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

// Returns factorial of n
static int fact(int n)
{
      if(n==0)
      return 1;
    int 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.

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)
      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.
?>

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)
      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>

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.

Another Approach:

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²)

More efficient approach:

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

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

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.

Output

10

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

Another Approach(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;
}

Output

10

Time Complexity: O(r)

Auxiliary Space: O(1)

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