
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é cerca de las 12:50. Los resultados oficiales tardan por lo menos una semana, así que este artículo no es sobre cómo me fue. Es sobre lo que haría distinto para llegar mejor preparado, y lo que sí me funcionó.
La idea principal: prepararte no es aprender todo. Es practicar lo que más se repite, en el lenguaje que dominas y en las mismas condiciones del reto. Si quieres ver cómo fueron mis otros retos, están en hackathons.
1. Elige un lenguaje y quédate con él
En este reto empecé en C y me cambié a PHP. PHP es el que uso a diario en WordPress y en plugins, y es en el que pienso. Python se escribe más rápido, pero en un reto con reloj no gana el lenguaje más corto: gana el que no te obliga a traducir en la cabeza.
Lo que significa en la práctica:
- Decide antes del reto, no durante. Cada minuto que pasas cambiando de lenguaje es un minuto que no pasas resolviendo.
- Conoce las funciones de tu lenguaje que más se usan en estos problemas. En PHP, para mí son
sort(),usort()constrcmp(),explode(),array_multisort()ySplMinHeap. Todas menos la última me tocaron ese día;SplMinHeapes la que pedía la versión rápida de Minimum Health. - Sabe cómo se lee la entrada y cómo se imprime la salida. Suena básico, pero si tienes que buscarlo en el reto ya perdiste tiempo.
2. Practica patrones, no problemas

