From ddae87fb5fa85f265d7bc30dad7ba0beb0fc3b17 Mon Sep 17 00:00:00 2001 From: Alejandro Piad Morffis Date: Tue, 17 Nov 2026 13:15:16 -0500 Subject: [PATCH 1/2] docs(conferences): animated HTML deck for 2026 lecture 10, divide and conquer Co-Authored-By: Claude Opus 5.5 --- .../10-divide-y-venceras/presentacion.html | 1519 +++++++++++++++++ 1 file changed, 1519 insertions(+) create mode 100644 conferences/2026/10-divide-y-venceras/presentacion.html diff --git a/conferences/2026/10-divide-y-venceras/presentacion.html b/conferences/2026/10-divide-y-venceras/presentacion.html new file mode 100644 index 0000000..d9b6c1e --- /dev/null +++ b/conferences/2026/10-divide-y-venceras/presentacion.html @@ -0,0 +1,1519 @@ + + + + + +Conferencia 10: divide y vencerás + + + +
+ + +
+
Programación · MatCom · Conferencia 10 · 18 de noviembre de 2026
+

Partir, resolver, combinar

+

Proyecto de hoy: el millón de números que la conferencia 8 no pudo ordenar. Dos algoritmos nuevos, escritos en Python sin trucos, que lo ordenan en segundos.

+
+
+ + +
+
Dónde estamos
+

La 8 dejó una cuenta, la 9 una herramienta

+

La conferencia 8 terminó viendo que la selección, la inserción y la burbuja multiplican su trabajo por cuatro cada vez que la lista se duplica. La 9 nos dio la función que se llama a sí misma dos veces. Hoy juntamos las dos cosas.

+
+
7
Examen
el primer tema
+
8
Búsqueda, ordenación y costo
todas las palabras ordenadas, a mano
+
9
Recursión
las Torres de Hanói
+
10
Divide y vencerás
el millón de números
+ +
12
Evaluación
un problema de divide y vencerás
+
+
+ + +
+
El plan de la hora
+

De dos montones al millón

+ + + + + 1 · MEZCLAR + dos montones + cada elemento, una vez + + + 2 · POR MEZCLA + n log n + contado con el árbol + + + 3 · RÁPIDA + el pivote + y la lista que la rompe + + + 4 · EL RELOJ + contra la 8 + y contra sorted + + + + + + + un millón de números, en segundos + + +

Las partes 2 y 3 son dos maneras de seguir el mismo esquema, divide y vencerás: una trabaja al combinar y la otra al partir.

+
+ +
+
El proyecto
+

Diez horas contra un tercio de segundo

+
+
+
    +
  • En la conferencia 8, la selección ordenó 4000 números en 0,564 s.
  • +
  • Un millón es 4000 × 250. Si duplicar n multiplica por 4, multiplicar n por 250 multiplica el tiempo por 250² = 62 500.
  • +
  • 0,564 s × 62 500 ≈ 35 000 s: casi diez horas.
  • +
+

sorted ordena ese millón en 0,37 s. No es un n² escrito en un lenguaje más rápido: es otro algoritmo.

+
+
+
+
Selección, con un millón
+
Unos 500 000 millones de comparaciones: n(n − 1)/2. La estimación de diez horas sale del reloj de la conferencia 8.
+
+
+
sorted, con un millón
+
0,37 s, medido en este capítulo del libro. Al final de la hora escribimos dos de su familia y los ponemos al lado.
+
+
+
+
+ + +
+
Parte 1
+

Mezclar dos listas ordenadas

+

La pieza que no es recursiva. Todo lo demás se apoya en ella.

+
+ +
+
Dos montones de exámenes
+

El menor de todos está arriba de un montón

+
+
+
def mezclar(a, b):
+    resultado = []
+    i, j = 0, 0
+    while i < len(a) and j < len(b):
+        if a[i] <= b[j]:
+            resultado.append(a[i])
+            i += 1
+        else:
+            resultado.append(b[j])
+            j += 1
+    resultado.extend(a[i:])
+    resultado.extend(b[j:])
+    return resultado
+

