5811_de-DE

liliconcom

Schnelle Möglichkeit, zwei Listen zu vergleichen und die ungewöhnlichen Elemente zu identifizieren

Kennt jemand eine schnelle Möglichkeit, zwei Listen zu vergleichen und unterschiedliche Listenelemente (dh ungewöhnliche Elemente) zu identifizieren?Ich kann dies mit zwei verschachtelten Schleifen tun, aber wie bei vielen Dingen in JSL hatte ich gehofft, dass es vielleicht eine obskure, einfachere Möglichkeit gibt. DJ

 

Meine Listen sind natürlich viel größer als diese:

list1={"Apfel", "Birne", "Orange", "Kiwi", "Wassermelone"};

list2={"Apfel", "Birne", "Orange", "Kiwi", "Erdbeere", "Wassermelone"};

 

Suchen Sie nach unterschiedlichen/ungewöhnlichen Elementen, in diesem Fall „Erdbeere“.

Betreff: Schnelle Möglichkeit, zwei Listen zu vergleichen (ungewöhnliche Elemente)?

Sie müssten es für verschiedene Größen und für verschiedene JSL-Loop-Ansätze vergleichen. Ich würde vermuten, dass irgendwo zwischen 2 und 10 Elemente im Set mit dem assoziativen Array schneller wären. Bei Größe 1 ist das assoziative Array übertrieben, aber es baut sich immer noch ziemlich schnell auf ... etwa eine Million pro Sekunde ...

start = tickseconds();
for(i=1,i<=1e6,i++,
a=associativearray({"a","b"});
b=associativearray({"a","b"});
c=associativearray({"a","b"});
d=associativearray({"a","b"});
e=associativearray({"a","b"}); 
);
stop=tickseconds();
aatime=(stop-start);
write("\!ntime for 5,000,000 associative arrays:",aatime);

start = tickseconds();
for(i=1,i<=1e6,i++,
a=1;
b=2;
c=3;
d=4;
e=5; 
);
stop=tickseconds();
satime=(stop-start);
write("\!ntime for 5,000,000 simple assingments:",satime);

write("\!nsimple/associative=", satime/aatime);

