Randomizza una lista<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />Ho bisogno di randomizzare una lista.
randomizeList = Function({List}, {Default Local},
//Il codice va qui
Lista di ritorno;
);
elenco = {1,2,3,4,5};
randomList = randomizeList(lista);
stampa(elenco casuale); //Output previsto qualcosa come {2,4,5,1,3}
Ci sono molti modi per farlo e nessuna risposta sbagliata.Apprezzo qualsiasi feedback, grazie!
Re: randomizzare un elencoama le linee rette; il comportamento N^2 per le liste è stato risolto!
Re: randomizzare un elenco
Ho aumentato le dimensioni dell'elenco per differenziare un po' meglio, anche se le differenze tra i metodi non sono così grandi. Ciò che sorprende sono le differenze di tempo tra i risultati sopra e questi. Inoltre, sembra strano che il metodo di pmroz sia più lento con 100 righe che con 10000. Forse è dovuto alla ripetizione del compito di fare la tavola?
JMP 13 beta 8
Mac Intel Core i7 a 2,5 GHz
DDR3 da 16 GB a 1600 MHz
| N articoli | pmroz | Jeff | Byron | Fil |
| 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: randomizzare un elencoIl codice seguente confronta i quattro algoritmi.I dati vengono archiviati in una tabella e quindi rappresentati graficamente.Sono curioso di sapere che aspetto ha in JMP 13?
// versione pmroz
pmroz_randomizeList = Funzione ({ una lista } , { Locale predefinito } ,
nr = articoli ( una lista ) ;
dt = Nuova tavola ( "" , privato , Aggiungi righe ( nr ) ,
Nuova colonna ( "Dati" , Numerico , Continuo , Formato ( "Migliore" , 12 ) ,
Imposta i valori ( una lista ) ) ,
Nuova colonna ( "Randomizzato" , Numerico , Continuo , Formato ( "Migliore" , 12 ) ,
Formula ( Uniforme casuale () ) )
) ;
dt << ordinare ( sostituire la tabella , di ( : Randomizzato )) ;
lista_casuale = dt : Dati << ottenere valori ;
) ;
// Jeff Perkinson 13 luglio 2016 14:00 (in risposta a Peter Mroz)
jeff_randomizeList = Funzione ({ una lista } , { Locale predefinito } ,
una lista [ rango ( j ( articoli ( una lista ) , 1 , uniforme casuale ()))]
) ;
// La funzione di Byron
byron_randomizeList = Funzione ({ una lista } , { Locale predefinito } ,
nr = articoli ( una lista ) ;
rslist = mescolanza casuale ( 1 :: nr ) ;
bolla = una lista [ rslist [ 1 :: nr ]] ;
) ;
// Philip Brown 14 luglio 2016 9:50
phil_randomizeList = Funzione ({ una lista } , { Locale predefinito } ,
una lista [ rango ( Ripetere ({ uniforme casuale ()} , articoli ( una lista ) ) )]
) ;
nlist = { 100 , 1000 , 10000 , 20000 , 30000 , 40000 , 50000 , 70000 } ;
dt = nuova tavola ( "Elenco casuale" , Aggiungi righe ( articoli ( nlist ) ) ,
Nuova colonna ( "N articoli" , Numerico , Continuo , Formato ( "Migliore" , 12 ) ) ,
Nuova colonna ( "pmroz" , Numerico , Continuo , Formato ( "Migliore" , 12 ) ) ,
Nuova colonna ( "Jeff" , Numerico , Continuo , Formato ( "Migliore" , 12 ) ) ,
Nuova colonna ( "Byron" , Numerico , Continuo , Formato ( "Migliore" , 12 ) ) ,
Nuova colonna ( "Filippo" , Numerico , Continuo , Formato ( "Migliore" , 12 ) )
) ;
per ( io = 1 , io <= articoli ( nlist ) , io ++,
nm = nlist [ io ] ;
dt : N articoli [ io ] = nm ;
la mia lista = ( come elenco ( 1 :: nm ))[ 1 ] ;
inizio = tick secondi () ;
elenco casuale = pmroz_randomizeList ( la mia lista ) ;
trascorso = tick secondi () - inizio ;
dt : pmroz [ io ] = trascorso ;
aspettare ( 0 ) ;
inizio = tick secondi () ;
elenco casuale = jeff_randomizeList ( la mia lista ) ;
trascorso = tick secondi () - inizio ;
dt : Jeff [ io ] = trascorso ;
aspettare ( 0 ) ;
inizio = tick secondi () ;
elenco casuale = byron_randomizeList ( la mia lista ) ;
trascorso = tick secondi () - inizio ;
dt : Byron [ io ] = trascorso ;
aspettare ( 0 ) ;
inizio = tick secondi () ;
elenco casuale = phil_randomizeList ( la mia lista ) ;
trascorso = tick secondi () - inizio ;
dt : Fil [ io ] = trascorso ;
aspettare ( 0 ) ;
) ;
dt << Generatore di grafici ( Mostra pannello di controllo ( 0 ) ,
Variabili ( X ( : N articoli ) , Y ( : pmroz ) , Y ( : Jeff , Posizione ( 1 ) ) , Y ( : Byron , Posizione ( 1 ) ) ,
Y ( : Fil , Posizione ( 1 ) ) ) ,
Elementi ( Punti ( X , Y ( 1 ) , Y ( 2 ) , Y ( 3 ) , Y ( 4 ) , Leggenda ( 1 ) , Tremore ( 1 ) ) ,
Più liscio ( X , Y ( 1 ) , Y ( 2 ) , Y ( 3 ) , Y ( 4 ) , Leggenda ( 2 ) ) )
) ;
Re: randomizzare un elencoLe tabelle private sono super utili, ma fai attenzione, mentre ogni tabella contiene meno memoria; sono più difficili da rintracciare.Puoi occupare rapidamente molta memoria creando e aprendo tabelle private ed è facile perderle poiché non hanno una finestra fisica (come nel mio esempio sopra).
Tuttavia, possono farti risparmiare un sacco di tempo poiché non è necessario chiuderli, puoi semplicemente riassegnare la variabile che li contiene (che è ciò che intendevo sopra ma non mi ero reso conto che la tua funzione aveva un {Default Local} -- DOH!).
Dalla guida allo script:
Tabelle di dati privati
Nascondi completamente la tabella di dati dalla visualizzazione includendo l'argomento privato:
dt = Open("$SAMPLE_DATA/Big Class.jmp", "privato");
Rendere privata una tabella può prevenire problemi di memoria quando uno script ne apre e chiude molti
tavoli. Le tabelle di dati private non hanno una finestra fisica, quindi è necessaria meno memoria rispetto a
tavoli invisibili.
Come per le tabelle invisibili, le analisi eseguite su una tabella di dati privata sono collegate alla tabella.
Per evitare di perdere una tabella di dati privati, è necessario assegnarle un riferimento come mostrato in precedenza
esempio. In caso contrario, JMP rimuove immediatamente la tabella di dati privati dalla memoria.
Ulteriori utilizzi della tabella più avanti nello script generano errori.
Re: randomizzare un elencoAncora un altro modo....
// Philip Brown 14 luglio 2016 9:50
phil_randomizeList = Funzione ({aList},{Locale predefinito},
una lista[ rango ( Ripetere ({ uniforme casuale ()}, articoli (una lista) ) )]
);
Non penso che questo sia più veloce della funzione incorporata Random Shuffle, ma mi è sempre piaciuto usare Repeat({}, n) per generare elenchi per determinate applicazioni.
Re: randomizzare un elencoIl privato la parola chiave è interessante: la tabella non viene nemmeno visualizzata nell'elenco delle finestre.Immagino che risparmi un po' di memoria.Posso usarlo in un sacco di posti.Grazie msharp!
Re: randomizzare un elencoQuindi la modifica di JMP 13 Insert Into risolverà lo stesso problema?Questa è una grande notizia!
Re: randomizzare un elencoLe funzioni tabella sono molto efficienti per insiemi di dati di grandi dimensioni.Uno dei motivi principali è che b/c JMP sfrutta più core mentre JSL no.Tuttavia, per piccoli set di dati il processo di creazione della tabella aggiunge molto sovraccarico.Per l'applicazione per cui lo sto usando, in realtà avevo qualcosa di simile alla risposta di PMroz, ma poiché i miei elenchi erano tutti <1000 elementi, ho notato che stava aggiungendo un bel po' di tempo.
Grazie a tutti!
Nota: Today() è preciso solo al secondo, Tick Seconds() è preciso a 1/60 di secondo e HP TIME() è accurato al microsecondo.Ovviamente tutto dipende dal tuo computer.Inoltre, per dare un giusto vantaggio, ho cambiato le tue tabelle in private e ho rimosso l'istruzione di chiusura, che accelererà il tuo script.
Nomi predefinito qui ( 1 ) ;
// versione pmroz
pmroz_randomizeList = Funzione ({ una lista } , { Locale predefinito } ,
dt = Nuova tavola ( "" , privato ,
Nuova colonna ( "Dati" , Imposta i valori ( una lista ) ) ,
Nuova colonna ( "Randomizzato" , Numerico , Continuo , Formula ( Uniforme casuale () ) )
) ;
dt << ordinare ( sostituire la tabella , di ( : Randomizzato )) ;
lista_casuale = dt : Dati << ottenere valori ;
) ;
// Jeff Perkinson 13 luglio 2016 14:00 (in risposta a Peter Mroz)
jeff_randomizeList = Funzione ({ una lista } , { Locale predefinito } ,
una lista [ rango ( j ( articoli ( una lista ) , 1 , uniforme casuale ()))]
) ;
// La funzione di Byron
byron_randomizeList = Funzione ({ una lista } , { Locale predefinito } ,
nr = articoli ( una lista ) ;
rslist = mescolanza casuale ( 1 :: nr ) ;
bolla = una lista [ rslist [ 1 :: nr ]] ;
) ;
nm = 100 ; // Imposta il numero di elementi dell'elenco
imax = 100 ; // Imposta il numero di iterazioni
la mia lista = ( come elenco ( 1 :: nm ))[ 1 ] ;
inizio = TEMPO HP () ;
Per ( io = 1 , io <= imax , io ++,
elenco casuale = pmroz_randomizeList ( la mia lista ) ;
) ;
trascorso = TEMPO HP () - inizio ;
Stampa ( "pmroz:" || car ( trascorso )) ;
aspettare ( 0 ) ;
inizio = TEMPO HP () ;
Per ( io = 1 , io <= imax , io ++,
elenco casuale = jeff_randomizeList ( la mia lista ) ;
) ;
trascorso = TEMPO HP () - inizio ;
Stampa ( "Jeff:" || car ( trascorso )) ;
aspettare ( 0 ) ;
inizio = TEMPO HP () ;
Per ( io = 1 , io <= imax , io ++,
elenco casuale = byron_randomizeList ( la mia lista ) ;
) ;
trascorso = TEMPO HP () - inizio ;
Stampa ( "Byron:" || car ( trascorso )) ;
aspettare ( 0 ) ;
//PRODUZIONE
"pmroz: 121646"
"Jeff: 3990"
"Byron: 3488"
Re: randomizzare un elencoi risultati cambieranno in JMP 13.
Elenco veloce
400.000 appare così in JMP 13:
"pmroz: 0.5333333333332848"
"Jeff: 0.2333333333333576"
"Byron: 0,2166666666667152"
Re: randomizzare un elencoMolto interessante.La mia soluzione per la tabella sembrava una specie di forza bruta, ma supera le altre due funzioni quando il numero di elementi dell'elenco supera i 15.000. Le funzioni della tabella sono apparentemente molto efficienti.
Ecco il codice che ho usato:
// versione pmroz
pmroz_randomizeList = Funzione ({ una lista } , { Locale predefinito } ,
nr = articoli ( una lista ) ;
dt = Nuova tavola ( "" , invisibile , Aggiungi righe ( nr ) ,
Nuova colonna ( "Dati" , Numerico , Continuo , Formato ( "Migliore" , 12 ) ,
Imposta i valori ( una lista ) ) ,
Nuova colonna ( "Randomizzato" , Numerico , Continuo , Formato ( "Migliore" , 12 ) ,
Formula ( Uniforme casuale () ) )
) ;
dt << ordinare ( sostituire la tabella , di ( : Randomizzato )) ;
lista_casuale = dt : Dati << ottenere valori ;
chiudere ( dt , novanta ) ;
lista_casuale ;
) ;
// Jeff Perkinson 13 luglio 2016 14:00 (in risposta a Peter Mroz)
jeff_randomizeList = Funzione ({ una lista } , { Locale predefinito } ,
una lista [ rango ( j ( articoli ( una lista ) , 1 , uniforme casuale ()))]
) ;
// La funzione di Byron
byron_randomizeList = Funzione ({ una lista } , { Locale predefinito } ,
nr = articoli ( una lista ) ;
rslist = mescolanza casuale ( 1 :: nr ) ;
bolla = una lista [ rslist [ 1 :: nr ]] ;
) ;
nm = 4000 ; // Imposta il numero di elementi dell'elenco
la mia lista = ( come elenco ( 1 :: nm ))[ 1 ] ;
inizio = oggi () ;
elenco casuale = pmroz_randomizeList ( la mia lista ) ;
trascorso = oggi () - inizio ;
Stampa ( "pmroz:" || car ( trascorso )) ;
aspettare ( 0 ) ;
la mia lista = ( come elenco ( 1 :: nm ))[ 1 ] ;
inizio = oggi () ;
elenco casuale = jeff_randomizeList ( la mia lista ) ;
trascorso = oggi () - inizio ;
Stampa ( "Jeff:" || car ( trascorso )) ;
aspettare ( 0 ) ;
la mia lista = ( come elenco ( 1 :: nm ))[ 1 ] ;
inizio = oggi () ;
elenco casuale = byron_randomizeList ( la mia lista ) ;
trascorso = oggi () - inizio ;
Stampa ( "Byron:" || car ( trascorso )) ;
aspettare ( 0 ) ;
Re: randomizzare un elencoIn JMP ci sono quasi sempre almeno tre modi per fare qualsiasi cosa.Quindi ecco il terzo.
Iniziando con alist, crea un elenco di numeri mescolati uguale al numero di elementi in alist. Quindi crea blist con i valori di alist nell'ordine di rslist.
elenco={a,b,c, 1 , 2 , 3 };
rslista= mescolanza casuale ( 1 :: articoli (una lista));
blist=alist[rslist[ 1 :: articoli (una lista)]];
Non importa se stai usando numeri o caratteri o una combinazione nell'elenco.
Sono abbastanza sicuro di aver avuto questa idea dal libro di accompagnamento di JSL
-Byron
Re: randomizzare un elencoEcco la mia implementazione.
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);Nel caso non sia chiaro cosa ci faccio qui
- Il j() la funzione crea una matrice di numeri casuali, ad es [0.04757597646676, 0.738883488578722, 0.935981905087828, 0.0233044682536274, 0.493906983872876]
- Il rango() la funzione restituisce una matrice (es. per sopra: [4, 1, 5, 2, 3] ) che viene utilizzato per restituire l'elenco originale in un ordine ordinato in base ai numeri casuali.
-Jeff
Re: randomizzare un elencoEcco un modo per farlo.Mi piacerebbe vedere altri approcci!
randomizeList = Funzione ({ Elenco } , { Locale predefinito } ,
nr = articoli ( Elenco ) ;
dt = Nuova tavola ( "" , invisibile , Aggiungi righe ( nr ) ,
Nuova colonna ( "Dati" , Numerico , Continuo , Formato ( "Migliore" , 12 ) ,
Imposta i valori ( Elenco ) ) ,
Nuova colonna ( "Randomizzato" , Numerico , Continuo , Formato ( "Migliore" , 12 ) ,
Formula ( Uniforme casuale () ) )
) ;
dt << ordinare ( sostituire la tabella , di ( : Randomizzato )) ;
lista_casuale = dt : Dati << ottenere valori ;
chiudere ( dt , novanta ) ;
lista_casuale ;
) ;
elenco = { 1 , 2 , 3 , 4 , 5 } ;
elenco casuale = randomizeList ( elenco ) ;
Stampa ( elenco casuale ) ; //Output previsto qualcosa come {2,4,5,1,3}