Debajo del de arriba, todos son mayores. Por eso basta comparar los dos de arriba. Cuando un montón se acaba, el otro va entero al final.

+
+
+
+
de ade blos dos de arriba
+
+
+
+ +
+
Cuánto cuesta
+

Cada elemento se mira una vez

+
+
+
Las vueltas
+
Cada vuelta del while pone un elemento en resultado. Hay como mucho len(a) + len(b) vueltas.
+
+
+
Sin ciclo dentro de otro
+
La selección vuelve a recorrer lo que queda en cada vuelta. La mezcla coloca y no vuelve a tocar. Mezclar cuesta tanto como la cantidad de elementos.
+
+
+
El <=
+
Con dos iguales arriba, se toma primero el de a. Los iguales conservan su orden: es la estabilidad de la conferencia 8.
+
+
+

En la animación anterior, el escenario con iguales lo muestra: los 3 de a salen antes que el 3 de b.

+
+ +
+ En vivo · archivo mezcla.py +

Dos montones, un solo ciclo

+
+
+
def mezclar(a, b):
+    resultado = []
+    i, j = 0, 0                 # el de arriba de cada montón
+    while i < len(a) and j < len(b):
+        if a[i] <= b[j]:
+            resultado.append(a[i])
+            i += 1
+        else:
+            resultado.append(b[j])
+            j += 1
+    resultado.extend(a[i:])     # lo que quede de a
+    resultado.extend(b[j:])     # o lo que quede de b
+    return resultado
+
+
+print(mezclar([2, 5, 8, 9], [1, 3, 4, 10, 12]))
+ +
+
+
    +
  1. Antes de escribir: con dos montones boca arriba, ¿dónde puede estar el menor de todos? Arriba de uno de los dos.
  2. +
  3. Escribe mezclar con el aula. Dos índices, uno por montón.
  4. +
  5. ¿Cuántas vueltas da el while en el ejemplo? Siete: cuando b llega al 10, a ya se acabó.
  6. +
  7. ¿Y con mezclar([], [3, 4])? Ninguna vuelta: el extend copia b entera.
  8. +
+
+
+
+ + +
+
Parte 2
+

Ordenación por mezcla

+

Si sabes mezclar, ordenar es partir a la mitad, ordenar cada mitad y mezclar.

+
+ +
+
La recursión de la conferencia 9
+

Ordenar cada mitad es el mismo problema

+
+
+
def ordenar_mezcla(lista):
+    if len(lista) <= 1:
+        return list(lista)
+    medio = len(lista) // 2
+    izquierda = ordenar_mezcla(lista[:medio])
+    derecha = ordenar_mezcla(lista[medio:])
+    return mezclar(izquierda, derecha)
+
    +
  • Caso base: cero o un elemento ya están ordenados.
  • +
  • Devuelve una lista nueva, como sorted. Por eso list(lista): una copia, no la misma lista con dos nombres (conferencia 4).
  • +
+
+
+
+

La animación mezcla en el mismo lugar para que se vea; el código construye listas nuevas. Lo apagado está fuera de la llamada actual.

+
+
+
+ +
+
El árbol de llamadas
+

Bajando parte, subiendo mezcla

+
+
+
    +
  • Bajando, cada llamada parte su lista a la mitad, hasta listas de un elemento.
  • +
  • Subiendo, cada nodo pasa a mostrar lo que devuelve: la mezcla de sus dos hijos.
  • +
  • A la derecha, cuántos elementos se mezclan en cada nivel.
  • +
+

¿Cuánto suma cada nivel?

+
+
+
+
+ +
+
Por qué es tan rápida
+

n por nivel, log₂ n niveles

