Ways of selecting men and women from a group to make a team
Given four integers n, w, m and k where,
- m is the total number of men.
- w is the total number of women.
- n is the total number of people that need to be selected to form the team.
- k is the minimum number of men that have to be selected.
The task is to find the number of ways in which the team can be formed.
Examples:
Input: m = 2, w = 2, n = 3, k = 1
Output: 4
There are 2 men, 2 women. We need to make a team of size 3 with at least one man and one woman. We can make the team in following ways.
m1 m2 w1
m1 w1 w2
m2 w1 w2
m1 m2 w2
Input: m = 7, w = 6, n = 5, k = 3
Output: 756
Input: m = 5, w = 6, n = 6, k = 3
Output: 281
Approach: Since, we have to take at least k men.
Totals ways = Ways when ‘k’ men are selected + Ways when ‘k+1’ men are selected + … + when ‘n’ men are selected
.
Taking the first example from above where out of 7 men and 6 women, total 5 people need to be selected with at least 3 men,
Number of ways = (7C3 x 6C2) + (7C4 x 6C1) + (7C5)
= 7 x 6 x 5 x 6 x 5 + (7C3 x 6C1) + (7C2)
= 525 + 7 x 6 x 5 x 6 + 7 x 6
= (525 + 210 + 21)
= 756
Algorithm:
- Create a method named “fact” that takes a parameter n and returns the factorial of n.
- Create a variable named “fact” and initialize it to 1.
- Start a for loop and traverse through the range 2 to n (inclusive) and multiply each number with the “fact” variable.
- Return the value of “fact”.
- Create another method named “ncr” that takes two parameters n and r, and returns the value of nCr.
- Inside the “ncr” function, use the “fact” function to calculate the factorial of n, r, and n-r.
- Calculate nCr using the formula n! / (r! * (n-r)!).
- Return the value of nCr.
- Create another method “ways” that takes four parameters m, w, n, and k, and returns the total possible ways.
- Create a variable named “ans” and initialize it to 0.
- Start a while loop to iterate until m is greater than or equal to k.
- Inside the while loop, add the value of nCr(m, k) multiplied by nCr(w, n-k) to the “ans” variable.
- Increment k by 1 in each iteration.
- Return the value of “ans”.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int fact( int n)
{
int fact = 1;
for ( int i = 2; i <= n; i++)
fact *= i;
return fact;
}
int ncr( int n, int r)
{
int ncr = fact(n) / (fact(r) * fact(n - r));
return ncr;
}
int ways( int m, int w, int n, int k)
{
int ans = 0;
while (m >= k) {
ans += ncr(m, k) * ncr(w, n - k);
k += 1;
}
return ans;
}
int main()
{
int m, w, n, k;
m = 7;
w = 6;
n = 5;
k = 3;
cout << ways(m, w, n, k);
}
|
Java
import java.io.*;
class GFG {
static int fact( int n)
{
int fact = 1 ;
for ( int i = 2 ; i <= n; i++)
fact *= i;
return fact;
}
static int ncr( int n, int r)
{
int ncr = fact(n) / (fact(r) * fact(n - r));
return ncr;
}
static int ways( int m, int w, int n, int k)
{
int ans = 0 ;
while (m >= k) {
ans += ncr(m, k) * ncr(w, n - k);
k += 1 ;
}
return ans;
}
public static void main (String[] args) {
int m, w, n, k;
m = 7 ;
w = 6 ;
n = 5 ;
k = 3 ;
System.out.println( ways(m, w, n, k));
}
}
|
Python3
def fact(n):
fact = 1
for i in range ( 2 , n + 1 ):
fact * = i
return fact
def ncr(n, r):
ncr = fact(n) / / (fact(r) * fact(n - r))
return ncr
def ways(m, w, n, k):
ans = 0
while (m > = k):
ans + = ncr(m, k) * ncr(w, n - k)
k + = 1
return ans;
m = 7
w = 6
n = 5
k = 3
print (ways(m, w, n, k))
|
C#
class GFG {
static int fact( int n)
{
int fact = 1;
for ( int i = 2; i <= n; i++)
fact *= i;
return fact;
}
static int ncr( int n, int r)
{
int ncr = fact(n) / (fact(r) * fact(n - r));
return ncr;
}
static int ways( int m, int w, int n, int k)
{
int ans = 0;
while (m >= k) {
ans += ncr(m, k) * ncr(w, n - k);
k += 1;
}
return ans;
}
static void Main () {
int m, w, n, k;
m = 7;
w = 6;
n = 5;
k = 3;
System.Console.WriteLine( ways(m, w, n, k));
}
}
|
Javascript
<script>
function fact(n)
{
var fact = 1;
for (i = 2; i <= n; i++)
fact *= i;
return fact;
}
function ncr(n , r)
{
var ncr = fact(n) / (fact(r) * fact(n - r));
return parseInt(ncr);
}
function ways(m , w , n , k)
{
var ans = 0;
while (m >= k)
{
ans += ncr(m, k) * ncr(w, n - k);
k += 1;
}
return parseInt(ans);
}
var m, w, n, k;
m = 7;
w = 6;
n = 5;
k = 3;
document.write( ways(m, w, n, k));
</script>
|
PHP
<?php
function fact( $n )
{
$fact = 1;
for ( $i = 2; $i <= $n ; $i ++)
$fact *= $i ;
return $fact ;
}
function ncr( $n , $r )
{
$ncr = (int)(fact( $n ) / (fact( $r ) *
fact( $n - $r )));
return $ncr ;
}
function ways( $m , $w , $n , $k )
{
$ans = 0;
while ( $m >= $k )
{
$ans += ncr( $m , $k ) *
ncr( $w , $n - $k );
$k += 1;
}
return $ans ;
}
$m = 7;
$w = 6;
$n = 5;
$k = 3;
echo ways( $m , $w , $n , $k );
|
Time Complexity: O(n)
Auxiliary Space: O(1)
Further Optimization : The above code can be optimized using faster algorithms for binomial coefficient computation.
Last Updated :
07 Jan, 2024
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...