
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 y 150 minutos para resolverlos. Los resultados oficiales todavía no salen (tardan mínimo una semana), así que aquí no hay lugar final que presumir. Lo que sí tengo es algo que noté al revisar mis soluciones: lo que me sacó adelante en los últimos problemas fue lo que ya había usado en los primeros.
Cada problema que resuelves te deja una herramienta. En el siguiente, la primera pregunta no es «¿cómo resuelvo esto desde cero?», sino «¿cuál de las herramientas que ya tengo sirve aquí?».
Empecé el reto en C y me cambié a PHP, que es lo que uso todos los días en WordPress y plugins. Python se escribe más rápido, pero yo pienso en PHP. Todo el código de aquí es PHP.
La tabla de lo que reutilicé
Estos fueron los cuatro problemas y lo que cada uno me dejó para el siguiente:
| Problema | Herramienta | Dónde la volví a usar |
|---|---|---|
| Closest Numbers | Ordenar antes de comparar (sort()) | Es la base de todos los demás |
| Ancestral Names | Ordenar con mis propias reglas (usort() + strcmp()) | Cada vez que el orden no es el «normal» |
| Minimum Health | Ordenar y buscar por posición | El rival en el lugar rank |
| Maximum Earnings | Ordenar varios arreglos juntos (array_multisort()) | Para preparar la tabla de programación dinámica |
Fíjate en la columna del medio: las cuatro empiezan con ordenar. Con los datos en orden, muchos problemas se vuelven «compara con el de al lado» o «toma el que está en tal posición».
En Closest Numbers eso fue literal: ordenar y comparar solo vecinos. Un bubble sort con 100,000 datos hace unos 5,000 millones de comparaciones (n²/2 = 100,000 × 100,000 / 2) y no termina a tiempo; lo cambié por sort() y dos pasadas: hallar $min e imprimir los pares con esa diferencia. Cómo llegué a esa idea está en los primeros pasos antes de escribir código.
Ancestral Names: ordenar con tus propias reglas
En Ancestral Names había que ordenar nombres que traen un número romano, del estilo «Mary XIII» (el ejemplo es mío). Primero por nombre en orden alfabético y, si el nombre es igual, por el valor del número romano. El problema es que como texto «XL» queda antes que «XVI», pero XL vale 40 y XVI vale 16. Por eso no sirve un sort() normal.
Lo partí en dos herramientas:
- Separar el texto con
explode(" ", $item): queda el nombre en la posición 0 y el romano en la 1. - Convertir el romano a número con la tabla completa: I=1, V=5, X=10, L=50, C=100, D=500, M=1000. La regla: si una letra vale menos que la que sigue, se resta; si no, se suma. IX = -1 + 10 = 9.
Luego usort con una función que compara: strcmp para el nombre y una resta de valores para el romano.
<?php
function romano($r) {
$v = ['I' => 1, 'V' => 5, 'X' => 10, 'L' => 50, 'C' => 100, 'D' => 500, 'M' => 1000];
$total = 0;
for ($i = 0; $i < strlen($r); $i++) {
$actual = $v[$r[$i]];
if ($i + 1 < strlen($r) && $actual < $v[$r[$i + 1]]) {
$total -= $actual;
} else {
$total += $actual;
}
}
return $total;
}
function ordenarNombres($nombres) {
usort($nombres, function ($a, $b) {
$pa = explode(" ", $a);
$pb = explode(" ", $b);
$c = strcmp($pa[0], $pb[0]);
if ($c != 0) {
return $c;
}
return romano($pa[1]) - romano($pb[1]);
});
return $nombres;
}
Así, «Steven XVI» queda antes que «Steven XL» porque 16 es menor que 40.
La función de usort regresa un número negativo si $a va antes, positivo si va después y cero si son iguales. strcmp ya regresa eso para texto, y la resta lo regresa para números. Esa es la herramienta que me llevo: sirve para cualquier orden raro, como por fecha y luego por precio.
El error de una letra
En un intento solo pasó 1 de 10 casos. La lógica estaba bien. El problema: en una línea escribí $pa[o], con la letra o, en lugar de $pa[0], con el número cero. Se ven casi iguales en pantalla.
Lo engañoso fue que un caso sí pasaba: tenía nombres iguales y nunca entraba a esa línea. Eso me hizo buscar el error en la lógica. Era una letra.
La lección también se reutiliza: si casi todo falla y un caso pasa, pregúntate qué tiene de distinto. Suele decirte qué línea nunca se ejecutó. Al final Ancestral Names pasó todos los casos.
Maximum Earnings: ordenar tres arreglos a la vez
El último problema fue de programación dinámica. Hay pasajeros; cada uno sube en un punto, baja en otro y deja una cantidad. No puedes llevar a dos al mismo tiempo, y quieres el máximo total.
Por qué no sirve tomar siempre el que más deja
La tentación es ir por el que más paga. Por qué falla:
- X va de 0 a 10 y deja 12.
- Y va de 0 a 5 y deja 8.
- Z va de 5 a 10 y deja 8.
Si tomas a X, ya no caben Y ni Z: ganas 12. Con Y + Z ganas 16. Lo mejor en cada paso no da el mejor total; por eso hace falta una tabla.
La herramienta que ya tenía: ordenar
Antes de la tabla, los pasajeros se ordenan por el punto donde bajan. Los datos venían en tres arreglos ($pickup, $drop, $tip); si ordeno solo uno, pierdo qué subida y qué propina iban con cada bajada.
array_multisort($drop, $pickup, $tip) ordena los tres arreglos juntos usando $drop como guía. Es la idea de Closest Numbers, pero manteniendo las filas juntas.
La tabla, fila por fila

