Erlang - Interleave auf die einfache Art

Question

Wie lassen sich drei Datensätze auf einfache/effiziente Weise verschachteln?

Data1 = [<<5>>,<<6>>,<<7>>],
Data2 = [<<5>>,<<6>>,<<7>>],
Data3 = [<<5>>,<<6>>,<<7>>].

Endergebnis:

Final = [<<5>>, <<5>>, <<5>>, <<6>>, <<6>>, <<6>>, <<7>>, <<7>>, <<7>>]

Ich bin sicher, es ist wie

[X || X <- [Data1, Data2, Data3]]

Answer 1

Sie können eine benutzerdefinierte zip Funktion, um dies zu erreichen.

zip([HX | TX], [HY | TY], [HZ | TZ]) -> [[HX, HY, HZ] | zip(TX, TY, TZ)];
zip([], [], []) -> [].

Diese Funktion funktioniert gut, solange die Länge der Eingänge gleich ist. Der Umgang mit unterschiedlich langen Eingängen erfordert etwas Tüftelei. Etwas wie dies:

zip(X, Y, Z) when length(X) =:= 0; length(Y) =:= 0; length(Z) =:= 0 -> [];
zip([HX | TX], [HY | TY], [HZ | TZ]) -> [[HX, HY, HZ] | zip(TX, TY, TZ)].

Nennen Sie es so:

7> my_module:zip(Data1, Data2, Data3).
[[<<5>>,<<5>>,<<5>>],
 [<<6>>,<<6>>,<<6>>],
 [<<7>>,<<7>>,<<7>>]]

Siehe auch: Funktion der Standardbibliothek lists:zip3 .

Answer 2

Funktion des Moduls:

zip3(X, Y, Z) when X =:= []; Y =:= []; Z =:= [] -> [];
zip3([HX | TX], [HY | TY], [HZ | TZ]) -> [ HX, HY, HZ | zip3(TX, TY, TZ)].

Dasselbe in der Schale:

F = fun(D1, D2, D3) ->
  G = fun(F, X, Y, Z) when X =:= []; Y =:= []; Z =:= [] -> [];
         (F, [HX | TX], [HY | TY], [HZ | TZ]) -> [ HX, HY, HZ | F(F, TX, TY, TZ)]
      end,
  G(G, D1, D2, D3)
end,                                                                              
Data1 = [<<5>>,<<6>>,<<7>>],
Data2 = [<<5>>,<<6>>,<<7>>],
Data3 = [<<5>>,<<6>>,<<7>>],
F(Data1, Data2, Data3).
[<<5>>,<<5>>,<<5>>,<<6>>,<<6>>,<<6>>,<<7>>,<<7>>,<<7>>]

Und natürlich können Sie das auch mit lists Modul:

lists:append(lists:zipwith3(fun(X, Y, Z) -> [X, Y, Z] end, Data1, Data2, Data3)).
[<<5>>,<<5>>,<<5>>,<<6>>,<<6>>,<<6>>,<<7>>,<<7>>,<<7>>]

Answer 3

Final = Data1 ++ Data2 ++ Data3.

Answer 4

Hier ist mein Versuch dazu. Damit können Sie so viele Datensätze hinzufügen, wie Sie wollen, fügen Sie sie einfach zu einer Liste hinzu. Es wird auch berücksichtigt, wenn die Listen unterschiedlich groß sind. Wahrscheinlich ist es effizienter, das neue Binärmodul zu verwenden, anstatt die Binärdaten in 1-Byte-Listen aufzuteilen, wenn die Binärdaten groß sein können oder es sich um eine sehr häufige Funktion handelt.

-module(zippy).
-compile(export_all).

zipAll(L) -> zip({L,[]}).
zip({L,Final}) ->
    case lists:any(fun(X) -> case X of [] -> false; _ -> true end end,L) of
        true -> zip(lists:mapfoldl(fun x/2,Final,L));
        _ -> lists:reverse(Final)
    end.

x([],L) -> {[],[null|L]};
x([H|T],L) -> {T,[H|L]}.

start() ->
    Data1 = [<<5>>,<<6>>,<<7>>],
    Data2 = [<<5>>,<<6>>,<<7>>],
    Data3 = [<<5>>,<<6>>,<<7>>],
    Data4 = [<<5>>,<<6>>,<<7>>,<<1>>],
    zipAll([Data1,Data2,Data3,Data4]).

Sie denken an Listenauffassungen [{X,Y,Z} || X <Daten1, Y<Daten2,Z<- Daten3]] die eher dazu dienen, alle Möglichkeiten zu generieren, bei denen die Reihenfolge keine Rolle spielt.