DEV Community

Cover image for Desafío de Nombres y Apellidos
Camilo for JavaScript Chile

Posted on

Desafío de Nombres y Apellidos

El siguiente es un pequeño ejercicio encontrado en el curso de Haskell
disponible en la Universidad de Helsinki.

Desafío

Dado una lista de nombres y apellidos:

  • Nombres: ["Eva", "Mike"]
  • Apellidos: ["Smith", "Wood", "Odd"]

Retornar una lista cuyos elementos sean solo de personas con largo par.

Ejemplo de Retorno

  • ["EvaSmith", "EvaOdd", "MikeWood"]

Solución en Haskell

Haskell permite pattern matching y list comprehensions.

[whole | first <- ["Eva", "Mike"],
         last <- ["Smith", "Wood", "Odd"],
         let whole = first ++ last,
         even (length whole)]
Enter fullscreen mode Exit fullscreen mode

Solución en Elixir

Si bien la solución en Elixir no es tan corta como en Haskell
es igual de elegante.

require Integer

for first <- ~w[Eva Mike],
  last <- ~w[Smith Wood Odd],
  name <- [first <> last],
  name
  |> String.length()
  |> Integer.is_even(), do: name
Enter fullscreen mode Exit fullscreen mode

Para esto utilizamos las características de for comprehensions.

Solución en Javascript

David de Javascript Chile nos escribe una solución en versión
imperativa y declarativa utilizando Javascript.

Imperativa

const nombres = ["Eva", "Mike"];
const apellidos = ["Smith", "Wood", "Odd"];

const output = [];

for(let i = 0; i < nombres.length; i++){
    for(let j = 0; j < apellidos.length; j++){
        const fullName = `${nombres[i]}${apellidos[j]}`;
        if(fullName.length % 2 == 0){
            output.push(fullName);
        }
    }
}
Enter fullscreen mode Exit fullscreen mode

Declarativa

const nombres = ["Eva", "Mike"];
const apellidos = ["Smith", "Wood", "Odd"];

const output = nombres.flatMap(n =>
        apellidos.map(a => `${n}${a}`)
    )
    .filter(fullName => fullName.length % 2 == 0);
Enter fullscreen mode Exit fullscreen mode

Elixir

La versión declarativa de Javascript la podríamos emular en Elixir de la siguiente
forma:

~w[Eva Mike]
|> Enum.flat_map(fn first ->
  ~w[Smith Wood Odd]
  |> Enum.map(fn last ->
    first <> last
  end)
end)
|> Enum.filter(&
    &1
    |> String.length()
    |> Integer.is_even()
)
Enter fullscreen mode Exit fullscreen mode

Aunque no es tan elegante como usar for comprehensions.

¿En qué otros lenguajes puedes solucionar el desafío?

Top comments (1)

Collapse
 
adolfont profile image
Adolfo Neto

The Erlang version will probably be very similar to the Haskell version.