Saltar al contenido

Contacto

Ciudad de México, México
Disponible para proyectos remotos y presenciales.

Redes profesionales

LinkedIn · GitHub · Correo
Ingeniería aplicada, resultados medibles.

Los primeros pasos antes de escribir código

· 7 min de lectura · Samuel Torres

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 por lo menos una semana), así que este artículo no es sobre cómo me fue. Es sobre algo que aprendí a la mala y que ahora hago en cada problema: no escribo código hasta terminar una rutina corta.

La idea es simple: los primeros cinco minutos de cada problema deciden cuánto vas a sufrir en los siguientes cuarenta. Si empiezas a teclear con la primera idea que se te ocurre, lo más probable es que a la mitad descubras que el enunciado pedía otra cosa, que tu solución no termina a tiempo o que imprimes la respuesta en el formato equivocado. Y eso, con el reloj corriendo, cuesta mucho más que cinco minutos.

Primero te cuento los seis pasos y luego los aplico completos a uno de los problemas del reto, Closest Numbers.

La rutina de 6 pasos

1. Lee el enunciado dos veces

La primera lectura es para entender de qué trata. La segunda es para encontrar lo que se te pasó: una palabra como «todos», «distintos» u «ordenados de menor a mayor» cambia el problema completo. Los enunciados vienen en inglés y suelen ser largos, con una historia alrededor. La segunda lectura sirve para quitar la historia y quedarte con lo que de verdad te piden.

2. Lee las restricciones

Es la parte que casi todos se saltan y la que más información da. Las restricciones te dicen cuántos datos van a llegar como máximo y qué tan grandes pueden ser. Con eso sabes, antes de escribir nada, si una solución «de fuerza bruta» va a alcanzar o si te va a dar timeout. No es lo mismo ordenar 10 números que 100,000.

3. Resuelve el ejemplo a mano

Toma el ejemplo del enunciado y resuélvelo tú, en papel o en un comentario, sin código. Si no puedes resolverlo a mano, todavía no entendiste el problema, y ningún código lo va a arreglar. Si sí puedes, acabas de descubrir los pasos que tu programa tiene que seguir.

4. Revisa la plantilla

HackerRank te da una plantilla con una función ya declarada: un nombre, unos parámetros y lo que se espera que regrese. Léela antes de escribir. Fíjate qué recibe la función, si tienes que regresar un valor o imprimirlo, y en qué tipo de dato. La plantilla cambia según el lenguaje que elijas. En el reto yo empecé en C y me cambié a PHP, que es el que uso todos los días en WordPress y plugins; al cambiar de lenguaje cambia la plantilla, y hay que volver a leerla.

5. Escribe la idea en palabras

Antes del código, una frase. Si la idea no cabe en una o dos frases en español, todavía está revuelta en tu cabeza. Esa frase es tu mapa: cuando te pierdas entre errores de sintaxis, regresas a ella y sabes qué estabas intentando hacer.

6. Revisa el formato de salida

La salida no la revisa una persona: la compara un programa contra la respuesta esperada, carácter por carácter. Un espacio de más al final, un salto de línea que falta o los números en otro orden pueden marcar como incorrecta una respuesta que en la lógica estaba bien. Por eso, antes de enviar, compara tu salida con la del ejemplo, letra por letra.

La rutina aplicada: Closest Numbers

Closest Numbers fue uno de los cuatro problemas del reto, y uno de los que resolví. En resumen: te dan una lista de números y tienes que encontrar los pares que están más cerca entre sí, es decir, los que tienen la diferencia más chica. Si hay varios pares con esa misma diferencia, van todos.

Pasos 1 y 2: enunciado y restricciones

Leído dos veces, el problema tiene dos partes: encontrar la diferencia mínima y luego todos los pares que la tienen. No es «el par más cercano», en singular; son todos los que empatan.

