# Ways of selecting men and women from a group to make a team

• Difficulty Level : Medium
• Last Updated : 23 Jul, 2022

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:
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
Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;` `// Returns factorial``// of the number``int` `fact(``int` `n)``{``    ``int` `fact = 1;``    ``for` `(``int` `i = 2; i <= n; i++)``        ``fact *= i;``    ``return` `fact;``}` `// Function to calculate ncr``int` `ncr(``int` `n, ``int` `r)``{``    ``int` `ncr = fact(n) / (fact(r) * fact(n - r));``    ``return` `ncr;``}` `// Function to calculate``// the total possible ways``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;``}` `// Driver code``int` `main()``{` `    ``int` `m, w, n, k;``    ``m = 7;``    ``w = 6;``    ``n = 5;``    ``k = 3;``    ``cout << ways(m, w, n, k);``}`

## Java

 `// Java implementation of the approach` `import` `java.io.*;` `class` `GFG {` `// Returns factorial``// of the number``static` `int` `fact(``int` `n)``{``    ``int` `fact = ``1``;``    ``for` `(``int` `i = ``2``; i <= n; i++)``        ``fact *= i;``    ``return` `fact;``}` `// Function to calculate ncr``static` `int` `ncr(``int` `n, ``int` `r)``{``    ``int` `ncr = fact(n) / (fact(r) * fact(n - r));``    ``return` `ncr;``}` `// Function to calculate``// the total possible ways``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;``}` `// Driver code``    ``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));``    ``}``}``// This Code is contributed``// by shs`

## Python3

 `# Python 3 implementation of the approach` `# Returns factorial of the number``def` `fact(n):``    ``fact ``=` `1``    ``for` `i ``in` `range``(``2``, n ``+` `1``):``        ``fact ``*``=` `i``    ``return` `fact` `# Function to calculate ncr``def` `ncr(n, r):``    ``ncr ``=` `fact(n) ``/``/` `(fact(r) ``*` `fact(n ``-` `r))``    ``return` `ncr` `# Function to calculate``# the total possible ways``def` `ways(m, w, n, k):``    ``ans ``=` `0``    ``while` `(m >``=` `k):``        ``ans ``+``=` `ncr(m, k) ``*` `ncr(w, n ``-` `k)``        ``k ``+``=` `1` `    ``return` `ans;` `# Driver code``m ``=` `7``w ``=` `6``n ``=` `5``k ``=` `3``print``(ways(m, w, n, k))` `# This code is contributed by sahishelangia`

## C#

 `// C# implementation of the approach` `class` `GFG {` `// Returns factorial``// of the number``static` `int` `fact(``int` `n)``{``    ``int` `fact = 1;``    ``for` `(``int` `i = 2; i <= n; i++)``        ``fact *= i;``    ``return` `fact;``}` `// Function to calculate ncr``static` `int` `ncr(``int` `n, ``int` `r)``{``    ``int` `ncr = fact(n) / (fact(r) * fact(n - r));``    ``return` `ncr;``}` `// Function to calculate``// the total possible ways``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;``}` `// Driver code``    ``static` `void` `Main () {``        ` `    ``int` `m, w, n, k;``    ``m = 7;``    ``w = 6;``    ``n = 5;``    ``k = 3;``    ``System.Console.WriteLine( ways(m, w, n, k));``    ``}``}``// This Code is contributed by mits`

## PHP

 `= ``\$k``)``    ``{``        ``\$ans` `+= ncr(``\$m``, ``\$k``) *``                ``ncr(``\$w``, ``\$n` `- ``\$k``);``        ``\$k` `+= 1;``    ``}` `    ``return` `\$ans``;``}` `// Driver code``\$m` `= 7;``\$w` `= 6;``\$n` `= 5;``\$k` `= 3;``echo` `ways(``\$m``, ``\$w``, ``\$n``, ``\$k``);` `// This Code is contributed``// by Mukul Singh`

## Javascript

 ``

Output:

`756`

Time Complexity: O(n)
Auxiliary Space: O(1)

Further Optimization : The above code can be optimized using faster algorithms for binomial coefficient computation.

My Personal Notes arrow_drop_up