Con los pasajeros ya ordenados por bajada, para cada uno hay dos opciones: no lo tomo (me quedo con lo mejor que llevaba) o sí lo tomo (lo que deja más lo mejor que tenía antes de que subiera). Anoto la mayor.
| Pasajero | Viaje | Deja | Si no lo tomo | Si sí lo tomo | Anoto |
|---|---|---|---|---|---|
| A | 0 → 5 | 6 | 0 | 6 | 6 |
| B | 2 → 9 | 9 | 6 | 9 | 9 |
| C | 9 → 11 | 5 | 9 | 5 + 9 = 14 | 14 |
| D | 10 → 11 | 3 | 14 | 3 + 9 = 12 | 14 |
| E | 11 → 14 | 5 | 14 | 5 + 14 = 19 | 19 |
| F | 12 → 17 | 6 | 19 | 6 + 14 = 20 | 20 |
La respuesta es 20. En la fila D: sube en 10, el último que bajó antes es B (en 9), así que tomarlo da 3 + 9 = 12; como 14 es mayor, anoto 14.
En código:
<?php
function maximoGanado($pickup, $drop, $tip) {
array_multisort($drop, $pickup, $tip);
$n = count($drop);
$mejor = [0]; // $mejor[$i] = lo máximo con los primeros $i pasajeros
for ($i = 0; $i < $n; $i++) {
// cuántos pasajeros ya bajaron cuando sube este
$j = 0;
while ($j < $i && $drop[$j] <= $pickup[$i]) {
$j++;
}
$siLoTomo = $tip[$i] + $mejor[$j];
$mejor[$i + 1] = max($mejor[$i], $siLoTomo);
}
return $mejor[$n];
}
Con los datos de la tabla regresa 20, y con X, Y y Z regresa 16, no 12. El while recorre la lista desde el principio; con muchos datos lo cambiaría por una búsqueda binaria, porque $drop ya está ordenado.
Este problema lo envié en los últimos minutos y no alcancé a confirmar el resultado. Lo que muestro aquí es la idea revisada con calma, no lo que pasó en la plataforma.
Mi caja de herramientas en PHP
Esta es la lista que me quedó después del reto. Patrón a la izquierda, herramienta a la derecha:
| Patrón | Herramienta PHP |
|---|---|
| Ordenar | sort() |
| Comparación personalizada | usort() + strcmp() |
| Los K más fuertes | SplMinHeap |
| Ordenar varios arreglos juntos | array_multisort() |
| Partir texto | explode() |
No es larga, y esa es la idea: cinco herramientas que conoces bien sirven más que veinte que tienes que buscar en el manual con el reloj corriendo. Si te estás preparando para un reto, armar tu propia versión de esta tabla es parte de prepararte para un hackathon.
La pregunta clave: ¿esto se parece a algo que ya hice?
En Minimum Health, en cada nivel llega un jugador nuevo y Charlie pelea contra el que ocupa el lugar rank entre los más fuertes; se suma la fuerza de cada rival. Al leerlo me pregunté: ¿esto se parece a algo que ya hice? Y sí. «Encontrar el rival en el lugar rank» era lo mismo que ordenar y tomar una posición, algo que ya había hecho dos veces ese día.
<?php
$lista[] = $nuevo;
sort($lista);
$rival = $lista[count($lista) - $rank];
Esa versión es correcta y pasó 11 de 15 casos; los 4 restantes fueron por tiempo (el ícono de reloj significa timeout, no respuesta equivocada). La versión rápida usa SplMinHeap guardando solo los rank más fuertes: top() es justo el rival, sin ordenar toda la lista cada vez. Por qué fui primero por la versión que funciona y dejé la rápida como mejora lo cuento en haz lo fácil primero y luego sube.
No empecé pensando en heaps. Pregunté qué ya tenía, lo usé, aseguré casos y luego pensé en mejorar.
Lo que yo no haría
- No cambiaría a un lenguaje que no domino para «ir más rápido». Yo me cambié de C a PHP, y fue para irme al que uso a diario, no a uno que se ve más corto.
- No resolvería cada problema desde cero sin antes preguntarme si se parece a algo que ya hice ese mismo día.
- No confiaría en el único caso que pasa. Si pasa 1 de 10, ese caso puede estar saltándose justo la línea con el error.
- No ordenaría un solo arreglo cuando los datos vienen en varios que van juntos. Para eso está
array_multisort().
¿Platicamos?
Si te preparas para un reto así o tienes un proyecto en PHP o WordPress, escríbeme en contacto. También puedes ver mis otros retos en hackathons.
Fuentes
- Los cuatro problemas, la tabla de herramientas reutilizadas, el error de
$pa[o], los 11 de 15 casos de Minimum Health, la tabla de Maximum Earnings y el ejemplo de X, Y y Z: experiencia propia de Samuel en el Google Core Hackathon End of Year (HackerRank, 21-nov-2026). - ~5,000 millones de comparaciones con bubble sort: cálculo propio, n²/2 con n = 100,000.
sort()— php.netusort()— php.netstrcmp()— php.netarray_multisort()— 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



