
Por Samuel Torres — Software & Cloud Engineer. 23+ sitios en producción.
El 21 de noviembre de 2026 presenté el Google Core Hackathon End of Year en HackerRank: 4 problemas de algoritmos en 150 minutos. La ventana para entrar era de 10:00 a 10:30; yo entré como a las 10:21 y terminé como a las 12:50. Los resultados oficiales tardan por lo menos una semana, así que aquí no hay lugar final ni premio. Lo que sí hay es lo que yo reporto de mi lado: Closest Numbers resuelto, Ancestral Names con todos los casos, Minimum Health con 11 de 15 casos y Maximum Earnings enviado en los últimos minutos, sin confirmar el resultado.
De todo lo que aprendí ese día, esto es lo que más me sirve para el siguiente reto: los puntos se ganan asegurando lo seguro primero, no atacando lo más difícil. Un problema difícil a medias vale lo mismo que uno que ni abriste. Un problema sencillo con 11 de 15 casos ya cuenta.
Lee los 4 problemas antes de escribir nada
El error más fácil de cometer es abrir el primer problema y empezar a escribir. Se siente productivo, pero no sabes si el tercero era el más fácil del examen.
Lo que yo haría en el siguiente reto es un escaneo de 2 minutos:
- Lee los 4 enunciados, solo el título, la idea y el ejemplo. No las restricciones a detalle todavía.
- Marca cuál parece más accesible. El que entiendes a la primera, el que se parece a algo que ya hiciste, el que tiene un ejemplo que puedes resolver a mano.
- Estima cuánto te llevaría cada uno, aunque sea a ojo: 20 minutos, 40 minutos, «no sé ni por dónde empezar».
- Decide el orden y anótalo en papel. Ese papel es tu plan cuando el reloj apriete.
Dos minutos de 150 son poco más del 1 % del tiempo (2 ÷ 150 = 0.013). A cambio, sabes desde el principio dónde están los puntos más baratos.
Ojo: el escaneo no es para resolver nada. Si te descubres pensando en el código del problema 3 mientras lees el 4, anótalo en una línea y sigue leyendo. El detalle de cómo leer un enunciado lo cuento en los primeros pasos antes de escribir código.
Mi decisión real: Minimum Health