No vas a ver en el reto el mismo problema que practicaste. Vas a ver uno que se parece. Por eso conviene practicar el patrón y no memorizar la solución.
Estos son los 10 patrones que más se repiten en este tipo de retos. Si dominas diez patrones, reconoces cientos de problemas:
- Two pointers: dos índices que avanzan sobre un arreglo, normalmente ordenado, para encontrar pares sin comparar todos contra todos.
- Sliding window: una ventana que se mueve sobre el arreglo y va sumando lo que entra y restando lo que sale.
- Hashmap: contar o buscar algo en tiempo constante con un arreglo asociativo.
- Stack: guardar lo pendiente y sacar lo último que entró (paréntesis, el siguiente mayor).
- BFS/DFS: recorrer un grafo o una cuadrícula por niveles o a profundidad.
- Heap: quedarte con los K más grandes o más chicos sin ordenar todo cada vez.
- Binary search: partir el rango a la mitad en cada paso, sobre un arreglo o sobre la respuesta.
- Sorting/greedy: ordenar primero y luego tomar la mejor decisión local.
- DP 1D: guardar en una tabla la mejor respuesta hasta cada punto y construir la siguiente con las anteriores.
- Prefix sums: sumas acumuladas para saber la suma de cualquier tramo con una resta.
En mi reto aparecieron tres de la lista. Closest Numbers era ordenar y comparar solo vecinos. Ancestral Names era ordenar con una comparación propia. Minimum Health, en su versión rápida, era un heap. Maximum Earnings era DP. Ninguno era nuevo como patrón; lo nuevo era el disfraz.
Así se ve el patrón de ordenar y comparar vecinos en PHP, con dos pasadas: una para hallar la diferencia mínima y otra para imprimir los pares que la tienen.
<?php
function closestNumbers(array $numbers): void {
sort($numbers);
$n = count($numbers);
$min = PHP_INT_MAX;
for ($i = 1; $i < $n; $i++) {
$min = min($min, $numbers[$i] - $numbers[$i - 1]);
}
for ($i = 1; $i < $n; $i++) {
if ($numbers[$i] - $numbers[$i - 1] == $min) {
echo $numbers[$i - 1] . " " . $numbers[$i] . "\n";
}
}
}
Por qué importa el patrón y no solo que "funcione": con un bubble sort, 100,000 números son unas 5,000 millones de comparaciones. La cuenta es n²/2: 100,000 × 100,000 = 10,000 millones, entre 2. Eso no termina a tiempo. Con sort() y una sola pasada por los vecinos, sí. Antes de escribir código conviene leer las restricciones; lo cuento con más detalle en los primeros pasos antes de escribir código.
3. Escribe sin autocompletado
En el trabajo escribo con mi editor, mis extensiones y mis atajos. En el reto escribes en el editor del navegador y el código tiene que correr a la primera, o casi. Ahí salen los errores que en el día a día el editor te marca antes de que los veas.
Después del reto armé una lista con los errores de un carácter. Son estos:
| Error | Escrito | Correcto |
|---|---|---|
Falta el $ | numbers[$i] | $numbers[$i] |
Letra o en vez de cero | $pa[o] | $pa[0] |
| Coma en vez de punto y coma | $k < $n, $k++ | $k < $n; $k++ |
| Asignar en vez de comparar | if ($diff = $min) | if ($diff == $min) |
| Signo cambiado | +- | += |
| Llave de más o de menos | } | — |
| Palabra mal escrita | retunr, usor | return, usort |
El de la o me costó caro. En Ancestral Names, en un intento solo pasó 1 de 10 casos porque escribí $pa[o] en lugar de $pa[0]. El único caso que pasó tenía nombres iguales, así que nunca entraba a esa línea. El código "funcionaba" justo en el caso que no lo probaba.
Cómo practicarlo: resuelve problemas en un editor simple, sin autocompletado ni sugerencias, y corre el código tú. Si te equivocas, anota el error en tu propia lista. Esa lista es oro para el repaso.
4. Simula el examen
Practicar un problema sin reloj y practicarlo con 150 minutos para cuatro no es lo mismo. Con reloj cambian tus decisiones: cuándo dejar un problema, cuándo conformarte con una solución lenta que pasa algunos casos, cuándo enviar.
Un simulacro de verdad tiene:
- El mismo tiempo y el mismo número de problemas que el reto. Si son 4 en 150 minutos, son 4 en 150 minutos.
- La misma plataforma, o una parecida, para que el editor y el formato de entrada no te sorprendan.
- Sin pausas. Nada de "ahorita sigo".
- Revisión al final: qué patrón era cada problema, dónde se fue el tiempo y qué error de un carácter cometiste.
En la plataforma también aprendes a leer los resultados. En Minimum Health tenía una versión correcta que pasó 11 de 15 casos. Los 4 que faltaron no tenían la respuesta mal: tenían el ícono de reloj, que significa que se acabó el tiempo de ejecución. Si no sabes distinguir eso, puedes pasar media hora buscando un error que no existe en lugar de hacer el código más rápido.
Si el reloj te pone nervioso, de eso trata cómo mantener la calma cuando el reloj corre.
5. Lee el enunciado en inglés
Los problemas vienen en inglés, y las palabras que deciden la solución son pocas pero importantes: at most, at least, distinct, ascending, non-decreasing, lexicographically, modulo. Si una de esas se te pasa, resuelves otro problema.
Lo que me sirve:
- Leer el enunciado completo dos veces antes de escribir nada.
- Practicar con enunciados en inglés aunque te cueste más. El día del reto no hay traducción.
- Fijarte en el formato de salida. La salida se compara tal cual, con espacios y saltos de línea.
Un plan de semana de ejemplo
No necesitas estudiar diez horas diarias. Necesitas constancia y practicar en las condiciones del reto. Un ejemplo de semana:
| Día | Qué haces | Para qué |
|---|---|---|
| Lunes | Patrones: 2 por día, un problema de cada uno | Reconocer el patrón cuando aparezca disfrazado |
| Miércoles | Simulacro con cronómetro, mismas reglas que el reto | Practicar decisiones con presión de tiempo |
| Viernes | Repaso de tu lista de errores de un carácter | Que no te cueste un caso lo que se arregla en un segundo |
Con 2 patrones por sesión, en cinco sesiones recorres los 10. Cuando termines la lista, vuelve a empezar con problemas distintos de los mismos patrones.
Este plan es consejo mío, no una receta probada con números. Ajústalo a tu tiempo; lo que no cambiaría es el simulacro con cronómetro.
Lo que yo no haría
- No cambiaría de lenguaje la semana del reto porque leí que otro es "mejor para competir". Llegas con menos soltura en todo.
- No memorizaría soluciones. El problema del reto nunca es exactamente el que practicaste.
- No practicaría solo con mi IDE. El día del reto no está.
- No confiaría en que un caso aprobado significa que el código está bien. El mío pasó uno con una
oen lugar de un cero. - No me quedaría pegado en el problema más difícil. Primero asegura lo que sí sale; de eso trata haz lo fácil primero y luego sube.
¿Platicamos?
Este tipo de práctica es la misma que uso en el trabajo: entender el problema, elegir la herramienta y probar antes de entregar. Si tienes un proyecto web, un plugin o un servidor que necesita a alguien que piense así, escríbeme en contacto.
Fuentes
- Datos del reto (4 problemas, 150 minutos, ventana de entrada, horarios, resultados por problema, el caso de
$pa[o], el timeout en Minimum Health, el cambio de C a PHP): experiencia propia de Samuel en el Google Core Hackathon End of Year (HackerRank, 21-nov-2026). - Los 10 patrones, los 5 puntos y el plan de semana: consejo propio de Samuel, sin estudio detrás.
- Cálculo de comparaciones del bubble sort (n²/2 con n = 100,000): cálculo propio, explicado en el texto.
sort()— php.netusort()— php.netstrcmp()— php.netexplode()— php.netarray_multisort()— 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



