#020 Suma de Dígitos de un Factorial

Factorial Digit Sum

n! significa n x (n - 1) x ... x 3 x 2 x 1

Por ejemplo, 10! = 10 x 9 x ... x 3 x 2 x 1 = 3628800,
y la suma de los dígitos de 10! es 3 + 6 + 2 + 8 + 8 + 0 + 0 = 27.

Encuentra la suma de los dígitos de 100!

* Factorial * BigInt * Suma de dígitos

1 ¿Que es un factorial?

El factorial de un numero n, escrito como n!, es el producto de todos los enteros positivos desde 1 hasta n.

Visualizando 5!

5 x 4 x 3 x 2 x 1 = 120

El crecimiento explosivo del factorial

n	n!	Digitos
5	120	3
10	3,628,800	7
15	1,307,674,368,000	13
20	2,432,902,008,176,640,000	19
50	3.04 x 10^64	65
100	9.33 x 10^157	158

100! tiene 158 digitos. Es un numero ENORME, pero Python lo maneja sin problemas.

Factorial vs Potencia: ¿Cual crece mas rapido?

Potencia (2^n)

2^10 = 1,024

2^20 = 1,048,576

2^100 ~ 10^30

Factorial (n!)

10! = 3,628,800

20! ~ 2.4 x 10^18

100! ~ 9.3 x 10^157

El factorial crece mucho mas rapido. Ya en n=100, el factorial tiene 158 digitos mientras que 2^100 "solo" tiene 31 digitos.

100! completo (158 digitos)

93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000

Observa los muchos ceros al final. Cada vez que multiplicamos por un multiplo de 5 y de 2, anadimos un cero. Hay 24 ceros al final de 100!

¿Por que tantos ceros al final?

Cada cero al final viene de un factor 10 = 2 x 5.

Multiplos de 5 en 1-100: 5, 10, 15, 20, 25... = 20 numeros

Multiplos de 25 (dan 5 extra): 25, 50, 75, 100 = 4 numeros

Total de factores 5: 20 + 4 = 24

Hay muchos mas factores 2 que 5, asi que el limitante son los 5. Por eso 100! termina en exactamente 24 ceros.

Ejemplo: suma de digitos de 10!

10! = 3628800

Suma = 3 + 6 + 2 + 8 + 8 + 0 + 0 = 27

Conexion con el Problema 16

Este problema es muy similar al Problema 16 (Power Digit Sum). La unica diferencia es que ahi calculabamos 2^1000 y aqui calculamos 100!

El algoritmo es identico: calcular el numero grande, convertir a string, sumar digitos. Python maneja ambos casos automaticamente con enteros de precision arbitraria.

Suma de digitos de 100!

648

Digitos en 100!

158

2 Implementacion en Python

Python tiene la funcion math.factorial() integrada, pero tambien podemos implementarlo nosotros mismos para entender mejor.

Python — Usando math.factorial

import math

# Paso 1: Calcular 100!
# math.factorial() es muy eficiente
factorial_100 = math.factorial(100)

# Paso 2: Convertir a string y sumar digitos
digit_sum = sum(int(d) for d in str(factorial_100))

print(f"100! tiene {len(str(factorial_100))} digitos")
print(f"Suma de digitos: {digit_sum}")

# Verificar con el ejemplo del problema
print(f"\nVerificacion: 10! = {math.factorial(10)}")
print(f"Suma de digitos de 10!: {sum(int(d) for d in str(math.factorial(10)))}")

// Output aparecera aqui

Python — Implementando factorial

def factorial_iterativo(n):
    """Calcula n! con un bucle."""
    resultado = 1
    for i in range(2, n + 1):
        resultado *= i
    return resultado

def factorial_recursivo(n):
    """Calcula n! recursivamente.

    La definicion matematica es:
    - 0! = 1
    - n! = n * (n-1)!
    """
    if n <= 1:
        return 1
    return n * factorial_recursivo(n - 1)

