Función recursiva: Factorial

Parte de la sección Lógica y Flujo del Journey de Dart de Coddy — lección 49 de 65.

El factorial de un número es una operación matemática clásica que es perfecta para demostrar la recursividad. El factorial de un entero positivo n (escrito como n!) es el producto de todos los enteros positivos desde 1 hasta n. Por ejemplo, 5! = 5 × 4 × 3 × 2 × 1 = 120.

Lo que hace que el factorial sea ideal para la recursividad es que se descompone naturalmente en problemas más pequeños e idénticos. Para calcular 5!, puedes pensarlo como 5 × 4!. Y 4! es simplemente 4 × 3!, y así sucesivamente. Este patrón continúa hasta llegar a 1!, que es igual a 1.

int factorial(int n) {
  if (n <= 1) {
    return 1; // Caso base
  }
  
  return n * factorial(n - 1); // Paso recursivo
}

El caso base detiene la recursión cuando n <= 1, devolviendo 1. El paso recursivo multiplica el número actual por el factorial del siguiente número más pequeño. Cuando llamas a factorial(5), devuelve 5 * factorial(4), que devuelve 5 * 4 * factorial(3), y así sucesivamente hasta que alcanza el caso base.

Este enfoque demuestra cómo la recursividad resuelve problemas de manera elegante al reducirlos a versiones más simples del mismo problema, haciendo que los cálculos complejos se sientan naturales e intuitivos.

Desafío

Fácil

Crea un programa que calcule factoriales para múltiples números utilizando recursividad. Tu programa demostrará la función factorial recursiva procesando una lista de números y calculando sus factoriales.

Lee una entrada de cadena que contenga números separados por comas (por ejemplo, "3,5,0,7")
Divide la cadena de entrada en números individuales y convierte cada uno a un entero
Crea una función recursiva llamada factorial que reciba un parámetro entero n
La función factorial debe implementar la siguiente lógica:

Caso base: Si n es menor o igual a 1, devuelve 1
Paso recursivo: Devuelve n multiplicado por factorial(n - 1)

Para cada número en la lista de entrada, calcula su factorial utilizando tu función recursiva
Muestra los resultados indicando cada número y su factorial correspondiente
Calcula y muestra la suma de todos los resultados factoriales

Por ejemplo, si la entrada es "4,3,2", tu programa debe mostrar:

Factorial Calculator
====================
Processing numbers: [4, 3, 2]
====================
Factorial Results:
4! = 24
3! = 6
2! = 2
====================
Sum of all factorials: 32
Calculation completed successfully

Si la entrada es "5,0,1", tu programa debe mostrar:

Factorial Calculator
====================
Processing numbers: [5, 0, 1]
====================
Factorial Results:
5! = 120
0! = 1
1! = 1
====================
Sum of all factorials: 122
Calculation completed successfully

Si la entrada es "6", tu programa debe mostrar:

Factorial Calculator
====================
Processing numbers: [6]
====================
Factorial Results:
6! = 720
====================
Sum of all factorials: 720
Calculation completed successfully

Tu programa debe implementar la función recursiva factorial que se llama a sí misma con valores decrementados hasta que alcanza el caso base. La función debe demostrar cómo la recursividad descompone el cálculo del factorial en subproblemas idénticos más pequeños. Utiliza la interpolación de cadenas para formatear los resultados factoriales como "$n! = $result". Recuerda que 0! es igual a 1 por definición matemática, lo cual tu caso base debe manejar correctamente.

Hoja de referencia

El factorial de un número entero positivo n (escrito como n!) es el producto de todos los números enteros positivos desde 1 hasta n. Por ejemplo, 5! = 5 × 4 × 3 × 2 × 1 = 120.

El factorial es ideal para la recursividad porque se descompone en problemas más pequeños e idénticos: 5! = 5 × 4!, y 4! = 4 × 3!, continuando hasta llegar a 1! = 1.

int factorial(int n) {
  if (n <= 1) {
    return 1; // Caso base
  }
  
  return n * factorial(n - 1); // Paso recursivo
}

El caso base detiene la recursividad cuando n <= 1, devolviendo 1. El paso recursivo multiplica el número actual por el factorial del siguiente número más pequeño.

Pruébalo tú mismo

import 'dart:io';

// TODO: Crea tu función factorial recursiva aquí

void main() {
  // Leer la cadena de entrada que contiene números separados por comas
  String? input = stdin.readLineSync();
  
  // Dividir la entrada y convertir a enteros
  List<int> numbers = input!.split(',').map((str) => int.parse(str.trim())).toList();
  
  // TODO: Escribe tu código a continuación para:
  // 1. Procesar cada número usando tu función factorial
  // 2. Calcular la suma de todos los factoriales
  // 3. Mostrar los resultados en el formato requerido
  
  print("Factorial Calculator");
  print("====================");
  print("Processing numbers: $numbers");
  print("====================");
  print("Factorial Results:");
  
  // TODO: Calcular y mostrar los resultados factoriales aquí
  
  print("====================");
  // TODO: Mostrar la suma de todos los factoriales
  print("Calculation completed successfully");
}