Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

Program to calculate the value of nCr Efficiently

  • Difficulty Level : Medium
  • Last Updated : 22 Mar, 2021

Given two numbers n, r ( n>=r ). The task is to find the value of C(n, r) for big value of n.

Examples: 

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input: n = 30, r = 15
Output: 155117520
C(30, 15) is 155117520 by  30!/((30-15)!*15!)


Input: n = 50, r = 25
Output: 126410606437752

Approach: A simple code can be created with the following knowledge that : 



C(n, r) = [n * (n-1) * .... * (n-r+1)] / [r * (r-1) * .... * 1]

However, for big values of n, r the products may overflow, hence during each iteration we divide the current variables holding value of products by their gcd. 

Below is the required implementation: 

C++




// C++ implementation to find nCr
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the nCr
void printNcR(int n, int r)
{
 
    // p holds the value of n*(n-1)*(n-2)...,
    // k holds the value of r*(r-1)...
    long long p = 1, k = 1;
 
    // C(n, r) == C(n, n-r),
    // choosing the smaller value
    if (n - r < r)
        r = n - r;
 
    if (r != 0) {
        while (r) {
            p *= n;
            k *= r;
 
            // gcd of p, k
            long long m = __gcd(p, k);
 
            // dividing by gcd, to simplify
            // product division by their gcd
            // saves from the overflow
            p /= m;
            k /= m;
 
            n--;
            r--;
        }
 
        // k should be simplified to 1
        // as C(n, r) is a natural number
        // (denominator should be 1 ) .
    }
 
    else
        p = 1;
 
    // if our approach is correct p = ans and k =1
    cout << p << endl;
}
 
// Driver code
int main()
{
    int n = 50, r = 25;
 
    printNcR(n, r);
 
    return 0;
}

Java




// Java implementation to find nCr
 
class GFG {
 
    // Function to find the nCr
    static void printNcR(int n, int r)
    {
 
        // p holds the value of n*(n-1)*(n-2)...,
        // k holds the value of r*(r-1)...
        long p = 1, k = 1;
 
        // C(n, r) == C(n, n-r),
        // choosing the smaller value
        if (n - r < r) {
            r = n - r;
        }
 
        if (r != 0) {
            while (r > 0) {
                p *= n;
                k *= r;
 
                // gcd of p, k
                long m = __gcd(p, k);
 
                // dividing by gcd, to simplify
                // product division by their gcd
                // saves from the overflow
                p /= m;
                k /= m;
 
                n--;
                r--;
            }
 
            // k should be simplified to 1
            // as C(n, r) is a natural number
            // (denominator should be 1 ) .
        }
        else {
            p = 1;
        }
 
        // if our approach is correct p = ans and k =1
        System.out.println(p);
    }
 
    static long __gcd(long n1, long n2)
    {
        long gcd = 1;
 
        for (int i = 1; i <= n1 && i <= n2; ++i) {
            // Checks if i is factor of both integers
            if (n1 % i == 0 && n2 % i == 0) {
                gcd = i;
            }
        }
        return gcd;
    }
 
    // Driver code
    public static void main(String[] args)
    {
        int n = 50, r = 25;
 
        printNcR(n, r);
    }
}

Python3




# Python3 implementation to find nCr
 
from math import *
 
# Function to find the nCr
 
 
def printNcR(n, r):
 
    # p holds the value of n*(n-1)*(n-2)...,
    # k holds the value of r*(r-1)...
    p = 1
    k = 1
 
    # C(n, r) == C(n, n-r),
    # choosing the smaller value
    if (n - r < r):
        r = n - r
 
    if (r != 0):
        while (r):
            p *= n
            k *= r
 
            # gcd of p, k
            m = gcd(p, k)
 
            # dividing by gcd, to simplify product
            # division by their gcd saves from
            # the overflow
            p //= m
            k //= m
 
            n -= 1
            r -= 1
 
        # k should be simplified to 1
        # as C(n, r) is a natural number
        # (denominator should be 1 )
 
    else:
        p = 1
 
    # if our approach is correct p = ans and k =1
    print(p)
 
 
# Driver code
if __name__ == "__main__":
    n = 50
    r = 25
 
    printNcR(n, r)
 
# this code is contributed by
# ChitraNayal

C#




// C# implementation to find nCr
 
using System;
 