/*:

time for 5,000,000 associative arrays:5.8166666666657
time for 5,000,000 simple assingments:0.283333333325572
simple/associative=0.0487106017178716

Sie können wahrscheinlich nicht mehr als etwa 20–30 einfache JSL-Anweisungen für jedes von Ihnen erstellte assoziative Array ausführen.

Betreff: Schnelle Möglichkeit, zwei Listen zu vergleichen (ungewöhnliche Elemente)?

Kurze Frage dazu: Ist die Zeitersparnis bei Verwendung des assoziativen Arrays im Vergleich zur Schleife so ziemlich immer größer als der Aufwand, der zum Erstellen des assoziativen Arrays im Vergleich zur Liste erforderlich ist?  

Betreff: Schnelle Möglichkeit, zwei Listen zu vergleichen (ungewöhnliche Elemente)?

Und die ungewöhnliche Methode erfordert nicht, zuerst die Kreuzung zu finden. Es ist einfach der Unterschied.

set1=associativearray({"apple","grape","orange","kiwi","watermelon"});
set2=associativearray({"apple","pear","orange","kiwi","strawberry","watermelon"});
uncommon1 = set1; uncommon1<<REMOVE></REMOVE>

Betreff: Schnelle Möglichkeit, zwei Listen zu vergleichen (ungewöhnliche Elemente)?

Außerdem: Wenn die Mitglieder der Menge mit aufeinanderfolgenden ganzen Zahlen beginnend bei 1 benannt werden, könnte dieses Problem sehr effizient mit einer Matrix gelöst werden. Aber wie bei benannten Mengenmitgliedern dargestellt, ist ein assoziatives Array wahrscheinlich besser als das Sortieren und definitiv besser als ein N^2-Paar verschachtelter Schleifen.

Betreff: Schnelle Möglichkeit, zwei Listen zu vergleichen (ungewöhnliche Elemente)?

set1=associativearray({"apple","grape","orange","kiwi","watermelon"});
set2=associativearray({"apple","pear","orange","kiwi","strawberry","watermelon"});
set3=associativearray({"apple","pear","watermelon"});
intersection=set1;intersection<<INTERSECT></INTERSECT>

"common (intersection) items:"
{"apple", "kiwi", "orange", "watermelon"}
"all (union) items"
{"apple", "grape", "kiwi", "orange", "pear", "strawberry", "watermelon"}
set1HasSet3 << Contains(set3) = 0;
set2HasSet3 << Contains(set3) = 1;

Die assoziativen Arrays eignen sich sehr gut für Millionen von Werten, insbesondere im Vergleich zum Schreiben eines JSL-Skripts, das Millionen von Werten in einer Schleife durchläuft.

 

Der Skriptindex enthält die Details für das assoziative Array, das als Satz verwendet wird. Hier sind die ungewöhnlichen Gegenstände:

set1=associativearray({"apple","grape","orange","kiwi","watermelon"});
set2=associativearray({"apple","pear","orange","kiwi","strawberry","watermelon"});
intersection=set1;intersection<<INTERSECT></INTERSECT>

 

Betreff: Schnelle Möglichkeit, zwei Listen zu vergleichen (ungewöhnliche Elemente)?

@MS :

Diese von Ihnen angebotene Lösung war für mich bisher in vielerlei Hinsicht äußerst hilfreich und ich möchte Ihnen zunächst dafür danken.

Ich möchte auch wissen, dass dieser Ansatz viel Speicher erfordert, wenn wir es mit wirklich großen Datensätzen zu tun haben (z. B. jeweils ein paar Millionen Elemente), und dass das Einfügen der Elemente in eine neue Tabelle nicht effizient erscheint. Gibt es eine effektivere Möglichkeit, ungewöhnliche Elemente zwischen zwei Spalten in zwei Datentabellen zu identifizieren, z. B. wenn Spalte 1 in Datentabelle 1 (dt1) und Spalte 1 in Datentabelle 2 (dt2) eine große Liste von Zahlen haben, können wir sie vergleichen? ein effektiverer Weg?

 

Am besten
Uday

Betreff: Schnelle Möglichkeit, zwei Listen zu vergleichen (ungewöhnliche Elemente)?<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />

Das würde ich auch gerne wissen. Häufige Elemente können mit Intersect() gefunden werden (siehe unten), mir ist jedoch keine entsprechende Funktion für ungewöhnliche Elemente bekannt.

Für Datentabellen gibt es mehr Optionen als für Listen. Das folgende Skript identifiziert die ungewöhnlichen Elemente über eine temporäre Datentabelle. Es ist vielleicht schneller als das Durchlaufen langer Listen, aber ich habe es nicht verglichen

Liste1 = { "Apfel" , "Birne" , "orange" , "Kiwi" , "Wassermelone" , "Mango" } ;

Liste2 = { "Apfel" , "Birne" , "Kiwi" , "orange" , "Erdbeere" , "Wassermelone" , "Melone" } ;

dt = Neuer Tisch ( „Temp“ ,

Neue Spalte ( "GR" , Charakter , Setwerte ( Liste1 || Liste2 ) ) ,

Neue Spalte ( „Nr.“ , numerisch , Formel ( 1 ) , Bewertungsformel ) ,

unsichtbar

) ;

Zusammenfassen ( G = von ( dt : GR ) , N = Zählen ( dt : Nr ) ) ;

not_in_common = G [ Ort ( Als Liste ( N ) , 1 )] ;

gemeinsam = Assoziatives Array ( Liste1 ) << schneiden ( Assoziatives Array ( Liste2 ) ) << getkeys ;

Zeigen ( gemeinsam , not_in_common ) ;

Schließen ( dt , nosave ) ;