maybe I’m missing the point, but
def reverse_sentence(sentence) do sentence |> String.split() |> Enum.reverse() |> Enum.join(" ") end
and if reverse is the point and you do not want to use stdlib
defp reverse(), do:  defp reverse([word | rest]), do: reverse(rest) ++ [word]
Also, you should check you code, as it is not correct.
Elixir has the great
@Sebb your solution has a downside in that it’s going to be slow on larger inputs.
You’re appending to a list which becomes expensive on big lists
Sure, if you want speed use
But I do not think my solution would be slower, because of the
But memory usage will be bad with my solution.
This will be way better:
defp reverse2(, result), do: result defp reverse2([word | rest], result) do reverse2(rest, [word | result]) end
Unfortunately that’s not true, but I like your dreams.
Enum was added to provide generic API for every
Enumerable. If I’m not wrong some optimizations were even rejected on
GitHub. Even if
Enum would have every optimization there is still one extra call for
Enumerable implementation. Since the post is for
Elixir newbies we should avoid going this topic too long.
In mentioned post I have added a comment with both
fast implementations. If we want to do it really fast we should only use pattern matching and recursion, for example:
defmodule Example do # function head with default arguments as described in article # `?\s` or `?\ ` returns a codepoint of space def sample(string, separator \\ ?\s, word \\ "", acc \\ "") # we simply pattern match if # current input, word (characters joined so far) and acc (words joined so far) # are empty which is true only if # the whole string is empty or contains only separator characters def sample("", _separator, "", ""), do: "" # when we reached end of input string # the only thing left is to join last word with our accumulator # Note: acc is common naming and short version of accumulator def sample("", separator, word, acc), do: <<word::binary, separator::utf8, acc::binary>> # trimming goes here # we simply pattern match checking if next 2 characters are our separator # in such case the function calls itself with only one separator def sample(<<separator::utf8, separator::utf8, rest::binary>>, separator, word, acc) do sample(<<separator::utf8, rest::binary>>, separator, word, acc) end # pattern matching for last separator after recent word (see clasule above) # in this case we do not want to have trailing separator # so we change our empty acc to the first word def sample(<<separator::utf8, rest::binary>>, separator, word, "") do sample(rest, separator, "", word) end # same as above, but with non empty acc # notice we reset the word after we set/add it to acc def sample(<<separator::utf8, rest::binary>>, separator, word, acc) do sample(rest, separator, "", <<word::binary, separator::utf8, acc::binary>>) end # this simple function clasule collects all characters that are not separator # and adds it to word parameter def sample(<<char::utf8, rest::binary>>, separator, word, acc) do sample(rest, separator, <<word::binary, char::utf8>>, acc) end end
Edit: Oh, for those newbies confused with too many solutions I would recommend to give benchee a try. With just few lines we can determine which solutions is faster.
Nice article, but you might want to edit this:
which is just not quite true. You probably meant something more like
Elixir, probably best known as the language behind Phoenix/LiveView, the most loved web framework in the StackOverflow 2022 survey …
It will at least be magnitudes faster than the version provided in the article and my recursive version. Hopefully also significantly faster than the tail-recursive
reverse2 … or is it?
I’ll look into those with Benchee as you suggested.