public class GFG {
 
    // Function to find the nCr
    static void printNcR(int n, int r)
    {
 
        // p holds the value of n*(n-1)*(n-2)...,
        // k holds the value of r*(r-1)...
        long p = 1, k = 1;
 
        // C(n, r) == C(n, n-r),
        // choosing the smaller value
        if (n - r < r) {
            r = n - r;
        }
 
        if (r != 0) {
            while (r > 0) {
                p *= n;
                k *= r;
 
                // gcd of p, k
                long m = __gcd(p, k);
 
                // dividing by gcd, to simplify
                // product division by their gcd
                // saves from the overflow
                p /= m;
                k /= m;
 
                n--;
                r--;
            }
 
            // k should be simplified to 1
            // as C(n, r) is a natural number
            // (denominator should be 1 ) .
        }
        else {
            p = 1;
        }
 
        // if our approach is correct p = ans and k =1
        Console.WriteLine(p);
    }
 
    static long __gcd(long n1, long n2)
    {
        long gcd = 1;
 
        for (int i = 1; i <= n1 && i <= n2; ++i) {
            // Checks if i is factor of both integers
            if (n1 % i == 0 && n2 % i == 0) {
                gcd = i;
            }
        }
        return gcd;
    }
 
    // Driver code
    static public void Main()
    {
        int n = 50, r = 25;
        printNcR(n, r);
    }
    // This code is contributed by ajit.
}

PHP




<?php
// PHP implementation to find nCr
     
// Function to find the nCr
function printNcR($n, $r) {
 
        // p holds the value of n*(n-1)*(n-2)...,
        // k holds the value of r*(r-1)...
        $p = 1;
        $k = 1;
 
        // C(n, r) == C(n, n-r),
        // choosing the smaller value
        if ($n - $r < $r) {
            $r = $n - $r;
        }
 
        if ($r != 0) {
            while ($r > 0) {
                $p *= $n;
                $k *= $r;
 
                // gcd of p, k
                $m = __gcd($p, $k);
 
                // dividing by gcd, to simplify product
                // division by their gcd saves from the overflow
                $p /= $m;
                $k /= $m;
 
                $n--;
                $r--;
            }
 
            // k should be simplified to 1
            // as C(n, r) is a natural number
            // (denominator should be 1 ) .
        } else {
            $p = 1;
        }
 
        // if our approach is correct p = ans and k =1
        echo ($p);
    }
 
    function  __gcd($n1, $n2) {
         $gcd = 1;
 
        for ($i = 1; $i <= $n1 && $i <= $n2; ++$i) {
            // Checks if i is factor of both integers
            if ($n1 % $i == 0 && $n2 % $i == 0) {
                $gcd = $i;
            }
        }
        return $gcd;
    }
 
        // Driver code
        $n = 50;
        $r = 25;
        printNcR($n, $r);
 
 
//This code is contributed by Sachin.
 
?>

Javascript




<script>
 
// Javascript implementation to find nCr
 
function __gcd(n1, n2)
{
    var gcd = 1;
 
    for (var i = 1; i <= n1 && i <= n2; ++i) {
        // Checks if i is factor of both integers
        if (n1 % i == 0 && n2 % i == 0) {
            gcd = i;
        }
    }
    return gcd;
}
 
// Function to find the nCr
function printNcR(n, r)
{
 
    // p holds the value of n*(n-1)*(n-2)...,
    // k holds the value of r*(r-1)...
    var p = 1, k = 1;
 
    // C(n, r) == C(n, n-r),
    // choosing the smaller value
    if (n - r < r)
        r = n - r;
 
    if (r != 0) {
        while (r) {
            p *= n;
            k *= r;
 
            // gcd of p, k
            var m = __gcd(p, k);
 
            // dividing by gcd, to simplify
            // product division by their gcd
            // saves from the overflow
            p /= m;
            k /= m;
 
            n--;
            r--;
        }
 
        // k should be simplified to 1
        // as C(n, r) is a natural number
        // (denominator should be 1 ) .
    }
 
    else
        p = 1;
 
    // if our approach is correct p = ans and k =1
    document.write(p);
}
 
// Driver code
var n = 50, r = 25;
printNcR(n, r);
 
</script>
Output
126410606437752

Time Complexity: O( R Log N) 
Auxiliary Space: O(1)




My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!