Dentro del portal GetOnBoard encontré un reto técnico, consiste en resolver un algoritmo, me pareció curioso que desde las primeras etapas pidan esta clase de retos técnicos, sin embargo me gustó la idea, ya que practicar algoritmos es una forma de gimnasia para el cerebro, a los devs nos tiene que gustar o al menos sentirnos familiarizados con algoritmos, así que dije por qué no?

Pensé: hagámoslo, y de paso lo documentaré en mi blog, así que aquí está.

Tienes que afilar tu hacha: Tengo una sección completa en este blog sobre algoritmos llamada Algoritmos notables, donde resuelvo algoritmos y te los explico, te invito a descubrirla aquí.

Enunciado

Originalmente estuvo en inglés, lo traduciré:

A partir de una oración de prueba, invierte todas las palabras con un número par de caracteres, elimina las palabras duplicadas con un número impar de caracteres y devuelve lo más rápido posible las palabras ordenadas por longitud en una nueva oración.

Solución

Te explicaré en enfoque que utilicé, luego te mostraré el código.

• Primero dividí el texto en una lista de palabras
• Fui una por una y apliqué lo que me solicitaron, si el número de letras es pal, le doy la vuelta a la palabra. Si es impar me aseguro que la palabra no se duplique (para esto utilicé un hash set).
• Finalmente ordené todo por la cantidad de letras de cada palabra utilizando un algoritmo llamado bubble sort.

El código es el siguiente:

    public static void GetOnBoardAlgorithm(string message)
    {
        var words = new List<string>();
        words = message.Split(' ').ToList();        
        List<string> ListResponse = new();
        string response = string.Empty;
        HashSet<string> hashSet = new HashSet<string>();

        foreach (var item in words)
        {
            var numberCharacters = item.Length;
            string temp = string.Empty;
            if (numberCharacters % 2 == 0)
            {
                temp = string.Join(string.Empty, item.Reverse()) ?? string.Empty;
            }
            else
            {
                if (hashSet.Add(item))
                {
                    temp = item;
                }
            }
            if(temp.Length>0) ListResponse.Add(temp);
        }

        //Parte final: Ordenando
        for (int i = 0; i < ListResponse.Count; i++)
        {
            for (int j = 0; j < ListResponse.Count - i-1; j++)
            {
                if (ListResponse[j].Length > ListResponse[j + 1].Length)
                {
                    var temp = ListResponse[j];
                    ListResponse[j] = ListResponse[j + 1];
                    ListResponse[j+1] = temp;
                }
            }
        }
        response = string.Join(" ", ListResponse);
        Console.WriteLine(response);
    }

Mejoras y recomendaciones

Considerando que el enunciado pide que sea lo más rápido posible, es decir que sea lo más eficiente posible te diré dos mejoras que le puedes hacer a mi código, que aunque funciona bien, puede mejorar:

• Invertir una cadena con una pila o Stack en lugar de Reverse, no estoy seguro de cuál de los dos es más eficiente, sin embargo en algunos procesos de retos técnicos te dirán que no puedes usar métodos como Reverse y que lo hagas por tu cuenta, así que vale la pena que sepas como hacer esto.

• En la parte de ordenamiento utilicé el método conocido como bubble sort, no es el más rápido, así que podrías actualizarlo y utiilizar Quick Sort.

Si esta entrada te ha gustado, compártela crack y haz que llegue a más gente 🥳

Créditos de imagen de portada: Foto de Priscilla Du Preez 🇨🇦 en Unsplash