+
+
+
+
Cada nivel mezcla n
+
Arriba, dos listas de 4 en una de 8. Abajo, cuatro mezclas de listas de 1. Los pedazos se achican, pero hay más: la suma es siempre la lista entera.
+
+
+
Hay log₂ n niveles
+
¿Cuántas veces se parte n a la mitad hasta llegar a 1? La pregunta de la búsqueda binaria: log₂ n. Con 8, tres niveles de mezclas.
+
+

Total: n log₂ n. Con un millón, n por 20, no n por un millón.

+
+
+
+

Comparaciones contadas en mezclar, con listas al azar. La mezcla hace algo menos que n log₂ n porque, cuando un montón se acaba, el otro se copia sin comparar.

+
+
+
+ +
+ En vivo · archivo mezcla.py, debajo de mezclar +

Probarla contra algo que sabemos que está bien

+
+
+
def ordenar_mezcla(lista):
+    if len(lista) <= 1:
+        return list(lista)
+    medio = len(lista) // 2
+    izquierda = ordenar_mezcla(lista[:medio])
+    derecha = ordenar_mezcla(lista[medio:])
+    return mezclar(izquierda, derecha)
+
+
+print(ordenar_mezcla([38, 27, 43, 3, 9, 82, 10, 5]))
+
+random.seed(1)
+for prueba in range(500):
+    n = random.randint(0, 12)
+    original = [random.randint(1, 5) for _ in range(n)]
+    if ordenar_mezcla(original) != sorted(original):
+        print("FALLA", original)
+
+print("pruebas terminadas")
+ +
+
+
    +
  1. Escribe ordenar_mezcla diciendo las tres palabras: partir, ordenar cada mitad, mezclar.
  2. +
  3. Corre las 500 pruebas. Listas cortas y con repetidos: ahí se esconden los errores.
  4. +
  5. Planta un error: cambia <= 1 por == 1. ¿Falla? Sí, con RecursionError en la prueba 4, la primera lista vacía: [] se parte en [] y [] para siempre.
  6. +
  7. Por eso n empieza en 0: una prueba sin la lista vacía no lo habría visto.
  8. +
+
+
+
+ +
+
El esquema tiene nombre
+

Dividir, vencer, combinar

+ + + + + + +
Búsqueda binaria (conferencia 8)Ordenación por mezcla
Dividirmirar el del medio: casi gratispartir por la mitad: casi gratis
Venceruna mitad, la que puede tener el valorlas dos mitades, con la misma función
Combinarnada: la respuesta de la mitad es la respuestamezclar: n por nivel
Costolog₂ n niveles, una llamada cada uno: log₂ nlog₂ n niveles, n en cada uno: n log₂ n
+

Que un problema se pueda partir no basta: el costo depende de cuánto cuestan las tres partes. La mezcla parte gratis y trabaja al combinar. La que viene hace lo contrario.

+
+ + +
+
Parte 3
+

Trabajar al partir

+

La ordenación rápida reparte la lista alrededor de un pivote, y así combinar no cuesta nada.

+
+ +
+
Ordenación rápida
+

Menores, iguales, mayores, y pegar

+
+
+
def ordenar_rapida(lista):
+    if len(lista) <= 1:
+        return list(lista)
+    pivote = lista[0]
+    menores, iguales, mayores = [], [], []
+    for x in lista:
+        if x < pivote:
+            menores.append(x)
+        elif x == pivote:
+            iguales.append(x)
+        else:
+            mayores.append(x)
+    return (ordenar_rapida(menores) + iguales
+            + ordenar_rapida(mayores))
+
    +
  • Todos los menores van antes que los iguales, que van antes que los mayores: pegar con + ya da la lista ordenada.
  • +
  • iguales nunca está vacía: tiene al pivote. Por eso las dos llamadas reciben listas más pequeñas.
  • +
+
+
+
+
pivoteel que se reparteya en su lugar
+
+
+
+ +
+
El árbol de la rápida
+

El árbol depende de dónde cae el pivote

