Ordenador de números

Ordenação de dados é um dos problemas mais estudados da ciência da computação — não por nostalgia acadêmica, mas porque acontece em todo lugar e a diferença entre um algoritmo ruim e um bom é a diferença entre um programa que processa em segundos e um que trava por horas. O bubble sort aparece em livros introdutórios como exemplo didático e merece esse papel: é intuitivo de entender, mas seu tempo O(n²) o torna inaceitável para listas grandes. O merge sort, concebido por John von Neumann em 1945, trouxe a ideia de dividir para conquistar e provou ser O(n log n) no pior caso. O quicksort, inventado por Tony Hoare em 1959, é geralmente mais rápido na prática por ser mais amigável ao cache de CPU, mesmo tendo O(n²) no pior caso com pivôs ruins. Donald Knuth dedicou o terceiro volume inteiro de The Art of Computer Programming, publicado em 1973, ao tema de sorting e searching.

Há uma armadilha clássica para quem usa JavaScript: o método nativo `Array.prototype.sort()` sem argumento ordena elementos como texto, não como números. Isso significa que ao ordenar `[1, 10, 2, 20]`, o resultado é `[1, 10, 2, 20]` — porque os números são comparados como se fossem palavras: `10` vem antes de `2` da mesma forma que `abc` vem antes de `b` no dicionário. Esse comportamento surpreende quase todos os desenvolvedores JavaScript pelo menos uma vez. A correção é passar a função comparadora `(a, b) => a - b` para ordem crescente, ou `(a, b) => b - a` para decrescente. A linguagem JavaScript especifica desde o ES2019 que `Array.prototype.sort` deve ser estável — ou seja, elementos com valores iguais mantêm sua ordem relativa original. Antes disso, a estabilidade dependia do motor JavaScript e do tamanho do array.

Ordenar números manualmente é mais comum no dia a dia técnico do que parece. Você copia 20 valores de uma coluna de log, 50 resultados de benchmark, ou uma lista de IDs de banco de dados que vieram fora de ordem — e precisa apenas saber qual é o maior, o menor, ou identificar os outliers. Abrir uma planilha para isso interrompe o fluxo de trabalho. Escrever um script de terminal é um exagero para isso. Esta ferramenta aceita números separados por qualquer combinação de vírgulas, espaços e quebras de linha — como você geralmente encontra ao copiar dados de terminais e tabelas — e devolve a lista ordenada pronta para usar.

Sorting is one of the most studied problems in computer science — not out of academic nostalgia, but because it occurs everywhere and the difference between a bad algorithm and a good one is the difference between a program that processes in seconds and one that locks up for hours. Bubble sort appears in introductory textbooks as a teaching example and earns that role: it is intuitive to understand, but its O(n²) time complexity makes it unacceptable for large lists. Merge sort, conceived by John von Neumann in 1945, introduced divide-and-conquer and proved to be O(n log n) in the worst case. Quicksort, invented by Tony Hoare in 1959, is generally faster in practice because it is more CPU-cache-friendly, even though it is O(n²) in the worst case with bad pivot choices. Donald Knuth dedicated the entire third volume of The Art of Computer Programming, published in 1973, to sorting and searching.

There is a classic trap for JavaScript developers: the native `Array.prototype.sort()` method without an argument sorts elements as text, not as numbers. This means sorting `[1, 10, 2, 20]` produces `[1, 10, 2, 20]` — because the numbers are compared as if they were words: `10` comes before `2` the same way `abc` comes before `b` in a dictionary. This behavior surprises almost every JavaScript developer at least once. The fix is to pass the comparator function `(a, b) => a - b` for ascending order, or `(a, b) => b - a` for descending. JavaScript has specified since ES2019 that `Array.prototype.sort` must be stable — meaning elements with equal values keep their relative original order. Before that, stability depended on the JavaScript engine and the array size.

Sorting numbers by hand is more common in day-to-day technical work than it seems. You copy 20 values from a log column, 50 benchmark results, or a list of database IDs that came out of order — and you just need to know which is largest, smallest, or spot the outliers. Opening a spreadsheet for this breaks the workflow. Writing a terminal script is overkill. This tool accepts numbers separated by any combination of commas, spaces, and line breaks — the way data typically looks when pasted from terminals and tables — and returns the sorted list ready to use.

Ordenar datos es uno de los problemas más estudiados de la informática — no por nostalgia académica, sino porque ocurre en todos lados y la diferencia entre un algoritmo malo y uno bueno es la diferencia entre un programa que procesa en segundos y uno que se bloquea durante horas. El bubble sort aparece en los libros de texto introductorios como ejemplo didáctico y merece ese lugar: es intuitivo de entender, pero su complejidad O(n²) en tiempo lo hace inaceptable para listas grandes. El merge sort, concebido por John von Neumann en 1945, introdujo la idea de divide y vencerás y demostró ser O(n log n) en el peor caso. El quicksort, inventado por Tony Hoare en 1959, suele ser más rápido en la práctica por ser más amigable con la caché de la CPU, aunque tiene O(n²) en el peor caso con malas elecciones de pivote. Donald Knuth dedicó el tercer volumen completo de The Art of Computer Programming, publicado en 1973, al tema de ordenación y búsqueda.

Existe una trampa clásica para quienes usan JavaScript: el método nativo `Array.prototype.sort()` sin argumento ordena los elementos como texto, no como números. Esto significa que al ordenar `[1, 10, 2, 20]`, el resultado es `[1, 10, 2, 20]` — porque los números se comparan como si fueran palabras: `10` viene antes que `2` igual que `abc` viene antes que `b` en el diccionario. Este comportamiento sorprende a prácticamente todos los desarrolladores de JavaScript al menos una vez. La solución es pasar la función comparadora `(a, b) => a - b` para orden ascendente, o `(a, b) => b - a` para descendente. JavaScript especifica desde ES2019 que `Array.prototype.sort` debe ser estable — es decir, los elementos con valores iguales conservan su orden relativo original. Antes de eso, la estabilidad dependía del motor JavaScript y del tamaño del array.

Ordenar números manualmente es más común en el trabajo técnico cotidiano de lo que parece. Copias 20 valores de una columna de log, 50 resultados de benchmark, o una lista de IDs de base de datos que llegaron desordenados — y solo necesitas saber cuál es el mayor, el menor, o identificar los valores atípicos. Abrir una hoja de cálculo para esto interrumpe el flujo de trabajo. Escribir un script de terminal es excesivo. Esta herramienta acepta números separados por cualquier combinación de comas, espacios y saltos de línea — tal como suelen verse al pegar datos de terminales y tablas — y devuelve la lista ordenada lista para usar.