Un moyen rapide de comparer deux listes et d'identifier les éléments peu communsQuelqu'un connaît-il un moyen rapide de comparer deux listes et d'identifier les différents éléments de la liste (c'est-à-dire les éléments peu communs) ?Je peux le faire en utilisant deux boucles imbriquées, mais comme beaucoup de choses en JSL, j'espérais qu'il pourrait y avoir un moyen obscur et plus simple. DJ
Mes listes sont bien sûr beaucoup plus grandes que cela :
list1={"pomme","poire","orange","kiwi","pastèque"};
list2={"pomme","poire","orange","kiwi","fraise","pastèque"};
Trouvez des éléments différents/peu communs, dans ce cas « fraise ».
Re : Un moyen rapide de comparer deux listes (éléments peu communs) ?Vous devrez le comparer pour différentes tailles et pour différentes approches de boucle JSL. Je suppose qu'entre 2 et 10 éléments de l'ensemble seraient plus rapides avec le tableau associatif. À la taille 1, le tableau associatif est excessif, mais il se construit quand même assez rapidement... environ un million par seconde...
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
Vous ne pouvez probablement pas exécuter plus de 20 à 30 instructions JSL simples pour chaque tableau associatif que vous créez.
Re : Un moyen rapide de comparer deux listes (éléments peu communs) ?Petite question à ce sujet : le temps gagné en utilisant le tableau associatif par rapport à la boucle est-il presque toujours supérieur à la surcharge nécessaire pour créer le tableau associatif par rapport à la liste ?
Re : Un moyen rapide de comparer deux listes (éléments peu communs) ?Et cette méthode peu courante ne nécessite pas de trouver d’abord l’intersection. C'est juste la différence.
set1=associativearray({"apple","grape","orange","kiwi","watermelon"});
set2=associativearray({"apple","pear","orange","kiwi","strawberry","watermelon"});
uncommon1 = set1; uncommon1<<REMOVE></REMOVE>Re : Un moyen rapide de comparer deux listes (éléments peu communs) ?Aussi : si les membres de l'ensemble sont nommés avec des entiers consécutifs, commençant à 1, ce problème pourrait être résolu très efficacement avec une matrice. Mais, comme présenté avec les membres d'un ensemble nommé, un tableau associatif est probablement meilleur que le tri, et certainement meilleur qu'une paire N^2 de boucles imbriquées.
Re : Un moyen rapide de comparer deux listes (éléments peu communs) ?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;
Les tableaux associatifs sont très efficaces pour des millions de valeurs, surtout par rapport à l'écriture d'un script JSL qui boucle sur des millions de valeurs.
L'index de script contient les détails du tableau associatif utilisé comme ensemble. Voici les objets peu courants :
set1=associativearray({"apple","grape","orange","kiwi","watermelon"});
set2=associativearray({"apple","pear","orange","kiwi","strawberry","watermelon"});
intersection=set1;intersection<<INTERSECT></INTERSECT>
Re : Un moyen rapide de comparer deux listes (éléments peu communs) ?@MS :
Cette solution que vous avez proposée m’a été extrêmement utile à bien des égards jusqu’à présent et je tiens d’abord à vous en remercier.
Je voudrais également savoir que lorsque nous traitons de très grands ensembles de données (par exemple quelques millions d'éléments chacun), cette approche nécessitera de grandes quantités de mémoire et l'insertion des éléments dans une nouvelle table ne semble pas efficace. Existe-t-il un moyen plus efficace d'identifier les éléments inhabituels entre deux colonnes de deux tableaux de données, c'est-à-dire si la colonne 1 du tableau de données 1 (dt1) et la colonne 1 du tableau de données 2 (dt2) contiennent une grande liste de nombres, pouvons-nous les comparer dans une manière plus efficace ?
Meilleur
aujourd'hui
Re : Un moyen rapide de comparer deux listes (éléments peu communs) ?<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />J'aimerais le savoir aussi. Les éléments courants peuvent être trouvés avec Intersect() (voir ci-dessous) mais je ne connais pas de fonction correspondante pour les éléments peu courants.
Il existe plus d'options pour les tableaux de données que pour les listes. Le script ci-dessous identifie les éléments inhabituels via une table de données temporaire. C'est peut-être plus rapide que de parcourir de longues listes mais je n'ai pas comparé
liste1 = { "pomme" , "poire" , "orange" , "kiwi" , "pastèque" , "mangue" } ;
liste2 = { "pomme" , "poire" , "kiwi" , "orange" , "fraise" , "pastèque" , "melon" } ;
dt = Nouveau tableau ( "température" ,
Nouvelle colonne ( "gr" , personnage , définir des valeurs ( liste1 || liste2 ) ) ,
Nouvelle colonne ( "n°" , numérique , formule ( 1 ) , formule d'évaluation ) ,
invisible
) ;
Résumer ( g = par ( dt : gr ) , n = Compter ( dt : n° ) ) ;
not_in_common = g [ Lieu ( Comme liste ( n ) , 1 )] ;
commun = Tableau associatif ( liste1 ) << couper ( Tableau associatif ( liste2 ) ) << récupérer les clés ;
Montrer ( commun , not_in_common ) ;
Fermer ( dt , nosave ) ;