+
+
+
    +
  • La mezcla parte siempre a la mitad. La rápida parte donde caiga el pivote: el 38 deja cinco a la izquierda y dos a la derecha.
  • +
  • El pivote no baja: se queda en iguales. No se dibujan las llamadas con la lista vacía.
  • +
  • A la derecha, cuántos elementos se reparten en cada nivel.
  • +
+

Mira el escenario ya ordenada. ¿Cuántos niveles?

+
+
+
+
+ +
+ En vivo · archivo rapida.py +

Una lista ordenada la rompe

+
+
+
print(ordenar_rapida([38, 27, 43, 3, 9, 82, 10, 5]))
+
+ordenada = list(range(2000))
+try:
+    ordenar_rapida(ordenada)
+except RecursionError as error:
+    print(type(error).__name__, error)
+ +

Con el primero como pivote y la lista ordenada, el pivote es siempre el menor: menores vacía, mayores con todos los demás. Cada nivel quita un elemento.

+
+
+
    +
  1. Escribe ordenar_rapida y pruébala con las mismas 500 listas que la mezcla.
  2. +
  3. Pregunta: con list(range(2000)), ¿cuántos niveles tiene el árbol? 2000, y el tope de la conferencia 9 es mil.
  4. +
  5. Corre. Con 990 todavía termina; con 1000 ya no.
  6. +
  7. El trabajo: n + (n − 1) + … + 2, casi n²/2. Otra vez cuadrática, con la lista que más se da en la práctica: datos que alguien ya ordenó.
  8. +
+
+
+
+ +
+
El arreglo
+

El pivote al azar

+
+
+
def ordenar_rapida_azar(lista):
+    if len(lista) <= 1:
+        return list(lista)
+    pivote = random.choice(lista)
+    ...     # lo demás, igual
+
+
+print(ordenar_rapida_azar(ordenada) == ordenada)
+ +
    +
  • random.choice(lista) devuelve un elemento cualquiera. Ahora ninguna lista es mala siempre.
  • +
  • El trabajo esperado es n log n con cualquier entrada. La demostración, en Diseño y Análisis de Algoritmos.
  • +
+
+
+
+

La misma lista ordenada de 16, con los dos pivotes. Mira el contador de niveles.

+
+
+
+ + +
+
Parte 4
+

El reloj

+

Contra los métodos de la conferencia 8 primero. Después, el millón.

+
+ +
+
La carrera
+

Una comparación por paso

+
+

Las tres sobre la misma lista de 32, y cada una avanza una comparación por paso. En la rápida se cuenta un x < pivote por elemento repartido.

+
+ +
+
Los segundos
+

La ventaja crece con cada duplicación

+
+
+
+

Las mismas listas al azar para los cuatro. La selección y la inserción multiplican por cuatro; la mezcla y la rápida se quedan pegadas al fondo.

+

Tiempos del libro. Con listas tan cortas, la mezcla y la rápida duran milésimas, y el reloj tiembla: lo que importa es la columna de la derecha en las dos de arriba.

+
+
+
+ +
+ En vivo · archivo millon.py, con las dos funciones +

El millón, por fin

+
+
+
random.seed(8)
+millon = [random.randint(1, 1_000_000) for _ in range(1_000_000)]
+
+for nombre, metodo in [("mezcla", ordenar_mezcla),
+                       ("rápida", ordenar_rapida_azar),
+                       ("sorted", sorted)]:
+    inicio = time.perf_counter()
+    resultado = metodo(millon)
+    print(f"{nombre:>7}: {time.perf_counter() - inicio:5.2f} s  "
+          f"{'bien' if resultado == sorted(millon) else 'MAL'}")
+ +
+
+
    +
  1. Recuerda la cuenta del principio: la selección, casi diez horas.
  2. +
  3. Pide una predicción para la mezcla. Corre y espera con el aula.
  4. +
  5. Segundos, en Python, con listas y append. No cambió la máquina ni el lenguaje: cambió el orden de crecimiento.
  6. +
  7. Los tiempos de la izquierda son los del libro. Los de tu laptop serán otros; el orden, no.
  8. +
