#016 Suma de Dígitos de una Potencia

Power Digit Sum

2¹⁵ = 32768 y la suma de sus dígitos es 3 + 2 + 7 + 6 + 8 = 26.

¿Cuál es la suma de los dígitos de 2¹⁰⁰⁰?

● BigInt ● Manipulación de dígitos ● Potencias

1 ¿Qué tan grande es 2¹⁰⁰⁰?

Empecemos por entender la magnitud del número que estamos manejando. Las potencias de 2 crecen exponencialmente.

El crecimiento exponencial:

2¹ = 2

2² = 4

2³ = 8

2⁴ = 16

2⁵ = 32

2¹⁰ = 1,024

2²⁰ = 1,048,576

2³⁰ ≈ 1 billón

2⁶⁴ ≈ 1.8×10¹⁹

2¹⁰⁰⁰ = ???

2¹⁰⁰⁰ tiene 302 dígitos

Para ponerlo en perspectiva: hay aproximadamente 10⁸⁰ átomos en el universo observable. 2¹⁰⁰⁰ ≈ 10³⁰¹ es un número astronómicamente mayor.

Ejemplo: suma de dígitos de 2¹⁵

2¹⁵ = 32768

Suma = 3 + 2 + 7 + 6 + 8 = 26

El Problema: Overflow

En la mayoría de lenguajes, los enteros tienen un tamaño fijo (32 o 64 bits). Un int64 solo puede almacenar hasta 2⁶³ - 1 ≈ 9.2×10¹⁸.

✗ C / C++

long long máximo: 2⁶³
2¹⁰⁰⁰ → overflow

✗ Java

long máximo: 2⁶³
Necesita BigInteger

✗ JavaScript

Number: solo 53 bits precisos
Necesita BigInt

✓ Python

Enteros de precisión arbitraria
2**1000 funciona directamente

El Algoritmo

Calcular 2¹⁰⁰⁰ (Python lo hace automáticamente con precisión infinita)
Convertir el número a string para acceder a cada dígito
Sumar los dígitos (convertidos de vuelta a int)

Suma de dígitos de 2¹⁰⁰⁰

1366

Dígitos en 2¹⁰⁰⁰

302

2 Implementación en Python

En Python, este problema es casi trivial gracias a los enteros de precisión arbitraria. Pero entendamos exactamente qué está pasando.

Python — Solución directa

# Paso 1: Calcular 2^1000
# Python maneja enteros de tamaño arbitrario automáticamente
power = 2 ** 1000

# Paso 2: Convertir a string para acceder a cada dígito
digits_str = str(power)

# Paso 3: Sumar los dígitos
# - Iteramos sobre cada carácter del string
# - Lo convertimos a int
# - Sumamos todo
digit_sum = sum(int(d) for d in digits_str)

print(f"2^1000 tiene {len(digits_str)} dígitos")
print(f"Suma de dígitos: {digit_sum}")

# Verificar con el ejemplo del problema
print(f"\nVerificación: 2^15 = {2**15}")
print(f"Suma de dígitos de 2^15: {sum(int(d) for d in str(2**15))}")

// Output aparecerá aquí

Desglose del Generator Expression

sum(int(d) for d in str(2**1000))

2**1000 → calcula la potencia (Python BigInt)

str(...) → convierte a string "107150860..."

for d in ... → itera sobre cada carácter: "1", "0", "7", ...

int(d) → convierte cada carácter a entero: 1, 0, 7, ...

sum(...) → suma todos los valores generados

¿Por qué Generator y no Lista?

Observa la diferencia:

# Lista (crea 302 elementos en memoria)

sum([int(d) for d in str(2**1000)])

# Generator (genera uno a uno)

sum(int(d) for d in str(2**1000))

Para 302 dígitos la diferencia es mínima, pero es un buen hábito usar generators cuando no necesitas la lista completa.

Python — Con bucle explícito

def power_digit_sum(base, exponent):
    """
    Calcula la suma de dígitos de base^exponent.

    Esta versión usa un bucle explícito para mayor claridad.
    """
    # Calcular la potencia
    number = base ** exponent

    # Sumar dígitos uno por uno
    total = 0
    for digit_char in str(number):
        digit_value = int(digit_char)
        total += digit_value

    return total

# Resolver el problema
result = power_digit_sum(2, 1000)
print(f"Suma de dígitos de 2^1000: {result}")

# Probar con otros valores
print("\nOtras potencias de 2:")
for exp in [10, 15, 100, 500]:
    print(f"  2^{exp}: suma = {power_digit_sum(2, exp)}")

// Output aparecerá aquí

Python — Sin convertir a string (matemático)

def digit_sum_math(n):
    """
    Suma de dígitos usando operaciones matemáticas.

    En vez de convertir a string, extraemos dígitos con:
    - n % 10  → último dígito
    - n // 10 → elimina el último dígito
    """
    total = 0

    while n > 0:
        last_digit = n % 10    # Extraer último dígito
        total += last_digit    # Sumarlo
        n = n // 10            # Eliminar último dígito

    return total

# Resolver el problema
power = 2 ** 1000
result = digit_sum_math(power)
print(f"Suma de dígitos de 2^1000: {result}")

# Demostrar cómo funciona con un número pequeño
print("\n--- Demostración con 32768 ---")
n = 32768
while n > 0:
    print(f"n = {n:>5}, último dígito = {n % 10}")
    n = n // 10

// Output aparecerá aquí

Comparación de Métodos

Método	Legibilidad	Rendimiento
sum(int(d) for d in str(n))	Excelente	Bueno
Bucle con for	Excelente	Bueno
n % 10, n // 10	Medio	Mejor

Para este problema, cualquier método es suficientemente rápido. Prefiere el que te resulte más claro.

¿Cómo maneja Python números tan grandes?

Python usa una representación interna llamada "arbitrary-precision integers":

Almacena el número como un array de "dígitos" en base 2³⁰
Cada "dígito" cabe en un entero de 32 bits
Para 2¹⁰⁰⁰ necesita ~34 de estos "dígitos"
Las operaciones (suma, multiplicación) trabajan dígito por dígito

Esto es más lento que enteros nativos, pero permite manejar números de cualquier tamaño.

✓ Enteros de precisión arbitraria ✓ Generator expressions ✓ Extracción de dígitos (str vs %10)

Power Digit Sum

1 ¿Qué tan grande es 21000?

El crecimiento exponencial:

21000 tiene 302 dígitos

Ejemplo: suma de dígitos de 215

El Problema: Overflow

El Algoritmo

2 Implementación en Python

Desglose del Generator Expression

¿Por qué Generator y no Lista?

Comparación de Métodos

¿Cómo maneja Python números tan grandes?

1 ¿Qué tan grande es 2¹⁰⁰⁰?

2¹⁰⁰⁰ tiene 302 dígitos

Ejemplo: suma de dígitos de 2¹⁵