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 longpara 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.