+
+
+
+ +
+
¿Y sorted?
+

Más rápida, pero de la misma familia

+
+
+
Escrita en C
+
No en Python. Eso le da una constante mucho menor: el mismo trabajo, cada paso más barato.
+
+
+
Timsort
+
Es una ordenación por mezcla con mejoras: aprovecha los pedazos que ya vienen ordenados en la entrada.
+
+
+
Inserción abajo
+
Para los pedazos pequeños usa la inserción de la conferencia 8, que ahí es más rápida que seguir con la recursión.
+
+
+

Su orden de crecimiento es el mismo que el de las nuestras: n log n. Entre n² y n log n, con un millón, está la diferencia entre multiplicar por un millón y multiplicar por veinte.

+
+ + +
+
Resumen
+

Lo que te llevas de hoy

+
    +
  • Divide y vencerás: dividir en subproblemas más pequeños del mismo tipo, resolverlos recursivamente, combinar sus soluciones.
  • +
  • Mezclar dos listas ordenadas cuesta tanto como la cantidad de elementos: cada uno se mira una vez.
  • +
  • La ordenación por mezcla parte sin mirar y trabaja al combinar: log₂ n niveles con n de trabajo cada uno, n log₂ n. Es estable.
  • +
  • La ordenación rápida trabaja al partir, en menores, iguales y mayores que un pivote, y combinar es pegar.
  • +
  • Con el primero como pivote, una lista ordenada deja el árbol como una fila: cuadrática y RecursionError. Con el pivote al azar, n log n esperado con cualquier entrada.
  • +
  • El costo de un algoritmo recursivo se cuenta en su árbol: cuántos niveles y cuánto trabajo en cada uno. La binaria es divide y vencerás con un solo subproblema.
  • +
+
+ +
+
Ejercicios · están completos en el libro
+

Para la clase práctica

+
+
    +
  • mezclar_tres(a, b, c), de dos maneras. ¿Cuál compara menos?
  • +
  • ordenar_mezcla partiendo en tres. ¿Cuántos niveles? Mídelo.
  • +
  • ordenar_mezcla_ciclo(lista) sin recursión: el árbol de abajo arriba.
  • +
  • La rápida con x <= pivote: ¿la lista más corta que da RecursionError?
  • +
+
    +
  • contar_rapida(lista) con listas ordenadas. ¿Otra lista mala?
  • +
  • Las palabras del Quijote, de más a menos frecuente, con ordenar_mezcla.
  • +
  • seleccionar(lista, k) con una sola llamada recursiva. ¿Cuánto trabaja?
  • +
  • La rápida con un millón ya ordenado: niveles, tiempo, y qué pasa en Python.
  • +
+
+
+ +
+
Para el profesor · guion de demos
+

Los momentos en la laptop

+
+

Todo corre en la carpeta de la conferencia, con import random y import time arriba. millon.py importa las funciones de mezcla.py y rapida.py, o las tiene copiadas. Pulsa el número de la diapositiva y Enter para saltar a ella. En las animaciones: A anima o pausa, S da un paso, X reinicia.

+
+ +
+ +
+
+ → Espacio RePág siguiente · ← anterior
+ R revela las salidas ocultas · V salta a la próxima demo en vivo
+ A anima o pausa · S un paso · X reinicia la animación
+ número + Enter va a esa diapositiva · Inicio Fin
+ F pantalla completa · ? esta ayuda +
+
+ + + + \ No newline at end of file From 4b773b63ed77dd692e7747188b169a20f1c7ca95 Mon Sep 17 00:00:00 2001 From: Alejandro Piad Morffis Date: Tue, 17 Nov 2026 13:35:51 -0500 Subject: [PATCH 2/2] docs(conferences): show why quicksort is used in the lecture 10 deck Count both comparisons of the quicksort in the race, add the comparisons against seconds slide, where each library uses which sort, and an in-place partition animation. Co-Authored-By: Claude Opus 5.5 --- .../10-divide-y-venceras/presentacion.html | 138 +++++++++++++++++- 1 file changed, 131 insertions(+), 7 deletions(-) diff --git a/conferences/2026/10-divide-y-venceras/presentacion.html b/conferences/2026/10-divide-y-venceras/presentacion.html index d9b6c1e..8d61b19 100644 --- a/conferences/2026/10-divide-y-venceras/presentacion.html +++ b/conferences/2026/10-divide-y-venceras/presentacion.html @@ -740,7 +740,7 @@

