# 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:**

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the **Essential Maths for CP Course** at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**

Input:m = 2, w = 2, n = 3, k = 1Output: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 w2Input:m = 7, w = 6, n = 5, k = 3Output:756Input:m = 5, w = 6, n = 6, k = 3Output: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 <bits/stdc++.h>` `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

`<?php` `// PHP implementation of the approach` `// Returns factorial of the number` `function` `fact(` `$n` `)` `{` ` ` `$fact` `= 1;` ` ` `for` `(` `$i` `= 2; ` `$i` `<= ` `$n` `; ` `$i` `++)` ` ` `$fact` `*= ` `$i` `;` ` ` `return` `$fact` `;` `}` `// Function to calculate ncr` `function` `ncr(` `$n` `, ` `$r` `)` `{` ` ` `$ncr` `= (int)(fact(` `$n` `) / (fact(` `$r` `) *` ` ` `fact(` `$n` `- ` `$r` `)));` ` ` `return` `$ncr` `;` `}` `// Function to calculate the total` `// possible ways` `function` `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;` `echo` `ways(` `$m` `, ` `$w` `, ` `$n` `, ` `$k` `);` `// This Code is contributed` `// by Mukul Singh` |

## Javascript

`<script>` `// javascript implementation of the approach` `// Returns factorial` `// of the number` `function` `fact(n)` `{` ` ` `var` `fact = 1;` ` ` `for` `(i = 2; i <= n; i++)` ` ` `fact *= i;` ` ` `return` `fact;` `}` `// Function to calculate ncr` `function` `ncr(n , r)` `{` ` ` `var` `ncr = fact(n) / (fact(r) * fact(n - r));` ` ` `return` `parseInt(ncr);` `}` `// Function to calculate` `// the total possible ways` `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);` `}` `// Driver code` `var` `m, w, n, k;` `m = 7;` `w = 6;` `n = 5;` `k = 3;` `document.write( ways(m, w, n, k));` `// This code is contributed by 29AjayKumar.` `</script>` |

**Output:**

756

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