Summe aller Elemente in einer Liste, ohne bereits berechnete Elemente zu wiederholen

Question

Ich versuche, auf das Ergebnis zu kommen, was eine doppelte for-Schleife in einer anderen Sprache wäre (Java oder JavaScript zum Beispiel).

So ist die nächste, die ich mit oben kommen kann ist so etwas wie dieses:

1> L = [1,2,3]. 
[1,2,3] 
2> R = [X + Y || X <- L, Y <- L]. 
[2,3,4,3,4,5,4,5,6] 
3> 

... aber was ich wirklich will, ist: [3,4,5]. Ich will nicht, um die Elemente summieren, die bereits hinzugefügt wurden:

A1 + A2 
A2 + A3 
A2 + A1 [already computed, position switched] 
A2 + A3 [already computed, position switched] 
A3 + A1 
A3 + A2 [already computed, position switched] 

Vielen Dank im Voraus ...

Answer 1

TL; DR

[X+Y || X <- L, Y <- L, Y > X]. 

Andere Lösungen

Sie möchten im Wesentlichen zwei Iteratoren neben der gleichen Datenstruktur und einem Akkumulator zu Colle gehen cts Summen von Unterscheidungselementen. Es gibt keinen Grund, warum Sie nicht so Iteratoren in Erlang zu imitieren wären in der Lage:

-module(sum2). 
-export([start/1]). 

start(Max) -> 
    L = lists:seq(1, Max), 
    T = list_to_tuple(L), 
    do_sum(T, 1, 2, size(T), []). 

do_sum(T, X, S, S, A) when X + 1 =:= S -> 
    lists:reverse([mk_sum(X, S, T) | A]); 
do_sum(T, X, S, S, A) -> 
    do_sum(T, X + 1, X + 2, S, [mk_sum(X, S, T) | A]); 
do_sum(T, X, Y, S, A) -> 
    do_sum(T, X, Y + 1, S, [mk_sum(X, Y, T) | A]). 

mk_sum(X, Y, T) -> element(X, T) + element(Y, T). 

Das Ergebnis:

7> c(sum2). 
{ok,sum2} 
8> sum2:start(3). 
[3,4,5] 
9> sum2:start(5). 
[3,4,5,6,5,6,7,7,8,9] 

Es gibt tatsächlich eine einfachere Lösung, wenn Sie nicht über eine Liste von Elemente, die Sie summieren möchten aber nur ganze Zahlen:

-module(sum3). 
-export([start/1]). 

start(Max) -> do_sum(1, 2, Max, []). 

do_sum(X, S, S, A) when X + 1 =:= S -> lists:reverse([X + S | A]); 
do_sum(X, S, S, A) -> do_sum(X + 1, X + 2, S, [X + S | A]); 
do_sum(X, Y, S, A) -> do_sum(X, Y + 1, S, [X + Y | A]). 

Oder sogar eine einfachere Lösung mit nur Liste Verständnis:

4> L = [1, 2, 3]. 
[1,2,3] 
5> [X+Y || X <- L, Y <- L, Y > X]. 
[3,4,5] 
6> f(). 
ok 
7> L = [1,2,3,4,5]. 
[1,2,3,4,5] 
8> [X+Y || X <- L, Y <- L, Y > X]. 
[3,4,5,6,5,6,7,7,8,9] 

Überprüfen Sie auch diese Frage, Erlang; list comprehension without duplicates, die ein ähnliches Problem angeht und mehr Ideen für mögliche Lösungen hat.