El reloj

La carrera

Una comparación por paso

-

Las tres sobre la misma lista de 32, y cada una avanza una comparación por paso. En la rápida se cuenta un x < pivote por elemento repartido.

+

Las tres sobre la misma lista de 32, y cada una avanza una comparación por paso. En la rápida cuentan el < y, si no era menor, el ==, como en el código. ¿Quién gana? Espera al reloj.

@@ -750,7 +750,7 @@

La ventaja crece con cada duplicación

Las mismas listas al azar para los cuatro. La selección y la inserción multiplican por cuatro; la mezcla y la rápida se quedan pegadas al fondo.

-

Tiempos del libro. Con listas tan cortas, la mezcla y la rápida duran milésimas, y el reloj tiembla: lo que importa es la columna de la derecha en las dos de arriba.

+

Tiempos del libro. Con listas tan cortas, la mezcla y la rápida duran milésimas y el reloj tiembla. Pero mira la última fila: la rápida es la más rápida de las cuatro, aunque en la carrera comparaba más que la mezcla.

@@ -785,9 +785,34 @@

El millón, por fin

+
+
La sorpresa
+

Más comparaciones, menos segundos

+
+
+
+

El mismo millón del libro, contado aparte. En la rápida cuentan el < y el ==.

+
+
+
# la mezcla: una vuelta por elemento colocado
+while i < len(a) and j < len(b):
+    if a[i] <= b[j]:
+        resultado.append(a[i])
+        i += 1
+
+# la rápida: una vuelta por elemento repartido
+for x in lista:
+    if x < pivote:
+        menores.append(x)
+

Contar comparaciones da el orden de crecimiento. El tiempo es ese orden por una constante: lo que cuesta cada vuelta. La de la mezcla calcula dos len, lee por índice y suma; la de la rápida recibe x y agrega.

+

Con el mismo orden, n log n, la constante decide.

+
+
+
+
¿Y sorted?
-

Más rápida, pero de la misma familia

+

sorted es una mezcla escrita en C

Escrita en C
@@ -802,7 +827,48 @@

Más rápida, pero de la misma familia

Para los pedazos pequeños usa la inserción de la conferencia 8, que ahí es más rápida que seguir con la recursión.
-

Su orden de crecimiento es el mismo que el de las nuestras: n log n. Entre n² y n log n, con un millón, está la diferencia entre multiplicar por un millón y multiplicar por veinte.

+

Si la rápida es más rápida, ¿por qué sorted es una mezcla? Porque la documentación de Python promete que es estable: los iguales conservan su orden, y eso la rápida no lo da.

+
+ +
+
En la práctica
+

Los lenguajes usan las dos

+ + + + + + + +
DóndeQué usaPor qué
sorted, list.sort (Python)Timsort, una mezclapromete estabilidad
Arrays.sort de objetos (Java)Timsort, una mezclalos objetos iguales se distinguen: hace falta estabilidad
Arrays.sort de números (Java)rápida con dos pivotesdos números iguales son indistinguibles: la estabilidad no importa
std::sort (C++)introsort: rápida, que cambia de método si la recursión se hace muy hondavelocidad, y un peor caso n log n sin depender del azar
std::stable_sort (C++)una mezclalo dice el nombre
+

La regla: mezcla cuando hace falta estabilidad o un peor caso garantizado; rápida cuando no, por velocidad y memoria.

