Code kata: apariencias impares

Por Carlos Blé Jurado

Hace poco, eligiendo ejercicios para una entrevista de trabajo, encontramos uno sencillo, pero muy interesante en Codewars. Es curioso lo mucho que nos podemos llegar a complicar la vida para resolver un problema que es tan sencillo.

El ejercicio consiste en filtrar una lista de números, quedándonos con aquellos que aparezcan un número de veces impar en dicha lista. Es una función que recibe una lista y devuelve otra lista.

Es buen ejercicio para quien quiere probar a hacerlo sin TDD, porque lo ve muy fácil. Luego, se puede hacer con TDD y comparar. Decimos que un ejercicio de código es una kata cuando lo trabajamos muchas veces. Empezando desde cero cada vez. En cada interacción practicamos algo distinto, enfocar el problema de manera distinta o utilizar técnicas distintas. Incluso, podemos probar con varios lenguajes de programación y paradigmas. Así, podemos comparar y desarrollar el olfato para reconocer qué tipo de soluciones funcionan mejor para según qué problemas.

Si quieres practicar la kata no sigas leyendo, practica antes de ver nuestra solución del vídeo o la solución que te mostramos en las siguientes líneas. Luego vuelve y compara.

Nosotros hicimos el experimento así, primero “a lo loco”. Luego, grabamos el video donde te mostramos una posible solución de la kata. Está narrado y con unas animaciones muy chulas que ha trabajado nuestro gran equipo de producción.

Después, llevamos el ejercicio a un coding dojo, donde más de 30 personas trabajaron en el ejercicio en dos iteraciones. Aprovecho la ocasión para agradecer a los amigos de Secret Source su propuesta de realizar un dojo juntos. Cuando tantas cabezas pensantes trabajan en el mismo problema, aparecen soluciones muy ingeniosas. Una de las que más me gustó fue esta:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

    int[] findNumbersAppearingAnOddNumberOfTimesIn(int[] numbers){
        if (numbers == null){
            return new int[0];
        }
        List<Integer> result = new ArrayList<>();
        for (int number: numbers){
            if (result.contains(number)) {
                removeNumberAppearingTwice(result, number);
            } else {
                addNumberAppearingOnce(result, number);
            }
        }
        return result.stream().mapToInt(i -> i).toArray();
    }

    private void addNumberAppearingOnce(List<Integer> result, int number){
        result.add(number);
    }

    private void removeNumberAppearingTwice(List<Integer> result, Integer number) {
        result.remove(number);
    }

Lo que me gustó de esta solución es que reduce mucho la complejidad ciclomática comparado con otras soluciones y, sin embargo, el código se sigue entendiendo muy bien.

No importa que hayas visto el código, si practicas la kata busca soluciones alternativas. La práctica deliberada y los experimentos extremos que nos permiten hacer estos ejercicios sin riesgo, nos ayudan a innovar y mejorar técnicamente en el día a día del trabajo.