Me quedaba menos de una hora en el reloj y tenía dos problemas por delante: Minimum Health y Maximum Earnings. Maximum Earnings pedía programación dinámica; Minimum Health se veía más sencillo. Fui por el sencillo.
La idea del problema: en cada nivel llega un jugador nuevo con su fuerza. Charlie pelea contra el jugador que ocupa el lugar rank entre los más fuertes, y se va sumando la fuerza de cada rival. «El lugar rank entre los más fuertes» es lo mismo que ordenar la lista y tomar una posición, algo que ya había hecho ese mismo día en los dos problemas anteriores.
No voy a copiar aquí el formato exacto de entrada de HackerRank. Lo que importa es la lógica, así que la escribo como una función que recibe un arreglo con la fuerza de cada jugador, en el orden en que llegan, y el rank.
Primero, la versión que funciona
<?php
function rivalesLento(array $fuerzas, int $rank): int
{
$lista = [];
$total = 0;
foreach ($fuerzas as $f) {
$lista[] = $f;
sort($lista);
if (count($lista) >= $rank) {
$total += $lista[count($lista) - $rank];
}
}
return $total;
}
Agrego al jugador nuevo, ordeno de menor a mayor con sort() y tomo $lista[count($lista) - $rank]. Si hay 5 jugadores y rank es 2, el segundo más fuerte está en el índice 5 − 2 = 3, el penúltimo. El if es para los primeros niveles, cuando todavía no hay rank jugadores; según el enunciado real puede que eso nunca pase, pero no cuesta nada cuidarlo.
Un ejemplo a mano con fuerzas [5, 1, 8, 3, 9] y rank = 2:
| Llega | Lista ordenada | Rival (2.º más fuerte) | Total |
|---|---|---|---|
| 5 | 5 | todavía no hay 2 | 0 |
| 1 | 1, 5 | 1 | 1 |
| 8 | 1, 5, 8 | 5 | 6 |
| 3 | 1, 3, 5, 8 | 5 | 11 |
| 9 | 1, 3, 5, 8, 9 | 8 | 19 |
Esta versión es correcta. Con ella aseguré 11 de 15 casos. Los 4 que faltaron tenían el ícono de reloj, y eso es importante leerlo bien: el reloj en un caso significa que se acabó el tiempo de ejecución (timeout), no que la respuesta esté mal. La lógica estaba bien; lo que fallaba era la velocidad.
Por qué es lenta
En cada nivel ordeno toda la lista otra vez, aunque solo llegó un jugador. Si hay n jugadores, hago n ordenamientos y cada uno es más grande que el anterior. Con listas chicas no se nota; con los casos grandes, el reloj gana.
Después, la versión rápida
La versión rápida usa SplMinHeap, una estructura que ya viene en PHP y que siempre tiene a la mano el número más chico. El truco: el heap guarda **solo los rank más fuertes**. El más débil de ese grupo es justo el que ocupa el lugar rank, y ese está en top().
<?php
function rivalesRapido(array $fuerzas, int $rank): int
{
$heap = new SplMinHeap();
$total = 0;
foreach ($fuerzas as $f) {
$heap->insert($f);
if (count($heap) > $rank) {
$heap->extract();
}
if (count($heap) === $rank) {
$total += $heap->top();
}
}
return $total;
}
Paso a paso: meto al jugador nuevo con insert(). Si ahora hay más de rank en el heap, saco al más débil con extract(), porque ya nunca va a ser rival: hay rank jugadores más fuertes que él. Lo que queda en top() es el rival de este nivel. Con el mismo ejemplo [5, 1, 8, 3, 9] y rank = 2 da 19, igual que la versión lenta.
La diferencia: ya no ordeno nada. Cada insert() o extract() trabaja sobre un heap que nunca pasa de rank + 1 elementos, en lugar de reordenar una lista que crece en cada nivel.
En el reto, esta versión quedó como mejora opcional: tenía 11 casos asegurados y otro problema sin resolver, así que seguí con Maximum Earnings. Ese lo envié en los últimos minutos y no alcancé a confirmar el resultado.
Primero que funcione, luego que sea rápido
Esto no es solo de Minimum Health. En Closest Numbers me pasó algo parecido: la primera idea fue un bubble sort, y con n = 100,000 datos eso son unas 5,000 millones de comparaciones (n²/2 = 100,000 × 100,000 ÷ 2 = 5 × 10⁹). Timeout seguro. Lo cambié por sort(), que ya viene en PHP, y el problema quedó en «ordenar y comparar solo vecinos».
La regla que me llevo:
- Una solución lenta y correcta ya da puntos. Los casos chicos pasan aunque los grandes no.
- Una solución rápida y equivocada no da nada. Y cuesta más depurarla, porque no sabes si el error está en la idea o en la optimización.
- La versión lenta te sirve de prueba. Cuando escribas la rápida, compara las dos con el mismo ejemplo. Si dan distinto, el error está en la nueva.
Divide el problema grande en problemas chicos
Cuando un problema se ve enorme, casi siempre son tres o cuatro problemas chicos pegados. Minimum Health, por ejemplo, se parte así:
- Guardar a los jugadores conforme llegan.
- Encontrar al que ocupa el lugar
rankentre los más fuertes. - Sumar su fuerza al total.
El paso 2 es el único difícil, y lo puedes resolver primero de la forma más tonta (ordenar todo) y luego mejorarlo sin tocar los pasos 1 y 3. Eso es justo lo que hace la versión con heap: cambia solo el paso 2.
En Ancestral Names pasa igual: separar nombre y número romano con explode(), convertir el romano a número y ordenar con usort(). Tres piezas, y cada una la puedes probar sola. Más sobre cómo reutilizar esas piezas en usa lo que ya aprendiste.
Guarda antes de arriesgar
Antes de tocar una versión que ya pasa casos, guárdala. Envíala, cópiala a un archivo aparte o déjala comentada abajo. Lo que sea, pero que exista una copia que sabes que funciona.
La razón es simple: optimizar con el reloj encima es cuando más errores de un carácter se cuelan. Un $ que falta, una coma en lugar de punto y coma, un = donde iba ==. Si la versión nueva se rompe y no tienes la vieja, puedes perder en cinco minutos lo que te costó media hora. Si tienes la copia, regresas a ella y no pasó nada.
Cuando el reloj aprieta y todo sale rojo, también ayuda tener un método para no entrar en pánico; eso lo cuento en cómo mantener la calma cuando el reloj corre.
Lo que yo no haría
- No empezaría por el problema que se ve más difícil «para quitármelo de encima». Si te atoras ahí, se te va el tiempo de los fáciles.
- No escribiría la versión optimizada de entrada si no la tengo clara. Primero la que funciona.
- No leería el ícono de reloj como «respuesta equivocada». Si la lógica está bien y solo falta velocidad, no reescribas la idea: cambia la estructura.
- No reescribiría encima de la única versión que pasa casos. Guarda primero.
- No me quedaría pegado en un problema hasta el final si todavía hay otro sin abrir. Asegura lo que tienes y sube al siguiente.
¿Platicamos?
Si tienes un proyecto que necesita esta forma de trabajar (asegurar primero lo que funciona y luego optimizar), escríbeme en contacto. Y si te interesan los retos, en hackathons está lo que he escrito sobre ellos.
Fuentes
- Formato del reto, horarios, decisión de ir por Minimum Health, 11 de 15 casos con la versión lenta, ícono de reloj como timeout, Maximum Earnings enviado sin confirmar resultado: experiencia propia de Samuel en el Google Core Hackathon End of Year (HackerRank, 21-nov-2026).
- Bubble sort con n = 100,000: unas 5,000 millones de comparaciones (cálculo propio, n²/2, explicado en el texto).
sort()— php.netusort()— php.netexplode()— php.netSplMinHeap— php.net
Sobre el autor
Samuel Torres es Software & Cloud Engineer en Conqr Digital Agency (CDMX). Opera 23+ sitios WordPress en producción y procesó 80,000 folios con OCR + LLM. Más en /sobre-mi. Cotiza por WhatsApp en 2 min



