#017 Contando Letras en Números

Number Letter Counts

Si escribimos los números del 1 al 5 en palabras: one, two, three, four, five, usamos 3 + 3 + 5 + 4 + 4 = 19 letras en total.

Si escribimos todos los números del 1 al 1000 en palabras (inglés británico), ¿cuántas letras usamos?

Nota: No contar espacios ni guiones. Usar "and" según el inglés británico (ej: 115 = "one hundred and fifteen").

● Diccionarios ● Strings ● Descomposición sistemática

1 Descomponiendo el Problema

La clave es identificar los bloques básicos y cómo se combinan para formar cualquier número.

1-9 Unidades

one

3 letras

two

3 letras

three

5 letras

four

4 letras

five

4 letras

six

3 letras

seven

5 letras

eight

5 letras

nine

4 letras

Total: 3+3+5+4+4+3+5+5+4 = 36 letras

10-19 Los "teens" (casos especiales)

ten

3 letras

eleven

6 letras

twelve

6 letras

thirteen

8 letras

fourteen

8 letras

fifteen

7 letras

sixteen

7 letras

seventeen

9 letras

eighteen

8 letras

nineteen

8 letras

Total: 3+6+6+8+8+7+7+9+8+8 = 70 letras

20-90 Decenas (múltiplos de 10)

twenty

6 letras

thirty

6 letras

forty

5 letras

fifty

5 letras

sixty

5 letras

seventy

7 letras

eighty

6 letras

ninety

6 letras

Ojo: Es "forty" (no "fourty"). Un error común.

Patrón para Centenas (100-999)

100 = one hundred

200 = two hundred

...

101 = one hundred and one

115 = one hundred and fifteen

342 = three hundred and forty-two

Regla británica: Se usa "and" cuando hay unidades o decenas después de "hundred".
100 = "one hundred" (sin and)
101-199 = "one hundred and ..." (con and)

Caso especial: 1000

1000 = "one thousand" = 11 letras

Solo hay un número con "thousand" en nuestro rango, así que es fácil manejarlo por separado.

Ejemplos del enunciado

Número	Palabra	Letras
342	threehundredandfortytwo	23
115	onehundredandfifteen	20

Recuerda: espacios y guiones NO se cuentan.

Letras del 1 al 1000

21,124

Números escritos

1000

2 Implementación con Diccionarios

Usaremos diccionarios para mapear números a sus palabras, construyendo desde las piezas básicas.

¿Por qué Diccionarios?

Los diccionarios son perfectos para este problema porque:

Mapeo directo: número → palabra
Lookup O(1): acceso instantáneo
Legibilidad: el código se lee como una tabla

# Ejemplo de estructura

units = {1: "one", 2: "two", 3: "three", ...}

tens = {20: "twenty", 30: "thirty", ...}

Python — Solución completa

# Diccionarios base
units = {
    0: "", 1: "one", 2: "two", 3: "three", 4: "four",
    5: "five", 6: "six", 7: "seven", 8: "eight", 9: "nine"
}

teens = {
    10: "ten", 11: "eleven", 12: "twelve", 13: "thirteen",
    14: "fourteen", 15: "fifteen", 16: "sixteen", 17: "seventeen",
    18: "eighteen", 19: "nineteen"
}

tens = {
    20: "twenty", 30: "thirty", 40: "forty", 50: "fifty",
    60: "sixty", 70: "seventy", 80: "eighty", 90: "ninety"
}

