FizzBuzz Benchmarks in elixir

FizzBuzzElixir.ex

defmodule Mix.Tasks.Statetrace.RunBench do
  use Mix.Task
  alias Statetrace.Meta

  @impl Mix.Task
  # credo:disable-for-next-line
  def run(_) do
    list = Enum.to_list(1..10_000)
    map_fun = fn i -> [i, i * i] end

    Benchee.run(
      %{
        # "fizz_buzz2" => fn -> fizz_buzz2(1000) end,
        # "fizzbuzz" => fn -> fizz_buzz(1000) end,
        # "fizz_buzz3" => fn -> fizz_buzz3(1000) end,
        "do_fizz_buzz7" => fn -> fizz_buzz7(1000) end,
        "fizz_buzz9" => fn -> fizz_buzz9(1000) end,
        "fizz_buzz10" => fn -> fizz_buzz10(1000) end,
        "do_fizz_buzz8" => fn -> fizz_buzz8(1000) end
        # "fizz_buzz4" => fn -> fizz_buzz4(1000) end,
        # "fizz_buzz6" => fn -> fizz_buzz6(1000) end
        # "fizz_buzz5" => fn -> fizz_buzz5(1000) end
      },
      memory_time: 2,
      time: 10
    )
  end

  def fizz_buzz(n) do
    Enum.map(1..n, fn n ->
      whichfizz = fn
        0, 0, _ -> "FizzBuzz"
        0, _, _ -> "Fizz"
        _, 0, _ -> "Buzz"
        _, _, n -> n
      end

      whichfizz.(rem(n, 3), rem(n, 5), n)
    end)
  end

  def fizz_buzz2(n) do
    for x <- 1..n do
      trem = rem(x, 3)
      frem = rem(x, 5)

      if trem == 0 and frem == 0 do
        "FizzBuzz"
      else
        if trem == 0 do
          "Fizz"
        else
          if frem == 0 do
            "Buzz"
          else
            x
          end
        end
      end
    end
  end

  def fizz_buzz2(n) do
    for x <- 1..n do
      trem = rem(x, 3)
      frem = rem(x, 5)

      if trem == 0 and frem == 0 do
        "FizzBuzz"
      else
        if trem == 0 do
          "Fizz"
        else
          if frem == 0 do
            "Buzz"
          else
            x
          end
        end
      end
    end
  end

  def fizz_buzz3(n) do
    for x <- 1..n do
      trem = rem(x, 3)
      frem = rem(x, 5)

      case {trem, frem} do
        {0, 0} -> "FizzBuzz"
        {0, _} -> "Fizz"
        {_, 0} -> "Buzz"
        _ -> x
      end
    end
  end

  def fizz_buzz4(n) do
    Enum.map(1..n, fn x ->
      trem = rem(x, 3)
      frem = rem(x, 5)

      case {trem, frem} do
        {0, 0} -> "FizzBuzz"
        {0, _} -> "Fizz"
        {_, 0} -> "Buzz"
        _ -> x
      end
    end)
  end

  def fizz_buzz5(n) do
    for x <- 1..n do
      trem = rem(x, 3)
      frem = rem(x, 5)

      beg =
        if trem == 0 do
          "Fizz"
        else
          ""
        end

      if frem == 0 do
        beg <> "Buzz"
      else
        beg || x
      end
    end
  end

  def fizz_buzz6(n) do
    Enum.reverse(do_fizz_buzz6(n))
  end

  def do_fizz_buzz6(0) do
    []
  end

  def do_fizz_buzz6(n) when rem(n, 3) == 0 and rem(n, 5) == 0 do
    ["FizzBuzz", do_fizz_buzz6(n - 1)]
  end

  def do_fizz_buzz6(n) when rem(n, 3) == 0 do
    ["Fizz", do_fizz_buzz6(n - 1)]
  end

  def do_fizz_buzz6(n) when rem(n, 5) == 0 do
    ["Buzz", do_fizz_buzz6(n - 1)]
  end

  def do_fizz_buzz6(n) do
    [n, do_fizz_buzz6(n - 1)]
  end

  def fizz_buzz7(n) do
    do_fizz_buzz7([], n)
  end

  def do_fizz_buzz7(acc, 0) do
    Enum.reverse(acc)
  end

  def do_fizz_buzz7(acc, n) when rem(n, 3) == 0 and rem(n, 5) == 0 do
    do_fizz_buzz7(["FizzBuzz" | acc], n - 1)
  end

  def do_fizz_buzz7(acc, n) when rem(n, 3) == 0 do
    do_fizz_buzz7(["Fizz" | acc], n - 1)
  end

  def do_fizz_buzz7(acc, n) when rem(n, 5) == 0 do
    do_fizz_buzz7(["Buzz" | acc], n - 1)
  end

  def do_fizz_buzz7(acc, n) do
    do_fizz_buzz7([n | acc], n - 1)
  end

  def fizz_buzz8(n) do
    do_fizz_buzz8([], n)
  end

  def do_fizz_buzz8(acc, 0) do
    Enum.reverse(acc)
  end

  def do_fizz_buzz8(acc, n) when rem(n - 1, 3) == 0 and rem(n - 1, 5) == 0 do
    do_fizz_buzz8([n, "FizzBuzz" | acc], n - 2)
  end

  def do_fizz_buzz8(acc, n) when rem(n - 1, 3) == 0 do
    do_fizz_buzz8([n, "Fizz" | acc], n - 2)
  end

  def do_fizz_buzz8(acc, n) when rem(n - 1, 5) == 0 do
    do_fizz_buzz8([n, "Buzz" | acc], n - 2)
  end

  def do_fizz_buzz8(acc, n) when rem(n, 3) == 0 and rem(n, 5) do
    do_fizz_buzz8(["FizzBuzz", n - 1 | acc], n - 2)
  end

  def do_fizz_buzz8(acc, n) when rem(n, 3) == 0 do
    do_fizz_buzz8(["Fizz", n - 1 | acc], n - 2)
  end

  def do_fizz_buzz8(acc, n) when rem(n, 5) == 0 do
    do_fizz_buzz8(["Buzz", n - 1 | acc], n - 2)
  end

  def do_fizz_buzz8(acc, n) when n > 0 do
    do_fizz_buzz8([n, n - 1 | acc], n - 2)
  end

  def do_fizz_buzz8(acc, n) do
    do_fizz_buzz8([n | acc], n - 1)
  end

  def fizz_buzz9(n) do
    fizz_buzz9([], n)
  end

  def fizz_buzz9(acc, 0) do
    Enum.reverse(acc)
  end

  for i <- 1..1000 do
    def fizz_buzz9(acc, unquote(i)),
      do:
        fizz_buzz9(
          [
            unquote(
              case {rem(i, 3), rem(i, 5)} do
                {0, 0} -> "FizzBuzz"
                {0, _} -> "Fizz"
                {_, 0} -> "Buzz"
                _ -> i
              end
            )
            | acc
          ],
          unquote(i - 1)
        )
  end

  def fizz_buzz9(acc, n) do
    do_fizz_buzz7(acc, n)
  end

  @boom Enum.map(1..1100, fn n ->
          whichfizz = fn
            0, 0, _ -> "FizzBuzz"
            0, _, _ -> "Fizz"
            _, 0, _ -> "Buzz"
            _, _, n -> n
          end

          whichfizz.(rem(n, 3), rem(n, 5), n)
        end)
  def fizz_buzz10(n) when n < 1100 do
    Enum.take(@boom, n)
  end

  def fizz_buzz10(n) do
    fizz_buzz9(n)
  end
end