# Resolver el problema
fact_100 = factorial_iterativo(100)
digit_sum = sum(int(d) for d in str(fact_100))

print(f"Suma de digitos de 100!: {digit_sum}")

# Mostrar ambos metodos dan el mismo resultado
print(f"\n5! iterativo: {factorial_iterativo(5)}")
print(f"5! recursivo: {factorial_recursivo(5)}")

# La recursiva tiene limite de profundidad
# Para n=100, la iterativa es mas segura
print(f"\n100! iterativo: {len(str(factorial_iterativo(100)))} digitos")
# factorial_recursivo(100) funcionaria pero no es recomendable para n grandes

// Output aparecera aqui

Iterativo vs Recursivo

Iterativo (preferido)

Sin limite de profundidad
Usa memoria constante
Mas rapido en Python

Recursivo

Limite ~1000 llamadas en Python
Crea n stack frames
Elegante pero ineficiente

La solucion en una linea

import math; print(sum(int(d) for d in str(math.factorial(100))))

O sin importar:

from functools import reduce

print(sum(int(d) for d in str(reduce(lambda a,b: a*b, range(1,101)))))

Python — Usando reduce (funcional)

from functools import reduce

# reduce aplica una funcion acumulativamente
# reduce(f, [a, b, c, d]) = f(f(f(a, b), c), d)

# Para factorial: multiplicamos todos los numeros de 1 a n
factorial = lambda n: reduce(lambda acc, x: acc * x, range(1, n + 1), 1)

# Visualizar como funciona reduce para 5!
print("Como funciona reduce para 5!:")
print("range(1, 6) = [1, 2, 3, 4, 5]")
print("Paso 1: 1 * 1 = 1")
print("Paso 2: 1 * 2 = 2")
print("Paso 3: 2 * 3 = 6")
print("Paso 4: 6 * 4 = 24")
print("Paso 5: 24 * 5 = 120")

print(f"\n5! = {factorial(5)}")
print(f"100! tiene {len(str(factorial(100)))} digitos")

# Resolver el problema
digit_sum = sum(int(d) for d in str(factorial(100)))
print(f"\nSuma de digitos de 100!: {digit_sum}")

// Output aparecera aqui

Python — Explorando factoriales

import math

def digit_sum(n):
    """Suma de digitos de un numero."""
    return sum(int(d) for d in str(n))

def trailing_zeros(n):
    """Cuenta ceros al final de n!"""
    # Cada cero viene de un par (2, 5)
    # Hay mas 2s que 5s, asi que contamos los 5s
    count = 0
    power_of_5 = 5
    while power_of_5 <= n:
        count += n // power_of_5
        power_of_5 *= 5
    return count

# Tabla de factoriales
print("n     n!                    Digitos  Suma   Ceros")
print("-" * 55)

for n in [1, 5, 10, 15, 20, 25, 50, 100]:
    fact = math.factorial(n)
    fact_str = str(fact)
    if len(fact_str) > 20:
        display = fact_str[:10] + "..." + fact_str[-5:]
    else:
        display = fact_str

    print(f"{n:<5} {display:<22} {len(fact_str):<8} {digit_sum(fact):<6} {trailing_zeros(n)}")

# Dato curioso
print("\n" + "=" * 55)
print("Dato curioso: 100! termina en 24 ceros porque hay")
print("24 factores de 5 en los numeros del 1 al 100:")
print(f"  Multiplos de 5:   100/5  = {100//5}")
print(f"  Multiplos de 25:  100/25 = {100//25}")
print(f"  Multiplos de 125: 100/125 = {100//125}")
print(f"  Total: {100//5 + 100//25 + 100//125} ceros")

// Output aparecera aqui

Resumen de metodos

Metodo	Codigo	Nota
math.factorial	math.factorial(100)	Recomendado
Bucle for	resultado *= i	Educativo
Recursion	n * factorial(n-1)	Limite stack
reduce	reduce(lambda...)	Funcional

OK Factorial (n!) OK math.factorial() OK Iterativo vs Recursivo OK reduce()