Il modo migliore per convertire una lista piatta in un set di due tuple in Erlang?

Question

C'è un modo veloce per convertire una lista semplice in una lista di due tuple in modo tale che una lista semplice come [1,2,3,4,5,6] diventa [{1,2}, {3,4 }, {5,6}]?

Questo funziona, ma ci si sente SBAGLIATO semplicemente:

tuples_from_flat_list(Target) -> 
    TargetWithIndex = lists:zip(lists:seq(1, length(Target)), Target), 
    {K, V} = lists:partition(fun({I, _}) -> I rem 2 == 1 end, TargetWithIndex), 
    lists:zipwith(fun({_, X}, {_, Y}) -> {X, Y} end, K, V). 

Answer 1

Questa versione è più efficiente di approccio 'dritti' con le liste concatenazione proposto in precedenza:

combine(L) when length(L) rem 2 == 0 -> combine([], L). 
combine(Acc, []) -> lists:reverse(Acc); 
combine(Acc, [H1,H2|T]) -> combine([{H1, H2}|Acc], T). 

benchmark:

combine.erl

-module(combine). 
-export([reverse/1, straight/1, test/2]). 

test(F, L) -> {Micros, _} = timer:tc(?MODULE, F, [L]), Micros. 

reverse(L) when length(L) rem 2 == 0 -> reverse([], L).         
straight(L) when length(L) rem 2 == 0 -> straight([], L). 

reverse(Acc, []) -> lists:reverse(Acc); 
reverse(Acc, [H1, H2 | T]) -> reverse([{H1, H2} | Acc], T). 

straight(Acc, []) -> Acc; 
straight(Acc, [H1, H2 | T]) -> straight(AcC++ [{H1, H2}], T). 

uscita:

130> combine:test(reverse, lists:seq(1,1000)). 
34 
131> combine:test(straight, lists:seq(1,1000)). 
1772 

Answer 2

tuples_from_flat_list(List) -> tuples_from_flat_list(List, []). 

tuples_from_flat_list([], Result) -> lists:reverse(Result). 
tuples_from_flat_list([X, Y|T], Acc) -> tuples_from_flat_list(T, [{X, Y}|Acc]). 

E 'meglio e più veloce.

Answer 3

L'approccio più breve e più concisa:

pair_up([A, B | Tail]) -> 
    [{A,B} | pair_up(Tail)]; 
pair_up([]) -> 
    []. 

O la versione più lunga che trasporta un accumulatore, ma ancora molto idiomatica Erlang:

pair_up(List) -> 
    pair_up(List, []). 

pair_up([A, B | Tail], Acc) -> 
    pair_up(Tail, [{A,B} | Acc]); 
pair_up([], Acc) -> 
    lists:reverse(Acc). 

Vedere questa sezione nella guida efficienza erlang "Myth: Tail-recursive functions are MUCH faster than recursive functions".

Come si noterà, entrambi gli approcci determinano un'uscita "badarg" quando vengono chiamati con un elenco di lunghezze irregolari. Questo è probabilmente auspicabile da una prospettiva a prova di errore.

Leggere anche "Myth: '++' is always bad" per capire perché accumuliamo l'accumulatore al contrario solo per invertire quando viene eseguito, anziché accodare alla fine dell'elenco.