+
+ +
+
Para quien quiera más · no está en el libro
+

La rápida de verdad no crea listas

+
+
+
def particion(lista):
+    pivote = lista[-1]
+    k = 0                   # lista[:k]: los menores
+    for j in range(len(lista) - 1):
+        if lista[j] < pivote:
+            lista[k], lista[j] = lista[j], lista[k]
+            k += 1
+    lista[k], lista[-1] = lista[-1], lista[k]
+    return k
+
    +
  • Nuestra rápida crea tres listas en cada llamada. Las de las bibliotecas intercambian dentro de la misma lista.
  • +
  • La mezcla necesita una lista auxiliar del tamaño de lo que mezcla. Esta rápida, ninguna.
  • +
+
+
+
+
pivotemenores, ya a la izquierdaintercambio
+

Con ini y fin en lugar de la lista entera, y dos llamadas recursivas, es la ordenación rápida en el mismo lugar. Queda para Diseño y Análisis de Algoritmos.

+
+
@@ -815,6 +881,7 @@

Lo que te llevas de hoy

  • La ordenación por mezcla parte sin mirar y trabaja al combinar: log₂ n niveles con n de trabajo cada uno, n log₂ n. Es estable.
  • La ordenación rápida trabaja al partir, en menores, iguales y mayores que un pivote, y combinar es pegar.
  • Con el primero como pivote, una lista ordenada deja el árbol como una fila: cuadrática y RecursionError. Con el pivote al azar, n log n esperado con cualquier entrada.
  • +
  • Contar comparaciones da el orden, no el tiempo: la rápida compara casi el doble y tarda menos. Con el mismo orden, la constante decide. La mezcla es estable; la rápida, más rápida en la práctica.
  • El costo de un algoritmo recursivo se cuenta en su árbol: cuántos niveles y cuánto trabajo en cada uno. La binaria es divide y vencerás con un solo subproblema.
  • @@ -1320,8 +1387,9 @@

    Los momentos en la laptop

    if (!quieto) yield F({ line: 3, cls: { done: hechos(), dim: fuera(lo, hi), key: [p] }, msg: `pivote: ${pv}` }); const men = [], igu = [], may = []; for (let k = lo; k < hi; k++) { - c.comparaciones++; - const x = a[k], dest = x.v < pv ? men : (x.v === pv ? igu : may); + const x = a[k]; + c.comparaciones += x.v < pv ? 1 : 2; // el < siempre, el == si no era menor + const dest = x.v < pv ? men : (x.v === pv ? igu : may); if (!quieto) yield F({ line: dest === men ? 7 : (dest === igu ? 9 : 11), cls: { done: hechos(), dim: fuera(lo, hi), key: [p], cmp: k === p ? [] : [k] }, msg: `${x.v} va a ${dest === men ? 'menores' : (dest === igu ? 'iguales' : 'mayores')}` }); else yield F({ cls: { done: hechos(), dim: fuera(lo, hi), key: [p], cmp: [k] }, msg: '' }); dest.push(x); @@ -1333,7 +1401,7 @@

    Los momentos en la laptop

    yield* qs(lo + men.length + igu.length, hi, d + 1); } yield* qs(0, n, 0); - yield F({ cls: { done: range(0, n) }, msg: `ordenada, en ${c.niveles} niveles de llamadas`, end: true }); + yield F({ cls: { done: range(0, n) }, msg: s.cuenta === 'comparaciones' ? `ordenada, con ${c.comparaciones} comparaciones` : `ordenada, en ${c.niveles} niveles de llamadas`, end: true }); } function* gSeleccion(a, c) { @@ -1393,6 +1461,49 @@

    Los momentos en la laptop

    yield F({ msg: `${c.repartidos} elementos repartidos en ${hondo} niveles de llamadas`, end: true }); } +// Dos medidas del mismo millón, que se revelan una por paso. +class Medidas extends Paso { + build() { + this.body.innerHTML = this.cfg.grupos.map(g => `
    ${g.titulo}
    ` + + g.filas.map(([t, col]) => `
    ${t}
    `).join('') + '
    ').join(''); + this.gfs = [...this.body.querySelectorAll('.grow')].map(g => [[...g.querySelectorAll('.gf')], [...g.querySelectorAll('.gv')]]); + } + paint(f) { + this.cfg.grupos.forEach((g, k) => { + const [fills, vals] = this.gfs[k], max = Math.max(...g.filas.map(r => r[2])); + g.filas.forEach(([t, col, v], r) => { + fills[r].style.width = k < f.ver ? (v / max * 100) + '%' : '0'; + vals[r].textContent = k < f.ver ? g.fmt(v) : ''; + }); + }); + } +} +function* gMedidas(c, s) { + yield { ver: 0, msg: 'el millón del libro: ¿cuál compara menos?' }; + yield { ver: 1, msg: 'la rápida hace casi el doble de comparaciones' }; + yield { ver: 2, msg: 'y tarda un 30 % menos', end: true }; +} + +// La partición de Lomuto: los menores se juntan a la izquierda, sin listas nuevas. +function* gParticion(a, c) { + c.intercambios = 0; + const n = a.length, pv = a[n - 1].v; + let k = 0; + const F = o => ({ a: a.slice(), cnt: { ...c }, ...o }); + yield F({ line: 1, cls: { key: [n - 1] }, ptr: { k: 0 }, msg: `pivote: el último, ${pv}` }); + for (let j = 0; j < n - 1; j++) { + const menor = a[j].v < pv; + yield F({ line: 4, cls: { key: [n - 1], found: range(0, k), cmp: [j] }, ptr: { k, j }, msg: `¿${a[j].v} < ${pv}? ${menor ? 'sí' : 'no'}` }); + if (menor) { + [a[k], a[j]] = [a[j], a[k]]; c.intercambios++; + yield F({ line: 5, cls: { key: [n - 1], found: range(0, k), swap: [k, j] }, ptr: { k, j }, msg: k === j ? `el ${a[k].v} ya está en su lugar` : `el ${a[k].v} pasa a la posición ${k}` }); + k++; + } + } + [a[k], a[n - 1]] = [a[n - 1], a[k]]; c.intercambios++; + yield F({ line: 7, cls: { found: range(0, k), key: [k] }, ptr: { k }, msg: `el ${pv} queda en la posición ${k}: menores a la izquierda, ninguna lista nueva`, end: true }); +} + const LIBRO = [38, 27, 43, 3, 9, 82, 10, 5]; new Montones($('v-mezclar'), { title: 'mezclar(a, b)', gen: gMezclar, code: 'c-mezclar', speed: 1000, @@ -1448,6 +1559,19 @@

    Los momentos en la laptop

    ], }); +new Medidas($('v-medidas'), { + title: 'ordenar un millón', gen: gMedidas, speed: 1600, scen: [{}], + grupos: [ + { titulo: 'comparaciones', fmt: miles, filas: [['mezcla', '#81c784', 18675014], ['rápida', '#ce93d8', 37258291]] }, + { titulo: 'segundos', fmt: v => v.toFixed(2).replace('.', ',') + ' s', filas: [['mezcla', '#81c784', 4.14], ['rápida', '#ce93d8', 2.88]] }, + ], +}); +new Viz($('v-part'), { + title: 'particion(lista)', kind: 'bars', gen: gParticion, code: 'c-part', speed: 800, + ptrs: { j: [0, '#ffb74d'], k: [1, '#81c784'] }, + scen: [{ label: 'un ejemplo', data: [27, 82, 3, 43, 9, 10, 5, 38] }, { label: '16 al azar', data: () => distintos(16) }], +}); + // la portada: la mezcla ordenando 32 barras sola, sin controles { const v = new Viz($('v-portada'), { kind: 'bars', gen: gMsort, controls: false, scen: [{ data: () => distintos(32), quieto: true }] });