Cómo Calcular Combinaciones (nCr) en C

Introducción

En este laboratorio, aprenderás a calcular combinaciones (nCr) utilizando un programa en C. El laboratorio cubre dos pasos principales: leer los valores de entrada para n y r, y luego implementar la fórmula para calcular la combinación nCr = n! / (r! * (n-r)!). Al final de este laboratorio, tendrás un programa en C funcional que puede calcular combinaciones para cualquier valor dado de n y r.

El laboratorio comienza demostrando cómo leer los valores de entrada para n y r utilizando la función scanf(). Luego, presenta la implementación de funciones para calcular el factorial y la combinación, que se utilizan para calcular el resultado final. El laboratorio proporciona el código completo e instrucciones paso a paso, lo que facilita seguirlo y aplicar los conceptos en tus propios proyectos.

Leer n y r

En este paso, aprenderás a leer los valores de entrada para n y r para calcular combinaciones en un programa en C.

Primero, crea un nuevo archivo C para tu programa de cálculo de combinaciones:

cd ~/project
nano combinations.c

Ahora, agrega el siguiente código para leer los valores de entrada:

#include <stdio.h>

int main() {
    int n, r;

    // Solicita al usuario que ingrese los valores de n y r
    printf("Ingrese el valor de n: ");
    scanf("%d", &n);

    printf("Ingrese el valor de r: ");
    scanf("%d", &r);

    // Imprime los valores ingresados para verificar la entrada
    printf("Usted ingresó n = %d y r = %d\n", n, r);

    return 0;
}

Compila y ejecuta el programa para probar la entrada:

gcc combinations.c -o combinations
./combinations

Salida de ejemplo:

Ingrese el valor de n: 5
Ingrese el valor de r: 3
Usted ingresó n = 5 y r = 3

Este código demuestra cómo:

Usar scanf() para leer entradas de números enteros del usuario
Solicitar al usuario que ingrese los valores de n y r
Imprimir los valores ingresados para confirmar la entrada correcta

El código establece los cimientos para calcular combinaciones capturando primero los valores de entrada necesarios n y r.

Calcular nCr = n!/(r!(n-r)!)

En este paso, implementarás una función para calcular el factorial y las combinaciones utilizando la fórmula nCr = n! / (r! * (n-r)!).

Abre el archivo combinations.c anterior y actualízalo con las funciones de cálculo de factorial y combinaciones:

cd ~/project
nano combinations.c

Agrega el siguiente código para implementar los cálculos de factorial y combinaciones:

#include <stdio.h>

// Función para calcular el factorial
unsigned long long factorial(int num) {
    if (num == 0 || num == 1) {
        return 1;
    }

    unsigned long long result = 1;
    for (int i = 2; i <= num; i++) {
        result *= i;
    }

    return result;
}

// Función para calcular combinaciones (nCr)
unsigned long long combinations(int n, int r) {
    // Validar la entrada
    if (r > n) {
        return 0;
    }

    // Usar la fórmula de combinaciones: nCr = n! / (r! * (n-r)!)
    unsigned long long numerador = factorial(n);
    unsigned long long denominador = factorial(r) * factorial(n - r);

    return numerador / denominador;
}

int main() {
    int n, r;

    // Solicitar al usuario que ingrese los valores de n y r
    printf("Ingrese el valor de n: ");
    scanf("%d", &n);

    printf("Ingrese el valor de r: ");
    scanf("%d", &r);

    // Calcular e imprimir la combinación
    unsigned long long resultado = combinations(n, r);

    printf("Combinación C(%d, %d) = %llu\n", n, r, resultado);

    return 0;
}

Compila y ejecuta el programa:

gcc combinations.c -o combinations
./combinations

Salida de ejemplo:

Ingrese el valor de n: 5
Ingrese el valor de r: 3
Combinación C(5, 3) = 10

Puntos clave de esta implementación:

La función factorial() calcula el factorial de un número dado.
La función combinations() implementa la fórmula de combinaciones.
Utiliza unsigned long long para manejar cálculos de factorial más grandes.
Valida la entrada para evitar combinaciones inválidas.

Imprimir el Resultado

En este paso, mejorarás el programa de cálculo de combinaciones agregando una salida más informativa y manejo de errores.

Abre el archivo combinations.c y modifica el código:

cd ~/project
nano combinations.c

Actualiza el código con una impresión de resultados mejorada y validación de entrada:

#include <stdio.h>

// Las funciones anteriores de factorial y combinaciones permanecen igual

int main() {
    int n, r;

    // Solicitar al usuario que ingrese los valores de n y r
    printf("Calculadora de Combinaciones (nCr)\n");
    printf("-----------------------------------\n");

    // Validación de entrada
    do {
        printf("Ingrese el número total de elementos (n): ");
        scanf("%d", &n);

        if (n < 0) {
            printf("Error: n debe ser un entero no negativo.\n");
        }
    } while (n < 0);

    do {
        printf("Ingrese el número de elementos a elegir (r): ");
        scanf("%d", &r);

        if (r < 0 || r > n) {
            printf("Error: r debe estar entre 0 y n.\n");
        }
    } while (r < 0 || r > n);

    // Calcular la combinación
    unsigned long long resultado = combinations(n, r);

    // Salida detallada del resultado
    printf("\nDesglose del Resultado:\n");
    printf("------------------------\n");
    printf("Elementos totales (n): %d\n", n);
    printf("Elementos a elegir (r): %d\n", r);
    printf("Combinaciones posibles (nCr): %llu\n", resultado);

    // Interpretación del resultado
    printf("\nInterpretación:\n");
    printf("----------------\n");
    printf("Hay %llu maneras de elegir %d elementos de un conjunto de %d elementos.\n",
           resultado, r, n);

    return 0;
}

Compila y ejecuta el programa:

gcc combinations.c -o combinations
./combinations

Salida de ejemplo:

Calculadora de Combinaciones (nCr)
-----------------------------------
Ingrese el número total de elementos (n): 5
Ingrese el número de elementos a elegir (r): 3

Desglose del Resultado:
------------------------
Elementos totales (n): 5
Elementos a elegir (r): 3
Combinaciones posibles (nCr): 10

Interpretación:
----------------
Hay 10 maneras de elegir 3 elementos de un conjunto de 5 elementos.

Mejoras clave:

Se agregó validación de entrada para evitar entradas inválidas.
Se mejoró la salida con un desglose detallado del resultado.
Se proporcionó una interpretación del resultado de la combinación.

Resumen

En este laboratorio, aprendiste a leer los valores de entrada para n y r, y luego a calcular las combinaciones (nCr) utilizando la fórmula nCr = n! / (r! * (n-r)!). Implementaste funciones para calcular el factorial y las combinaciones, y luego utilizaste estas funciones para calcular el resultado final. Los pasos clave fueron: 1) leer los valores de entrada para n y r, y 2) calcular las combinaciones utilizando la fórmula y la función factorial.