基于结构类型改变的分块列表



我有一个列表,我想基于从结构类型B到a的转换进行块化。因此,例如,我有以下内容:

iex(1)> defmodule A, do: defstruct []
{:module, A ...
iex(2)> defmodule B, do: defstruct []
{:module, B ...
iex(3)> values = [ %A{}, %A{}, %B{}, %B{}, %B{}, %A{}, %A{}, %B{} ]
[%A{}, %A{}, %B{}, %B{}, %B{}, %A{}, %A{}, %B{}]

我想把这些数据分成一个2元素的列表,包含:

[ [ %A{}, %A{}, %B{}, %B{}, %B{} ], [ %A{}, %A{}, %B{} ] ]

如果初始输入全部为A或B,则输出将保持不变,因为没有发生B->A转换。

我认为Enum.chunk_by/2是要走的路,但是我很难弄清楚如何维护前一个元素的上下文,以知道何时分裂。

这样的问题的惯用解决方案是什么样子的?

另一种方法是使用纯递归:

def collect_chunks([]), do: []
def collect_chunks(list) do
  {chunk, post_chunk} = collect_chunk(list)
  [chunk | collect_chunks(post_chunk)]
end
defp collect_chunk([]), do: {[], []}
defp collect_chunk([%B{} = last_element | [%A{} | _] = post_chunk]), do: {[last_element], post_chunk}
defp collect_chunk([el | rest]) do
  {remaining_chunk, post_chunk} = collect_chunk(rest)
  {[el | remaining_chunk], post_chunk}
end

另一种选择是chunk_by struct类型,然后再进行一次列表合并(除非列表包含%B{}):

def chunk(structs) do
  structs
  |> Enum.chunk_by(& &1.__struct__)
  |> merge()
end
# Don't merge when current is %B
defp merge([[%B{}|_]=h|t]), do: [h|merge(t)]
# Merge all others
defp merge([curr, next|t]), do: [curr ++ next|merge(t)]
# We are done
defp merge([]), do: []

Enum.chunk_by/2目前不提供对前一个元素的访问,所以在这种情况下我们不能使用Enum.chunk_by/2。我们将不得不退回到reduce/3

在所有Enum函数中,reduce/3是最灵活的,并且被大多数Enum函数内部使用。

下面是生成所需输出的一种方法,给定值[ %A{}, %A{}, %B{}, %B{}, %B{}, %A{}, %A{}, %B{} ]:

  values
  |> Enum.reduce([[]], fn (elem, acc) ->
    prev_list = List.first(acc)         
    prev_elem = List.first(prev_list)
    b_changed_to_a? = fn -> prev_elem.__struct__ == B && elem.__struct__ == A end
    if is_nil(prev_elem) || !b_changed_to_a?.() do
      List.replace_at(acc, 0, [elem|prev_list])
    else
      [[elem]|acc]      
    end
  end)
  |> Enum.map(&Enum.reverse/1)
  |> Enum.reverse

注意,我总是在列表前添加一个元素。这是因为在Elixir中添加列表是一个昂贵的操作。

希望这个解决方案有帮助!

相关内容

  • 没有找到相关文章

最新更新