Luego las restricciones: la lista puede tener hasta 100,000 números. Ese dato decide todo lo demás.

La primera idea que se le ocurre a cualquiera es comparar cada número contra todos los demás. Con 100,000 números eso son 100,000 × 99,999 / 2 pares, más o menos 5,000 millones de comparaciones. Lo mismo pasa si escribes tu propio bubble sort para ordenar: en el peor caso hace del orden de n²/2 comparaciones, y con n = 100,000 eso es 100,000² / 2 = 5,000,000,000. No termina a tiempo: timeout seguro.

En cambio, la función sort() de PHP ya trae un ordenamiento eficiente, que como regla general trabaja del orden de n·log n. Con n = 100,000, log₂ de 100,000 es casi 17, así que hablamos de alrededor de 1.7 millones de comparaciones. La diferencia entre las dos cifras es la diferencia entre pasar y no pasar los casos grandes.

Paso 3: el ejemplo a mano

Closest Numbers a mano: ordenar y comparar solo vecinos
Closest Numbers a mano: ordenar y comparar solo vecinos

Tomo una lista chica: [6, 2, 4, 10].

Si la dejo así, tendría que comparar el 6 con el 2, con el 4 y con el 10; luego el 2 con el 4 y con el 10; y así. Pero si la ordeno primero, queda [2, 4, 6, 10] y aparece algo que a mano se ve rápido:

VecinosDiferencia
2 y 42
4 y 62
6 y 104

La diferencia mínima es 2, y la tienen dos pares: (2, 4) y (4, 6).

Lo importante de hacerlo a mano es lo que descubres: en una lista ordenada, el número más cercano a cualquier otro siempre está a su lado. No hace falta comparar el 2 con el 10; si el 2 y el 4 ya están separados por 2, el 10 no puede estar más cerca del 2. Por eso solo hay que comparar vecinos, y con n números hay n − 1 pares de vecinos, no 5,000 millones de pares.

Paso 4: la plantilla

Aquí no te puedo decir el nombre exacto de la función ni lo que regresaba en este reto, y no lo voy a inventar. Lo que sí te digo es qué buscar: qué parámetro recibe la lista, si la función tiene que regresar un arreglo o imprimir texto, y si la plantilla ya trae el código que lee la entrada. Si ya lo trae, no lo toques: tu trabajo está dentro de la función.

Paso 5: la idea en una frase

Ordeno y comparo vecinos.

Un poco más larga: ordeno la lista, recorro los vecinos una vez para encontrar la diferencia mínima, y los recorro otra vez para juntar los pares que tienen esa diferencia.

Con esa frase, el código casi se escribe solo:

<?php
function closestNumbers($arr) {
    sort($arr);
    $n = count($arr);

    // Primera pasada: la diferencia mínima entre vecinos
    $min = PHP_INT_MAX;
    for ($i = 1; $i < $n; $i++) {
        $diff = $arr[$i] - $arr[$i - 1];
        if ($diff < $min) {
            $min = $diff;
        }
    }

    // Segunda pasada: todos los pares con esa diferencia
    $pares = [];
    for ($i = 1; $i < $n; $i++) {
        if ($arr[$i] - $arr[$i - 1] == $min) {
            $pares[] = [$arr[$i - 1], $arr[$i]];
        }
    }
    return $pares;
}

print_r(closestNumbers([6, 2, 4, 10]));
// Pares: [2, 4] y [4, 6]

Son dos recorridos de n − 1 vecinos cada uno, más el sort().

Ojo con un detalle que se ve chiquito: en la segunda pasada es ==, no =. Si escribes if ($diff = $min) estás asignando, no comparando, y la condición casi siempre da verdadero. Es uno de esos errores de un carácter que te comen diez minutos.

Este código regresa los pares como arreglos de dos números. Cómo se tienen que entregar en tu reto (un arreglo plano, texto separado por espacios, un par por línea) lo dice la plantilla y el ejemplo de salida, no yo. Ajusta solo el final.

