Formas totales de seleccionar un grupo de X hombres de N hombres con o sin incluir a un hombre en particular

Dados dos enteros X y N . La tarea es encontrar el número total de formas de seleccionar X hombres de un grupo de N hombres con o sin incluir a un hombre en particular.
Ejemplos: 
 

Entrada: N = 3 X = 2 
Salida: 3 
Incluyendo un hombre digamos M1, las formas pueden ser (M1, M2) y (M1, M3). 
Excluyendo a un hombre, digamos M1, la única forma es (M2, M3). 
Total vías = 2 + 1 = 3.
Entrada: N = 5 X = 3 
Salida: 10 
 

Enfoque: El número total de formas de elegir X hombres de N hombres es ^N C _X 
 

• Incluyendo un hombre en particular: Podemos elegir (X – 1) hombres de (N – 1) en ^{N – 1} C _{X – 1} .
• Excluyendo a un hombre en particular: Podemos elegir X hombres de (N – 1) en ^{N – 1} C _X

A continuación se muestra la implementación del enfoque anterior: 
 

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to return the value of nCr
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 count of ways
int total_ways(int N, int X)
{
    return (nCr(N - 1, X - 1) + nCr(N - 1, X));
}
 
// Driver code
int main()
{
    int N = 5, X = 3;
 
    cout << total_ways(N, X);
 
    return 0;
}

// Java implementation of the approach
import java.io.*;
 
class GFG
{
     
// Function to return the value of nCr
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 count of ways
static int total_ways(int N, int X)
{
    return (nCr(N - 1, X - 1) + nCr(N - 1, X));
}
 
// Driver code
public static void main (String[] args)
{
    int N = 5, X = 3;
     
    System.out.println (total_ways(N, X));
}
}
 
// This code is contributed by Sachin

# Python3 implementation of the approach
 
# Function to return the value of nCr
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 count of ways
def total_ways(N, X) :
 
    return (nCr(N - 1, X - 1) + nCr(N - 1, X));
 
# Driver code
if __name__ == "__main__" :
 
    N = 5; X = 3;
 
    print(total_ways(N, X));
 
# This code is contributed by AnkitRai01

// C# implementation of the approach
using System;
     
class GFG
{
     
// Function to return the value of nCr
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 count of ways
static int total_ways(int N, int X)
{
    return (nCr(N - 1, X - 1) + nCr(N - 1, X));
}
 
// Driver code
public static void Main (String[] args)
{
    int N = 5, X = 3;
     
    Console.WriteLine(total_ways(N, X));
}
}
     
// This code is contributed by 29AjayKumar

<script>
    // Javascript implementation of the approach
     
    // Function to return the value of nCr
    function nCr(n, r)
    {
       
        // Initialize the answer
        let ans = 1;
       
        for (let 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 count of ways
     
    function total_ways(N, X)
    {
        return (nCr(N - 1, X - 1) + nCr(N - 1, X));
    }
     
    let N = 5, X = 3;
   
    document.write(total_ways(N, X));
     
</script>

10

Complejidad del tiempo: O(X)

Espacio Auxiliar: O(1)