def number_to_words(n):
    """Convierte un número (1-1000) a su forma escrita en inglés."""
    if n == 1000:
        return "onethousand"

    if n == 0:
        return ""

    result = ""

    # Centenas (100-999)
    if n >= 100:
        hundreds_digit = n // 100
        result += units[hundreds_digit] + "hundred"
        n = n % 100  # Quedan las decenas y unidades

        # Añadir "and" si hay algo después
        if n > 0:
            result += "and"

    # Teens (10-19) - caso especial
    if 10 <= n <= 19:
        result += teens[n]
        return result

    # Decenas (20, 30, ..., 90)
    if n >= 20:
        tens_digit = (n // 10) * 10
        result += tens[tens_digit]
        n = n % 10

    # Unidades (1-9)
    if n > 0:
        result += units[n]

    return result

# Contar letras totales del 1 al 1000
total_letters = sum(len(number_to_words(n)) for n in range(1, 1001))

print(f"Total de letras del 1 al 1000: {total_letters}")

# Verificar con los ejemplos del problema
print("\nVerificaciones:")
print(f"342 = '{number_to_words(342)}' ({len(number_to_words(342))} letras)")
print(f"115 = '{number_to_words(115)}' ({len(number_to_words(115))} letras)")

# Mostrar algunos ejemplos
print("\nEjemplos:")
for n in [1, 15, 20, 21, 100, 101, 999, 1000]:
    word = number_to_words(n)
    print(f"  {n:>4} = {word} ({len(word)} letras)")

// Output aparecerá aquí

Descomponiendo un número: 342

342 // 100 = 3 → "three" + "hundred"

342 % 100 = 42 → queda 42, añadimos "and"

42 // 10 * 10 = 40 → "forty"

42 % 10 = 2 → "two"

Resultado: "threehundredandfortytwo" = 23 letras ✓

Python — Versión optimizada (precalculando 1-99)

"""
Versión optimizada: en vez de construir strings,
podemos contar letras directamente.

Observación: las letras de 1-99 se repiten en cada centena.
"""

# Longitudes de las palabras base
units_len = [0, 3, 3, 5, 4, 4, 3, 5, 5, 4]  # "", one, two, three...
teens_len = [3, 6, 6, 8, 8, 7, 7, 9, 8, 8]  # ten, eleven, twelve...
tens_len = [0, 0, 6, 6, 5, 5, 5, 7, 6, 6]   # "", "", twenty, thirty...

def count_letters_1_to_99():
    """Cuenta letras del 1 al 99."""
    total = 0

    # 1-9
    total += sum(units_len[1:10])

    # 10-19
    total += sum(teens_len)

    # 20-99
    for d in range(2, 10):  # decenas: 20, 30, ..., 90
        # El múltiplo de 10 solo (20, 30, ...)
        total += tens_len[d]
        # 21-29, 31-39, etc. (9 números cada uno)
        for u in range(1, 10):
            total += tens_len[d] + units_len[u]

    return total

def count_letters_1_to_999():
    """Cuenta letras del 1 al 999."""
    letters_1_99 = count_letters_1_to_99()

    total = letters_1_99  # 1-99

    # 100-999: hay 9 centenas (100-199, 200-299, ..., 900-999)
    hundred_len = 7  # "hundred"
    and_len = 3      # "and"

    for h in range(1, 10):  # centenas: 1xx, 2xx, ..., 9xx
        # X00: "X hundred"
        total += units_len[h] + hundred_len

        # X01-X99: "X hundred and ..." (99 números)
        # = 99 × (X + hundred + and) + letras de 1-99
        total += 99 * (units_len[h] + hundred_len + and_len)
        total += letters_1_99

    return total

def count_letters_1_to_1000():
    """Cuenta letras del 1 al 1000."""
    return count_letters_1_to_999() + 11  # "onethousand" = 11 letras

result = count_letters_1_to_1000()
print(f"Total de letras del 1 al 1000: {result}")

# Desglose
print(f"\nDesglose:")
print(f"  1-99:   {count_letters_1_to_99()} letras")
print(f"  1-999:  {count_letters_1_to_999()} letras")
print(f"  1000:   11 letras")
print(f"  Total:  {result} letras")

// Output aparecerá aquí

Errores Comunes

"fourty" en vez de "forty" (sin u)
Olvidar el "and" después de hundred
Poner "and" en números redondos como 100, 200 (no llevan)
Contar espacios o guiones (no deben contarse)
Olvidar el 1000 al final

✓ Diccionarios como tablas de lookup ✓ Descomposición de problemas ✓ División entera y módulo

3 Diccionarios: La Estructura de Datos Más Útil

Los diccionarios son probablemente la estructura de datos más usada en Python. Entenderlos bien te ahorrará horas de código y dolores de cabeza.

Piensa en una Agenda de Teléfonos

Agenda física (lista ordenada)

Ana ......... 555-0101

Carlos ...... 555-0202

Diana ....... 555-0303

Eduardo ..... 555-0404

... 500 nombres más ...

Zoe ......... 555-9999

Para encontrar a "María", revisas uno por uno hasta la M

Diccionario Python

# Acceso INSTANTÁNEO

agenda = {

"Ana": "555-0101",

"Carlos": "555-0202",

"María": "555-0505",

...

}

agenda["María"] # → "555-0505"

Encuentra a "María" instantáneamente, sin importar cuántos nombres haya

¿Cómo es posible que sea instantáneo?

Los diccionarios usan algo llamado "tabla hash". Suena complicado, pero la idea es simple:

Imagina un armario con 1000 cajones numerados

...

Cuando guardas "María" → "555-0505", Python calcula un número mágico (hash) de "María"

El hash de "María" podría ser, digamos, 347. Python guarda el valor en el cajón 347.

Cuando preguntas por agenda["María"], Python calcula el hash otra vez (347), va directo al cajón 347, y te da el valor.

¡No busca! Sabe exactamente dónde está. Por eso es O(1) - tiempo constante, sin importar si hay 10 o 10 millones de elementos.

Tres formas de convertir 3 → "three"

Opción 1: Cadena de if-elif O(n) comparaciones

def numero_a_palabra(n):

if n == 1: return "one"

elif n == 2: return "two"

elif n == 3: return "three" # ← llega aquí después de 3 comparaciones

elif n == 4: return "four"

... # 9 ifs para 9 números

Problema: Para encontrar "nine" hace 9 comparaciones. Imagina con 1000 números.

Opción 2: Lista (array) O(1) pero limitado

palabras = ["", "one", "two", "three", "four", ...]

palabras[3] # → "three" (instantáneo)

Problema: Solo funciona si las claves son números consecutivos (0, 1, 2, 3...). ¿Y si quiero mapear 20 → "twenty"? Desperdiciaría 19 posiciones vacías.

Opción 3: Diccionario O(1) + flexible

palabras = {1: "one", 2: "two", 3: "three", 20: "twenty", 90: "ninety"}

palabras[3] # → "three" (instantáneo)

palabras[90] # → "ninety" (también instantáneo)

Mejor de ambos mundos: Rápido como lista, flexible como if-elif.

Python — Comparando las 3 opciones

import time

# === OPCIÓN 1: if-elif ===
def unidad_if(n):
    if n == 1: return "one"
    elif n == 2: return "two"
    elif n == 3: return "three"
    elif n == 4: return "four"
    elif n == 5: return "five"
    elif n == 6: return "six"
    elif n == 7: return "seven"
    elif n == 8: return "eight"
    elif n == 9: return "nine"
    return ""

# === OPCIÓN 2: Lista ===
unidades_lista = ["", "one", "two", "three", "four",
                  "five", "six", "seven", "eight", "nine"]

def unidad_lista(n):
    return unidades_lista[n]

# === OPCIÓN 3: Diccionario ===
unidades_dict = {
    0: "", 1: "one", 2: "two", 3: "three", 4: "four",
    5: "five", 6: "six", 7: "seven", 8: "eight", 9: "nine"
}

def unidad_dict(n):
    return unidades_dict[n]

# Verificar que las 3 dan el mismo resultado
print("¿Dan el mismo resultado?")
for n in range(1, 10):
    assert unidad_if(n) == unidad_lista(n) == unidad_dict(n)
print("✓ Sí, las 3 opciones son equivalentes\n")

# Medir rendimiento (1 millón de lookups)
REPS = 1_000_000

t1 = time.time()
for _ in range(REPS):
    unidad_if(9)  # Peor caso: última comparación
t_if = time.time() - t1

t2 = time.time()
for _ in range(REPS):
    unidad_lista(9)
t_lista = time.time() - t2

t3 = time.time()
for _ in range(REPS):
    unidad_dict(9)
t_dict = time.time() - t3

print(f"1 millón de lookups para n=9:")
print(f"  if-elif:     {t_if:.3f}s")
print(f"  lista:       {t_lista:.3f}s")
print(f"  diccionario: {t_dict:.3f}s")
print(f"\nEl diccionario es igual de rápido que la lista,")
print(f"pero mucho más flexible (las claves no tienen que ser 0,1,2,3...)")

// Output aparecerá aquí

¿Cuándo usar cada estructura?

Estructura	Usa cuando...	Ejemplo
if-elif	Pocas opciones (2-4) con lógica diferente en cada rama	if edad < 18: ... elif edad < 65: ...
Lista	Claves son índices consecutivos (0, 1, 2...)	dias = ["Lun", "Mar", "Mie"...]
Diccionario	Claves son arbitrarias (números salteados, strings, etc.)	capitales = {"España": "Madrid", ...}

¿Qué puede ser una clave de diccionario?

✓ Puede ser clave:

Números: 1, 3.14
Strings: "hola"
Tuplas: (1, 2)
Booleanos: True, False

✗ NO puede ser clave:

Listas: [1, 2]
Diccionarios: {"a": 1}
Sets: {1, 2}

(Solo tipos "inmutables" pueden ser claves)

Python — Operaciones comunes con diccionarios

# Crear un diccionario
edades = {"Ana": 25, "Carlos": 30, "Diana": 28}

# Acceder a un valor
print(f"Edad de Ana: {edades['Ana']}")

# Añadir o modificar
edades["Eduardo"] = 35  # Añade si no existe
edades["Ana"] = 26      # Modifica si ya existe
print(f"Después de cambios: {edades}")

# Verificar si existe una clave
if "Carlos" in edades:
    print("Carlos está en el diccionario")

# Acceso seguro con .get() (no da error si no existe)
print(f"Edad de Zoe: {edades.get('Zoe', 'No encontrado')}")

# Iterar sobre claves y valores
print("\nTodas las edades:")
for nombre, edad in edades.items():
    print(f"  {nombre}: {edad} años")

# Número de elementos
print(f"\nTotal de personas: {len(edades)}")

# Eliminar una clave
del edades["Diana"]
print(f"Después de eliminar Diana: {edades}")

// Output aparecerá aquí

Resumen: ¿Por qué diccionarios?

⚡

Rápido

O(1) para buscar, añadir, eliminar

🔑

Flexible

Cualquier clave inmutable

📖

Legible

El código se autodocumenta

✓ Hash tables (conceptual) ✓ O(1) vs O(n) lookup ✓ dict vs list vs if-elif ✓ Operaciones de diccionario