Paso 6: el formato de salida

Este es el paso donde una solución correcta puede salir mal. La salida se compara carácter por carácter contra la esperada: espacios, saltos de línea y orden. Si el ejemplo muestra los números en una línea separados por un espacio y tú imprimes un par por línea, el resultado es «incorrecto», aunque los pares sean los buenos.

Por eso, antes de enviar:

  • Corre tu código con el ejemplo del enunciado.
  • Pon tu salida junto a la esperada y compárala carácter por carácter.
  • Revisa que no sobre un espacio al final ni falte un salto de línea.
  • Revisa el orden: como la lista ya está ordenada, los pares salen de menor a mayor, pero confirma que eso es lo que pide el enunciado.

Por qué vale la pena gastar esos cinco minutos

En un reto de 150 minutos, cinco minutos por problema se sienten como un lujo. Con cuatro problemas son veinte minutos sin escribir código, y cuando ves el contador bajando, la tentación es empezar ya.

Pero piensa en lo que te ahorran. Leer las restricciones te evita escribir una solución completa que luego vas a tirar por timeout. Resolver el ejemplo a mano te da el algoritmo. La frase te saca del hoyo cuando te pierdes. Revisar el formato evita perder puntos por un espacio. Cada uno de esos errores, descubierto a la mitad, cuesta más que el paso que lo evita.

Esto también ayuda con los nervios. Cuando tienes una rutina, la primera parte de cada problema es mecánica, y lo mecánico calma. Escribí más sobre eso en cómo mantener la calma cuando el reloj corre. Y si quieres saber en qué orden atacar los problemas una vez que los leíste, está haz lo fácil primero y luego sube.

Lo que yo no haría

  • No empezaría a escribir con la primera idea. La primera idea casi siempre es la de fuerza bruta, y con 100,000 datos la fuerza bruta no llega.
  • No escribiría mi propio algoritmo de ordenamiento en un reto. sort() ya existe, está probado y es más rápido que cualquier bubble sort que escriba con prisa.
  • No me saltaría el ejemplo a mano «porque se ve fácil». Ahí es donde aparece el detalle que cambia todo, como que son todos los pares que empatan y no solo uno.
  • No enviaría sin comparar mi salida con la del ejemplo. La lógica puede estar perfecta y el resultado salir mal por un espacio.
  • No asumiría el formato de salida. Ni de este problema ni de ninguno: lo dice el enunciado.

¿Platicamos?

Hago desarrollo web completo, plugins y sistemas a medida, servidores y cloud. Esta misma forma de trabajar, entender el problema antes de tocar el código, es la que uso con mis clientes. Si tienes un proyecto o quieres comentar algo de este artículo, escríbeme en contacto. Y si te interesan los retos de programación, en hackathons junto lo que he aprendido en cada uno.

Fuentes

  • Reto de 4 problemas en 150 minutos, problema Closest Numbers, cambio de C a PHP y rutina de 6 pasos: experiencia propia de Samuel en el Google Core Hackathon End of Year (HackerRank, 21-nov-2026).
  • Comparaciones de bubble sort y de «todos contra todos» con n = 100,000 (n²/2 ≈ 5,000 millones) y n·log₂ n ≈ 1.7 millones: cálculo propio explicado en el texto.
  • Función sort() de PHP — 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

Samuel Torres Pichardo

Samuel Torres Pichardo
Ingeniero de software y cloud en Ciudad de México, con unos 3 años de experiencia profesional.
Sobre mí · LinkedIn · GitHub · Contacto

¿Tienes un proyecto en mente?

Contrátame: yo te ayudo a construirlo.

Páginas web, tiendas, sistemas a la medida y nube. Me cuentas qué necesitas y te digo cómo lo haría, cuánto cuesta y cuánto tarda.

  • Ciudad de México · remoto

Menú

English

[email protected]