Codility - BinaryGap in Elixir - stuck!

Your accumulator in Enum.reduce can be a more complex structure than a simple value. You could, for example, have a tuple that represents the current count of zero and a list of previous zero counts.

e.g.

{last_count, list_of_counts} = Enum.reduce(string_list, {0, []}, fn x, {current_count, list_of_counts} -> 
  # "if" version - I find it ugly
  count = if x == "0" do current_count + 1 else 0 end
  list_of_counts = if x == "0" do list_of_counts else [current_count | list_of_counts] end
  {count, list_of_counts}

  # or case version (delete one or other)
  case x == "0" do
    true -> {current_count + 1, list_of_counts}
    false -> {0, [current_count | list_of_counts}
  end
end

# Need to add last one 
list_of_counts = if last_count > 0 do [last_count | list_of_counts] else list_of_counts end

# Then you can get max value from the list, or whatever...

@mindok Thank you so much! I really appreciate your time and effort to help!
Let me fully absorb what is happening in your code and I will get back shortly!
Thanks again!

Enum.reduce/{2,3} is terse, and I use it plenty, but sometimes I have a hard time reading it and immediately understanding what is going on. Same goes for using it. At the end of the day it is just another way to write a recursive function, so when I am stuck it can be helpful to just write the recursive functions. On top of that, writing recursive functions to traverse a list in Elixir can be pretty straightforward thanks to pattern matching.

For example:

  def zeros(integer) when is_integer(integer) do
    Integer.digits(integer, 2)
    |> zeros(0, 0)
  end

  defp zeros([], _current_gap, max_gap), do: IO.puts max_gap
  defp zeros([bit | remaining_bits], current_gap, max_gap) do
    current_gap =
      case bit do
        0 -> current_gap + 1
        1 -> 0
      end

    max_gap =
      case current_gap do
        current_gap when current_gap > max_gap ->
          current_gap
        _ ->
          max_gap
      end

    zeros(remaining_bits, current_gap, max_gap)
  end
end

This is the perfect example of the problem when plain old good recursion is much more comprehensive and succinct than all the syntactic sugar.

defmodule BinGaps do
  def count(list, acc \\ {0, 0})

  # we are done, return result
  def count([], {max, _}), do: max
  # let’s count it
  def count([0|rest], {max, curr}),
    do: count(rest, {max, curr+1})
  # ok, we have new winner
  def count([1|rest], {max, curr}) when curr > max,
    do: count(rest, {curr, 0})
  # this was shorter, go ahead
  def count([1|rest], {max, _}),
    do: count(rest, {max, 0})
end

[20, 1041] |> Enum.map(fn number ->
  number
  |> Integer.digits(2)
  |> BinGaps.count()
end)
#⇒ [1, 5]

I think the recursive definition by @mudasobwa is what I would do. But just for fun here’s a different approach using a regex to split the number:

defmodule Zeros do
  def maxcount(integer) when is_integer(integer) do
    integer
    |> Integer.to_string
    |> String.split(~r/[^0]+/, trim: true)
    |> Enum.max_by(&String.length/1)
    |> String.length
  end
end

iex> Zeros.maxcount 100200004000000002
8

Unfortunately, this is also vulnerable to the longest trailing zero block. It should be somewhat like:

Regex.scan(~r/0+(?!0|\z)/i, "10100")
#⇒ [["0"]]

# or, without EOF matcher
Regex.scan(~r/0+(?=1)/i, "10100")

Beautiful people! I am really sorry for my late response here, but I just wanted to say thanks to everyone! I really appreciate your time!
Yeah, the solution from @mudasobwa looks the most concise. Thanks again!
Also, @mindok thanks for reminding that acc in Enum.reduce() might be more complex than just value: it helped me to reconsider many things I’ve implemented using Enum.reduce()
Thanks again all!