Number of ways of distributing N identical objects in R distinct groups with no groups empty

Given two integer N and R, the task is to calculate the number of ways to distribute N identical objects into R distinct groups such that no groups are left empty.

Examples:

Input: N = 4, R = 2
Output: 3
No of objects in 1st group = 1, in second group = 3
No of objects in 1st group = 2, in second group = 2
No of objects in 1st group = 3, in second group = 1

Input: N = 5, R = 3
Output: 6

Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach: Idea is to use Multinomial theorem. Let us suppose that x₁ objects are placed in the first group, x₂ objects are placed in second group and x_R objects are placed in the R^th group. It is given that,
x₁ + x₂ + x₃ +…+ x_R = N for all x_i ≥ 1 for 1 ≤ i ≤ R
Now replace every x_i with y_i + 1 for all 1 ≤ i ≤ R. Now all the y variaables are greater than or equal to zero.
The equation becomes,
y₁ + y₂ + y₃ + … + y_R + R = N for all y_i ≥ 0 for 1 ≤ i ≤ R
y₁ + y₂ + y₃ + … + y_R = N – R
It now reduces to that standard multinomial equation whose solution is ^{(N – R) + R – 1}C_{R – 1}.
The solution of this equation is given by ^{N – 1}C_{R – 1}.

Below is the implementation of the above approach:

CPP

// C++ implementation of the above approach 
#include <bits/stdc++.h> 
using namespace std; 
  
// Function to return the 
// value of ncr effectively 
int ncr(int n, int r) 
{ 
  
    // Initialize the answer 
    int ans = 1; 
  
    for (int i = 1; i <= r; i += 1) { 
  
        // Divide simultaneously by 
        // i to avoid overflow 
        ans *= (n - r + i); 
        ans /= i; 
    } 
    return ans; 
} 
  
// Function to return the number of 
// ways to distribute N identical 
// objects in R distinct objects 
int NoOfDistributions(int N, int R) 
{ 
    return ncr(N - 1, R - 1); 
} 
  
// Driver code 
int main() 
{ 
    int N = 4; 
    int R = 3; 
  
    cout << NoOfDistributions(N, R); 
  
    return 0; 
} 

Java

// Java implementation of the above approach  
import java.io.*; 
  
class GFG  
{ 
          
    // Function to return the  
    // value of ncr effectively  
    static int ncr(int n, int r)  
    {  
      
        // Initialize the answer  
        int ans = 1;  
      
        for (int i = 1; i <= r; i += 1)  
        {  
      
            // Divide simultaneously by  
            // i to avoid overflow  
            ans *= (n - r + i);  
            ans /= i;  
        }  
        return ans;  
    }  
      
    // Function to return the number of  
    // ways to distribute N identical  
    // objects in R distinct objects  
    static int NoOfDistributions(int N, int R)  
    {  
        return ncr(N - 1, R - 1);  
    }  
      
    // Driver code  
    public static void main (String[] args) 
    { 
  
        int N = 4;  
        int R = 3;  
      
        System.out.println(NoOfDistributions(N, R));  
    } 
} 
  
// This code is contributed by ajit  

Python3

# Python3 implementation of the above approach 
  
# Function to return the 
# value of ncr effectively 
def ncr(n, r): 
  
  
    # Initialize the answer 
    ans = 1
  
    for i in range(1,r+1):  
  
        # Divide simultaneously by 
        # i to avoid overflow 
        ans *= (n - r + i) 
        ans //= i 
      
    return ans 
  
# Function to return the number of 
# ways to distribute N identical 
# objects in R distinct objects 
def NoOfDistributions(N, R): 
  
    return ncr(N - 1, R - 1) 
  
# Driver code 
  
N = 4
R = 3
  
print(NoOfDistributions(N, R)) 
  
# This code is contributed by mohit kumar 29 

C#

// C# implementation of the above approach  
using System; 
  
class GFG 
{ 
      
    // Function to return the  
    // value of ncr effectively  
    static int ncr(int n, int r)  
    {  
      
        // Initialize the answer  
        int ans = 1;  
      
        for (int i = 1; i <= r; i += 1)  
        {  
      
            // Divide simultaneously by  
            // i to avoid overflow  
            ans *= (n - r + i);  
            ans /= i;  
        }  
        return ans;  
    }  
      
    // Function to return the number of  
    // ways to distribute N identical  
    // objects in R distinct objects  
    static int NoOfDistributions(int N, int R)  
    {  
        return ncr(N - 1, R - 1);  
    }  
      
    // Driver code  
    static public void Main () 
    { 
        int N = 4;  
        int R = 3;  
      
        Console.WriteLine(NoOfDistributions(N, R));  
    } 
} 
  
// This code is contributed by AnkitRai01 

Output:

Time Complexity: O(R)

My Personal Notes

Recommended: Please try your approach on {IDE} first, before moving on to the solution.

CPP

Java

Python3

C#

Recommended Posts: