Functional programming Erlang风格的N长度函数的子列表

我一直在学习Erlang并尝试完成一些练习函数。我很难做出一个特别的函数，我想这可能是因为我对“Erlang”的思考不够

该函数接受一个列表和一个子列表大小，然后生成一个元组列表，其中包含子列表前的元素数、子列表本身和子列表后的元素数。比如说

子列表（1[a，b，c]）=：=[{0[a]，2}，{1[b]，1}，{2[c]，0}]。
子列表（2[a，b，c]）=：=[{0[a，b]，1}，{1[b，c]，0}]。

我的工作解决方案是

子列表（子列表大小[H|T]）->
长度=长度（1，T），
子列表（子列表大小、长度、长度子列表大小[H | T]，]）。
子列表（_，_，-1，_，Acc）->列表：反向（Acc）；
子列表（子列表、长度、计数、[H|T]，Acc）->
Sub={Length SubSize Count，grab（SubSize[H | T]，]），Count}，
子列表（子列表、长度、计数-1、T、[Sub|Acc]）。
长度（N，[]）->N；
长度（N，[u124; T]）->长度（N+1，T）。
抓取（0，_，Acc）->列表：反向（Acc）；
抓取（N[H|T]，Acc）->抓取（N-1，T[H|Acc]）。

但感觉不对劲，我想知道是否有更好的方法

有一个扩展要求使用列表理解重新实现sublists函数。我的尝试失败了

子列表\u lc（子列表，L）->
长度=长度（0，L），
索引=列表：zip（L，列表：seq（0，长度-1）），
[{I，X，Length-1-SubSize}|{X，I}我在下面展示了几种方法。所有方法都可以防止请求的子列表长度大于列表长度的情况。所有方法都使用标准函数

第一种方法使用
lists:split/2
捕获每个子列表和剩余尾部列表的长度，并使用计数器
C
跟踪子列表前面的元素数量。剩余尾部列表的长度（名为
Rest
）给出每个子列表后面的元素数量

sublists(N,L) when N =< length(L)  ->
    sublists(N,L,[],0).
sublists(N,L,Acc,C) when N == length(L) ->
    lists:reverse([{C,L,0}|Acc]);
sublists(N,[_|T]=L,Acc,C) ->
    {SL,Rest} = lists:split(N,L),
    sublists(N,T,[{C,SL,length(Rest)}|Acc],C+1).

最后，这里是一个基于列表理解的解决方案。它与前面的解决方案类似，它使用两个计数器列表来控制迭代。它还使用
list:nthail/2
和
list:sublist/2
来获得每个子列表，这显然不是很有效；毫无疑问，它可以改进

sublists(N,L) when N =< length(L) ->
    Up = lists:seq(0,length(L)-N),
    Down = lists:reverse(Up),
    [{U,lists:sublist(lists:nthtail(U,L),N),D} || {U,D} <- lists:zip(Up,Down)].

当N=
向上=列表：序号（0，长度（L）-N），
向下=列表：反向（向上），
[{U，list:sublist（list:nthail（U，L），N），D}{U，D}
sublists(N,L) when N =< length(L) ->
    Up = lists:seq(0,length(L)-N),
    Down = lists:reverse(Up),
    [{U,lists:sublist(lists:nthtail(U,L),N),D} || {U,D} <- lists:zip(Up,Down)].