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

## Javascript

 ``

## PHP

 ``

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`

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

### 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;` `}`

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

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Previous
Next