Randomiser une liste<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />J'ai besoin de randomiser une liste.
randomizeList = Function({List}, {Default Local},
// Le code va ici
retourner la liste ;
);
liste = {1,2,3,4,5} ;
randomList = randomizeList(liste);
print(randomList); // Sortie attendue quelque chose comme {2,4,5,1,3}
Il existe de nombreuses façons de le faire et aucune mauvaise réponse.J'apprécie tout commentaire, merci !
Re : randomiser une listeaime les lignes droites; le comportement N^2 pour les listes est corrigé !
Re : randomiser une liste
J'ai augmenté la taille des listes pour aider à différencier un peu mieux, bien que les différences entre les méthodes ne soient pas si grandes. Ce qui est surprenant, ce sont les différences de temps entre les résultats ci-dessus et ceux-ci. De plus, il semble étrange que la méthode de pmroz soit plus lente avec 100 lignes qu'avec 10 000. Peut-être est-ce dû à la répétition de la tâche de faire la table ?
JMP 13 bêta 8
Mac 2,5 GHz Intel Core i7
16 Go de mémoire DDR3 à 1 600 MHz
| N articles | pmroz | Jef | Byron | Phil |
| 100 | 0.1833333333 | 0 | 0 | 0 |
| 1000 | 0 | 0 | 0 | 0 |
| 10000 | 0.0166666667 | 0 | 0 | 0 |
| 50000 | 0,05 | 0.0166666667 | 0 | 0.0166666667 |
| 100000 | 0,1 | 0.0333333333 | 0.0333333333 | 0.0333333333 |
| 500000 | 0,6 | 0.2333333333 | 0.1666666667 | 0.2666666667 |
| 1000000 | 1.3166666667 | 0.5166666667 | 0.3666666667 | 0.5666666667 |
| 10000000 | 17.633333333 | 6.1833333333 | 4.3 | 7.15 |
Re : randomiser une listeLe code ci-dessous compare les quatre algorithmes.Les données sont stockées dans un tableau puis représentées graphiquement.Je suis curieux de savoir à quoi cela ressemble dans JMP 13 ?
// version pmroz
pmroz_randomizeList = Fonction ({ une liste } , { Locale par défaut } ,
nr = articles ( une liste ) ;
dt = Nouveau tableau ( "" , privé , Ajouter des lignes ( nr ) ,
Nouvelle colonne ( "Données" , Numérique , Continu , Format ( "Meilleur" , 12 ) ,
Définir les valeurs ( une liste ) ) ,
Nouvelle colonne ( "Aléatoire" , Numérique , Continu , Format ( "Meilleur" , 12 ) ,
Formule ( Uniforme aléatoire () ) )
) ;
dt << trier ( remplacer le tableau , par ( : Randomisé )) ;
liste_aléatoire = dt : Données << obtenir des valeurs ;
) ;
// Jeff Perkinson 13 juillet 2016 14h00 (en réponse à Peter Mroz)
jeff_randomizeList = Fonction ({ une liste } , { Locale par défaut } ,
une liste [ rang ( j ( articles ( une liste ) , 1 , uniforme aléatoire ()))]
) ;
// Fonction de Byron
byron_randomizeList = Fonction ({ une liste } , { Locale par défaut } ,
nr = articles ( une liste ) ;
rslist = mélange aléatoire ( 1 :: nr ) ;
cloque = une liste [ rslist [ 1 :: nr ]] ;
) ;
// Philip Brown 14 juillet 2016 09h50
phil_randomizeList = Fonction ({ une liste } , { Locale par défaut } ,
une liste [ rang ( Répéter ({ uniforme aléatoire ()} , articles ( une liste ) ) )]
) ;
nlist = { 100 , 1000 , 10000 , 20000 , 30000 , 40000 , 50000 , 70000 } ;
dt = nouveau tableau ( "Liste aléatoire" , Ajouter des lignes ( articles ( nlist ) ) ,
Nouvelle colonne ( "N éléments" , Numérique , Continu , Format ( "Meilleur" , 12 ) ) ,
Nouvelle colonne ( "pmroz" , Numérique , Continu , Format ( "Meilleur" , 12 ) ) ,
Nouvelle colonne ( "Jef" , Numérique , Continu , Format ( "Meilleur" , 12 ) ) ,
Nouvelle colonne ( "Byron" , Numérique , Continu , Format ( "Meilleur" , 12 ) ) ,
Nouvelle colonne ( « Phil » , Numérique , Continu , Format ( "Meilleur" , 12 ) )
) ;
pour ( je = 1 , je <= articles ( nlist ) , je ++,
nm = nlist [ je ] ;
dt : N articles [ je ] = nm ;
ma liste = ( sous forme de liste ( 1 :: nm ))[ 1 ] ;
début = tick secondes () ;
liste aléatoire = pmroz_randomizeList ( ma liste ) ;
écoulé = tick secondes () - début ;
dt : pmroz [ je ] = écoulé ;
Attendez ( 0 ) ;
début = tick secondes () ;
liste aléatoire = jeff_randomizeList ( ma liste ) ;
écoulé = tick secondes () - début ;
dt : Jef [ je ] = écoulé ;
Attendez ( 0 ) ;
début = tick secondes () ;
liste aléatoire = byron_randomizeList ( ma liste ) ;
écoulé = tick secondes () - début ;
dt : Byron [ je ] = écoulé ;
Attendez ( 0 ) ;
début = tick secondes () ;
liste aléatoire = phil_randomizeList ( ma liste ) ;
écoulé = tick secondes () - début ;
dt : Phil [ je ] = écoulé ;
Attendez ( 0 ) ;
) ;
dt << Générateur de graphiques ( Afficher le panneau de configuration ( 0 ) ,
variables ( X ( : N articles ) , Oui ( : pmroz ) , Oui ( : Jef , Position ( 1 ) ) , Oui ( : Byron , Position ( 1 ) ) ,
Oui ( : Phil , Position ( 1 ) ) ) ,
Éléments ( Points ( X , Oui ( 1 ) , Oui ( 2 ) , Oui ( 3 ) , Oui ( 4 ) , Légende ( 1 ) , Gigue ( 1 ) ) ,
Plus lisse ( X , Oui ( 1 ) , Oui ( 2 ) , Oui ( 3 ) , Oui ( 4 ) , Légende ( 2 ) ) )
) ;
Re : randomiser une listeLes tables privées sont super utiles, mais soyez prudent, car chaque table contient moins de mémoire ; ils sont plus difficiles à suivre.Vous pouvez rapidement prendre beaucoup de mémoire en créant et en ouvrant des tables privées et il est facile de passer à côté car elles n'ont pas de fenêtre physique (comme dans mon exemple ci-dessus).
Cependant, ils peuvent vous faire gagner beaucoup de temps car vous n'avez pas besoin de les fermer, vous pouvez simplement réaffecter la variable qui les contient (ce que je voulais faire ci-dessus mais je n'avais pas réalisé que votre fonction avait un {Default Local} -- DOH !).
À partir du guide de script :
Tables de données privées
Masquez complètement la table de données en incluant l'argument privé :
dt = Open( "$SAMPLE_DATA/Big Class.jmp", "private" );
Rendre une table privée peut éviter des problèmes de mémoire lorsqu'un script s'ouvre et se ferme plusieurs
les tables. Les tables de données privées n'ont pas de fenêtre physique, donc moins de mémoire est nécessaire qu'avec
tableaux invisibles.
Comme pour les tables invisibles, les analyses exécutées sur une table de données privée sont liées à la table.
Pour éviter de perdre une table de données privées, vous devez lui affecter une référence comme indiqué dans le précédent
Exemple. Sinon, JMP supprime immédiatement la table de données privées de la mémoire.
Les utilisations supplémentaires de la table ultérieurement dans le script génèrent des erreurs.
Re : randomiser une listeEncore une autre façon....
// Philip Brown 14 juillet 2016 09h50
phil_randomizeList = Fonction ({aListe},{Local par défaut},
une liste[ rang ( Répéter ({ uniforme aléatoire ()}, articles (une liste) ) )]
);
Je ne pense pas que ce soit plus rapide que la fonction intégrée Random Shuffle, mais j'ai toujours aimé utiliser Repeat({}, n) pour générer des listes pour certaines applications.
Re : randomiser une listeLa privé mot-clé est intéressant - la table n'apparaît même pas dans la liste des fenêtres.J'imagine que cela économise un peu de mémoire.Je peux l'utiliser dans un tas d'endroits.Merci msharp!
Re : randomiser une listeAinsi, le changement d'insertion dans JMP 13 résoudra le même problème ?C'est une super nouvelle!
Re : randomiser une listeLes fonctions de table sont très efficaces pour les grands ensembles de données.L'une des principales raisons est que b/c JMP tire parti de plusieurs cœurs alors que JSL ne le fait pas.Cependant, pour les petits ensembles de données, le processus de création de la table ajoute beaucoup de surcharge.Pour l'application pour laquelle j'utilise ceci, j'avais en fait quelque chose de similaire à la réponse de PMroz, mais comme mes listes étaient toutes <1000 éléments, j'ai remarqué que cela prenait un peu de temps.
Merci tout le monde!
Remarque : Today() n'est précis qu'à la seconde près, Tick Seconds() est précis au 1/60 de seconde et HP TIME() est précis à la microseconde près.Bien sûr, tout dépend de votre ordinateur.De plus, pour donner un avantage équitable, j'ai changé vos tables en privé et supprimé l'instruction close, ce qui accélérera votre script.
Noms par défaut ici ( 1 ) ;
// version pmroz
pmroz_randomizeList = Fonction ({ une liste } , { Locale par défaut } ,
dt = Nouveau tableau ( "" , privé ,
Nouvelle colonne ( "Données" , Définir les valeurs ( une liste ) ) ,
Nouvelle colonne ( "Aléatoire" , Numérique , Continu , Formule ( Uniforme aléatoire () ) )
) ;
dt << trier ( remplacer le tableau , par ( : Randomisé )) ;
liste_aléatoire = dt : Données << obtenir des valeurs ;
) ;
// Jeff Perkinson 13 juillet 2016 14h00 (en réponse à Peter Mroz)
jeff_randomizeList = Fonction ({ une liste } , { Locale par défaut } ,
une liste [ rang ( j ( articles ( une liste ) , 1 , uniforme aléatoire ()))]
) ;
// Fonction de Byron
byron_randomizeList = Fonction ({ une liste } , { Locale par défaut } ,
nr = articles ( une liste ) ;
rslist = mélange aléatoire ( 1 :: nr ) ;
cloque = une liste [ rslist [ 1 :: nr ]] ;
) ;
nm = 100 ; // Fixe le nombre d'éléments de la liste
imax = 100 ; // Définir le nombre d'itérations
ma liste = ( sous forme de liste ( 1 :: nm ))[ 1 ] ;
début = HP TEMPS () ;
Pour ( je = 1 , je <= imax , je ++,
liste aléatoire = pmroz_randomizeList ( ma liste ) ;
) ;
écoulé = HP TEMPS () - début ;
imprimer ( "pmroz:" || carboniser ( écoulé )) ;
Attendez ( 0 ) ;
début = HP TEMPS () ;
Pour ( je = 1 , je <= imax , je ++,
liste aléatoire = jeff_randomizeList ( ma liste ) ;
) ;
écoulé = HP TEMPS () - début ;
imprimer ( « Jeff : » || carboniser ( écoulé )) ;
Attendez ( 0 ) ;
début = HP TEMPS () ;
Pour ( je = 1 , je <= imax , je ++,
liste aléatoire = byron_randomizeList ( ma liste ) ;
) ;
écoulé = HP TEMPS () - début ;
imprimer ( « Byron : » || carboniser ( écoulé )) ;
Attendez ( 0 ) ;
//PRODUCTION
"pmroz: 121646"
"Jeff : 3990"
"Byron : 3488"
Re : randomiser une listeles résultats changeront dans JMP 13.
Liste rapide
400 000 ressemble à ceci dans JMP 13 :
"pmroz : 0,533333333332848"
"Jeff : 0.233333333333576"
"Byron : 0.216666666667152"
Re : randomiser une listeTrès intéressant.Ma solution de table semblait une sorte de force brute, mais elle surpasse les deux autres fonctions lorsque le nombre d'éléments de liste dépasse 15 000. Les fonctions de table sont apparemment très efficaces.
Voici le code que j'ai utilisé :
// version pmroz
pmroz_randomizeList = Fonction ({ une liste } , { Locale par défaut } ,
nr = articles ( une liste ) ;
dt = Nouveau tableau ( "" , invisible , Ajouter des lignes ( nr ) ,
Nouvelle colonne ( "Données" , Numérique , Continu , Format ( "Meilleur" , 12 ) ,
Définir les valeurs ( une liste ) ) ,
Nouvelle colonne ( "Aléatoire" , Numérique , Continu , Format ( "Meilleur" , 12 ) ,
Formule ( Uniforme aléatoire () ) )
) ;
dt << trier ( remplacer le tableau , par ( : Randomisé )) ;
liste_aléatoire = dt : Données << obtenir des valeurs ;
proche ( dt , nosave ) ;
liste_aléatoire ;
) ;
// Jeff Perkinson 13 juillet 2016 14h00 (en réponse à Peter Mroz)
jeff_randomizeList = Fonction ({ une liste } , { Locale par défaut } ,
une liste [ rang ( j ( articles ( une liste ) , 1 , uniforme aléatoire ()))]
) ;
// Fonction de Byron
byron_randomizeList = Fonction ({ une liste } , { Locale par défaut } ,
nr = articles ( une liste ) ;
rslist = mélange aléatoire ( 1 :: nr ) ;
cloque = une liste [ rslist [ 1 :: nr ]] ;
) ;
nm = 4000 ; // Fixe le nombre d'éléments de la liste
ma liste = ( sous forme de liste ( 1 :: nm ))[ 1 ] ;
début = aujourd'hui () ;
liste aléatoire = pmroz_randomizeList ( ma liste ) ;
écoulé = aujourd'hui () - début ;
imprimer ( "pmroz:" || carboniser ( écoulé )) ;
Attendez ( 0 ) ;
ma liste = ( sous forme de liste ( 1 :: nm ))[ 1 ] ;
début = aujourd'hui () ;
liste aléatoire = jeff_randomizeList ( ma liste ) ;
écoulé = aujourd'hui () - début ;
imprimer ( « Jeff : » || carboniser ( écoulé )) ;
Attendez ( 0 ) ;
ma liste = ( sous forme de liste ( 1 :: nm ))[ 1 ] ;
début = aujourd'hui () ;
liste aléatoire = byron_randomizeList ( ma liste ) ;
écoulé = aujourd'hui () - début ;
imprimer ( « Byron : » || carboniser ( écoulé )) ;
Attendez ( 0 ) ;
Re : randomiser une listeDans JMP, il existe presque toujours au moins trois façons de faire quelque chose.Voici donc le troisième.
En commençant par alist, faites une liste de nombres mélangés égal au nombre d'éléments dans alist. Faites ensuite blist avec les valeurs de alist dans l'ordre de rslist.
alist={a,b,c, 1 , 2 , 3 } ;
rslist= mélange aléatoire ( 1 :: articles (une liste));
blist=aliste[rslist[ 1 :: articles (une liste)]];
Peu importe que vous utilisiez des nombres ou des caractères ou une combinaison dans la liste.
Je suis à peu près sûr d'avoir eu cette idée dans le livre d'accompagnement JSL
-Byron
Re : randomiser une listeVoici ma réalisation.
randomizeList =Function({List},{Default Local}, //Code goes here List[rank(j(nitems(List), 1, random uniform()))]);list = {100,200,300,400,500};randomList = randomizeList(list);print(randomList);Au cas où ce n'est pas clair ce que je fais ici
- La j() La fonction crée une matrice de nombres aléatoires, par exemple [0.04757597646676, 0.738883488578722, 0.935981905087828, 0.0233044682536274, 0.493906983872876]
- La rang() La fonction renvoie une matrice (par exemple pour ci-dessus : [4, 1, 5, 2, 3] ) qui est utilisé pour retourner la liste d'origine dans un ordre trié les nombres aléatoires.
-Jeff
Re : randomiser une listeVoici une façon de le faire.J'aimerais voir d'autres approches!
randomizeList = Fonction ({ Liste } , { Locale par défaut } ,
nr = articles ( Liste ) ;
dt = Nouveau tableau ( "" , invisible , Ajouter des lignes ( nr ) ,
Nouvelle colonne ( "Données" , Numérique , Continu , Format ( "Meilleur" , 12 ) ,
Définir les valeurs ( Liste ) ) ,
Nouvelle colonne ( "Aléatoire" , Numérique , Continu , Format ( "Meilleur" , 12 ) ,
Formule ( Uniforme aléatoire () ) )
) ;
dt << trier ( remplacer le tableau , par ( : Randomisé )) ;
liste_aléatoire = dt : Données << obtenir des valeurs ;
proche ( dt , nosave ) ;
liste_aléatoire ;
) ;
liste = { 1 , 2 , 3 , 4 , 5 } ;
liste aléatoire = randomizeList ( liste ) ;
imprimer ( liste aléatoire ) ; // Sortie attendue quelque chose comme {2,4,5,1,3}
