# Program to calculate value of nCr

Last Updated : 20 Apr, 2024

Given two numbers N and r, The task is to find the value of NCr . 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 5C2 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 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 <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(2N)
Auxiliary Space: O(N2)

### Approach 3 : Using Binomial Coefficient formula

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

Iterative way of calculating NCR.    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 } } ``` JavaScript ```// Calculate multiplication of natural numbers from start to end function multiplier(start, end) { if (start === end) { return start; } else { let res = 1; while (start <= end) { res *= start; start++; } return res; } } // Function to calculate n choose r (nCr) function nCR(n, r) { if (n < r) { return -1; } else if (n === r || r === 0) { return 1; } else { const maxVal = Math.max(r, n - r); const minVal = Math.min(r, n - r); const numerator = multiplier(maxVal + 1, n); const denominator = multiplier(1, minVal); return numerator / denominator; } } // Example usage const n = 20005; const r = 25; console.log(nCR(n, r)); ```

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 .

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

Previous
Next