 GeeksforGeeks App
Open App Browser
Continue

## Related Articles

• Write an Interview Experience
• Mathematical Algorithms

# 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 Xk in the expansion of (1 + X)n.
• 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

Examples :

Input: N = 5, r = 2
Output: 10
Explanation: The value of 5C2 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 nCr = (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 ``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 ` `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

 ``

## Javascript

 ``

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 ``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(2N)
Auxiliary Space: O(N2)

### More efficient approach:

Iterative way of calculating NCR.    using binomial coefficient formula.

## C++

 `#include ``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<

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

My Personal Notes arrow_drop_up