Un modo rapido per confrontare due elenchi e identificare gli elementi non comuniQualcuno conosce un modo rapido per confrontare due elenchi e identificare eventuali elementi diversi dell'elenco (ovvero elementi non comuni)?Posso farlo utilizzando due cicli nidificati, ma come molte cose in JSL speravo che potesse esserci un modo oscuro e più semplice. DJ
Le mie liste sono molto più grandi di questa ovviamente:
list1={"mela","pera","arancia","kiwi","anguria"};
list2={"mela","pera","arancia","kiwi","fragola","anguria"};
Trova eventuali elementi diversi/non comuni, in questo caso "fragola".
Ri: Modo rapido per confrontare due elenchi (elementi non comuni)?Dovresti confrontarlo per dimensioni diverse e per diversi approcci al loop JSL. Immagino che da qualche parte tra 2 e 10 elementi nel set sarebbero più veloci con l'array associativo. Alla dimensione 1, l'array associativo è eccessivo, ma si costruisce comunque piuttosto velocemente... circa un milione al secondo...
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
Probabilmente non puoi eseguire più di 20-30 semplici istruzioni JSL per ogni array associativo che crei.
Ri: Modo rapido per confrontare due elenchi (elementi non comuni)?Domanda veloce per questo: il tempo risparmiato utilizzando l'array associativo rispetto al ciclo è praticamente sempre maggiore del sovraccarico necessario per creare l'array associativo rispetto all'elenco?
Ri: Modo rapido per confrontare due elenchi (elementi non comuni)?E il metodo insolito non richiede prima di trovare l'intersezione. È proprio la differenza.
set1=associativearray({"apple","grape","orange","kiwi","watermelon"});
set2=associativearray({"apple","pear","orange","kiwi","strawberry","watermelon"});
uncommon1 = set1; uncommon1<<REMOVE></REMOVE>Ri: Modo rapido per confrontare due elenchi (elementi non comuni)?Inoltre: se i membri dell'insieme vengono nominati con numeri interi consecutivi, a partire da 1, questo problema potrebbe essere risolto in modo molto efficiente con una matrice. Ma, come presentato con i membri di un insieme con nome, un array associativo è probabilmente migliore dell'ordinamento e sicuramente migliore di una coppia N ^ 2 di cicli nidificati.
Ri: Modo rapido per confrontare due elenchi (elementi non comuni)?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;
Gli array associativi sono ottimi per milioni di valori, soprattutto rispetto alla scrittura di uno script JSL che esegue il loop su milioni di valori.
L'indice di scripting contiene i dettagli per l'array associativo utilizzato come set. Ecco gli oggetti non comuni:
set1=associativearray({"apple","grape","orange","kiwi","watermelon"});
set2=associativearray({"apple","pear","orange","kiwi","strawberry","watermelon"});
intersection=set1;intersection<<INTERSECT></INTERSECT>
Ri: Modo rapido per confrontare due elenchi (elementi non comuni)?@SM :
La soluzione che mi hai offerto mi è stata estremamente utile finora in molti modi diversi e voglio innanzitutto ringraziarti per questo.
Vorrei anche verificare che quando abbiamo a che fare con insiemi di dati molto grandi (ad esempio un paio di milioni di elementi ciascuno), questo approccio richiederà grandi quantità di memoria e l'inserimento degli elementi in una nuova tabella non sembra efficiente. Esiste un modo più efficace per identificare elementi non comuni tra due colonne in due tabelle dati, ovvero se la colonna 1 nella tabella dati 1 (dt1) e la colonna 1 nella tabella dati 2 (dt2) hanno un ampio elenco di numeri, possiamo confrontarli in un modo più efficace?
Migliore
oggi
Ri: Modo rapido per confrontare due elenchi (elementi non comuni)?<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />Vorrei saperlo anch'io. Gli elementi comuni possono essere trovati con Intersect() (vedi sotto) ma non sono a conoscenza di una funzione corrispondente per elementi non comuni.
Sono disponibili più opzioni per le tabelle di dati che per gli elenchi. Lo script seguente identifica gli elementi non comuni tramite un datatable temporaneo. Potrebbe essere più veloce che scorrere lunghi elenchi, ma non ho confrontato
elenco1 = { "mela" , "Pera" , "arancia" , "kiwi" , "anguria" , "Mango" } ;
elenco2 = { "mela" , "Pera" , "kiwi" , "arancia" , "fragola" , "anguria" , "melone" } ;
dt = Nuova tabella ( "temp" ,
Nuova colonna ( "gr" , carattere , valori impostati ( elenco1 || elenco2 ) ) ,
Nuova colonna ( "nr" , numerico , formula ( 1 ) , evalformula ) ,
invisibile
) ;
Riassumere ( G = di ( dt : gr ) , N = Contare ( dt : n ) ) ;
non_in_comune = G [ Loc ( Come elenco ( N ) , 1 )] ;
comune = Matrice associativa ( elenco1 ) << intersecare ( Matrice associativa ( lista2 ) ) << getkeys ;
Spettacolo ( comune , non_in_comune ) ;
Vicino ( dt , nosalva ) ;
