19506_it-IT

liliconcom

Randomizza una lista<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />

Devo randomizzare una lista.

randomizeList = Funzione({Lista}, {Locale predefinito},

//Il codice va qui

Elenco resi;

);

lista = {1,2,3,4,5};

listacasuale = listacasuale(lista);

print(listacasuale); //Risultato previsto simile a {2,4,5,1,3}

Ci sono molti modi per farlo e nessuna risposta sbagliata.Apprezzo qualsiasi feedback, grazie! 

Re: Randomizzare una lista

adoro le linee rette; il comportamento N^2 per le liste è stato corretto!

Re: Randomizzare una lista

Ho aumentato le dimensioni degli elenchi per differenziarli un po' meglio, anche se le differenze tra i metodi non sono così grandi. Ciò che sorprende è la differenza temporale 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 preparare il tavolo?

JMP13beta8

MacIntel Core i7 da 2,5 GHz

DDR3 da 16 GB 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 una lista

Il codice seguente confronta i quattro algoritmi.I dati vengono archiviati in una tabella e quindi rappresentati graficamente.Sono curioso di sapere come appare in JMP 13?

// versione pmroz

pmroz_randomizeList = Funzione ({ una lista } , { Locale predefinito } ,

n = nitems ( una lista ) ;

dt = Nuova tabella ( "" , privato , Aggiungi righe ( n ) ,

Nuova colonna ( "Dati" , Numerico , Continuo , Formato ( "Migliore" , 12 ) ,

Imposta 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 ( nitems ( una lista ) , 1 , uniforme casuale ()))]

) ;

// La funzione di Byron

byron_randomizeList = Funzione ({ una lista } , { Locale predefinito } ,

n = nitems ( una lista ) ;

rslist = mescolamento casuale ( 1 :: n ) ;

Blist = una lista [ rslist [ 1 :: n ]] ;

) ;

// Philip Brown 14 luglio 2016 9:50

phil_randomizeList = Funzione ({ una lista } , { Locale predefinito } ,

una lista [ rango ( Ripetere ({ uniforme casuale ()} , nitems ( una lista ) ) )]

) ;

nlist = { 100 , 1000 , 10000 , 20000 , 30000 , 40000 , 50000 , 70000 } ;

dt = nuova tabella ( "Elenco casuale" , Aggiungi righe ( nitems ( 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 ( "Fil" , Numerico , Continuo , Formato ( "Migliore" , 12 ) )

) ;

per ( io = 1 , io <= nitems ( nlist ) , io ++,

nm = nlist [ io ] ;

dt : N articoli [ io ] = nm ;

la mia lista = ( come elenco ( 1 :: nm ))[ 1 ] ;

inizio = spuntare i secondi () ;

lista casuale = pmroz_randomizeList ( la mia lista ) ;

trascorso = spuntare i secondi () - inizio ;

dt : pmroz [ io ] = trascorso ;

Aspettare ( 0 ) ;

inizio = spuntare i secondi () ;

lista casuale = jeff_randomizeList ( la mia lista ) ;

trascorso = spuntare i secondi () - inizio ;

dt : Jeff [ io ] = trascorso ;

Aspettare ( 0 ) ;

inizio = spuntare i secondi () ;

lista casuale = byron_randomizeList ( la mia lista ) ;

trascorso = spuntare i secondi () - inizio ;

dt : Byron [ io ] = trascorso ;

Aspettare ( 0 ) ;

inizio = spuntare i secondi () ;

lista casuale = phil_randomizeList ( la mia lista ) ;

trascorso = spuntare i secondi () - inizio ;

dt : Fil [ io ] = trascorso ;

Aspettare ( 0 ) ;

) ;

dt << Costruttore 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 ) , Jitter ( 1 ) ) ,

Più liscio ( X , Y ( 1 ) , Y ( 2 ) , Y ( 3 ) , Y ( 4 ) , Leggenda ( 2 ) ) )

) ;

Re: Randomizzare una lista

Le tabelle private sono super utili, ma fai attenzione, poiché ogni tabella contiene meno memoria; sono più difficili da monitorare.Puoi occupare rapidamente molta memoria creando e aprendo tabelle private ed è facile non notarle poiché non hanno una finestra fisica (come nel mio esempio sopra).

Tuttavia, possono farti risparmiare molto tempo poiché non è necessario chiuderli, puoi semplicemente riassegnare la variabile che li contiene (che è ciò che intendevo sopra ma non avevo realizzato che la tua funzione avesse un {Default Local} --DOH!).

Dalla guida allo scripting:

Tabelle di dati privati

Nascondi completamente la tabella dati dalla vista 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 ne chiude molti

tavoli. Le tabelle di dati private non hanno una finestra fisica, quindi è necessaria meno memoria rispetto a

tavoli invisibili.

Come nel caso delle tabelle invisibili, le analisi eseguite su una tabella di dati privata sono collegate alla tabella.

Per evitare di perdere una tabella di dati privata, è necessario assegnarle un riferimento come mostrato in precedenza

esempio. In caso contrario, JMP rimuove immediatamente la tabella dei dati privati dalla memoria.

Ulteriori utilizzi della tabella più avanti nello script generano errori.

Re: Randomizzare una lista

Ancora un altro modo....

// Philip Brown 14 luglio 2016 9:50

phil_randomizeLista = Funzione ({aLista},{Locale predefinito},

una lista[ rango ( Ripetere ({ uniforme casuale ()}, nitems (una lista) ) )]

);

Non penso che sia più veloce della funzione incorporata Random Shuffle, ma mi è sempre piaciuto usare Repeat({}, n) per generare elenchi per determinate applicazioni.

Re: Randomizzare una lista

IL 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 una lista

Quindi la modifica Inserisci in JMP 13 risolverà lo stesso problema?Questa è un'ottima notizia!

Re: Randomizzare una lista

Le funzioni di tabella sono molto efficienti per set di dati di grandi dimensioni.Uno dei motivi principali è che JMP b/c sfrutta più core mentre JSL no.Tuttavia, per insiemi di dati di piccole dimensioni, 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 fino a 1/60 di secondo e HP TIME() è preciso al microsecondo.Naturalmente tutto dipende dal tuo computer.Inoltre, per darti un giusto vantaggio, ho cambiato le tue tabelle in private e ho rimosso l'istruzione di chiusura, che velocizzerà il tuo script.

Nomi predefiniti qui ( 1 ) ;

// versione pmroz

pmroz_randomizeList = Funzione ({ una lista } , { Locale predefinito } ,

dt = Nuova tabella ( "" , privato ,

Nuova colonna ( "Dati" , Imposta 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 ( nitems ( una lista ) , 1 , uniforme casuale ()))]

) ;

// La funzione di Byron

byron_randomizeList = Funzione ({ una lista } , { Locale predefinito } ,

n = nitems ( una lista ) ;

rslist = mescolamento casuale ( 1 :: n ) ;

Blist = una lista [ rslist [ 1 :: n ]] ;

) ;

nm = 100 ; // Imposta il numero di elementi della lista

imax = 100 ; // Imposta il numero di iterazioni

la mia lista = ( come elenco ( 1 :: nm ))[ 1 ] ;

inizio = HP TEMPO () ;

Per ( io = 1 , io <= imax , io ++,

lista casuale = pmroz_randomizeList ( la mia lista ) ;

) ;

trascorso = HP TEMPO () - inizio ;

stampa ( "pmroz: " || car ( trascorso )) ;

Aspettare ( 0 ) ;

inizio = HP TEMPO () ;

Per ( io = 1 , io <= imax , io ++,

lista casuale = jeff_randomizeList ( la mia lista ) ;

) ;

trascorso = HP TEMPO () - inizio ;

stampa ( "Jeff:" || car ( trascorso )) ;

Aspettare ( 0 ) ;

inizio = TEMPO HP () ;

Per ( io = 1 , io <= imax , io ++,

lista casuale = byron_randomizeList ( la mia lista ) ;

) ;

trascorso = HP TEMPO () - inizio ;

stampa ( "Byron:" || car ( trascorso )) ;

Aspettare ( 0 ) ;

//PRODUZIONE

"pmroz: 121646"

"Jeff: 3990"

"Byron: 3488"

Re: Randomizzare una lista

i risultati cambieranno in JMP 13.

Elenco veloce

400.000 si presenta così in JMP 13:

"pmroz: 0.533333333332848"

"Jeff: 0.233333333333576"

"Byron: 0,216666666667152"

Re: Randomizzare una lista

Molto interessante.La mia soluzione di tabella sembrava una specie di forza bruta, ma supera le altre due funzioni quando il numero di elementi dell'elenco supera i 15.000. Apparentemente le funzioni della tabella sono molto efficienti.

Ecco il codice che ho usato:

// versione pmroz

pmroz_randomizeList = Funzione ({ una lista } , { Locale predefinito } ,

n = nitems ( una lista ) ;

dt = Nuova tabella ( "" , invisibile , Aggiungi righe ( n ) ,

Nuova colonna ( "Dati" , Numerico , Continuo , Formato ( "Migliore" , 12 ) ,

Imposta 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 ;

vicino ( dt , nosalva ) ;

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 ( nitems ( una lista ) , 1 , uniforme casuale ()))]

) ;

// La funzione di Byron

byron_randomizeList = Funzione ({ una lista } , { Locale predefinito } ,

n = nitems ( una lista ) ;

rslist = mescolamento casuale ( 1 :: n ) ;

Blist = una lista [ rslist [ 1 :: n ]] ;

) ;

nm = 4000 ; // Imposta il numero di elementi della lista

la mia lista = ( come elenco ( 1 :: nm ))[ 1 ] ;

inizio = Oggi () ;

lista 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 () ;

lista 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 () ;

lista casuale = byron_randomizeList ( la mia lista ) ;

trascorso = Oggi () - inizio ;

stampa ( "Byron:" || car ( trascorso )) ;

Aspettare ( 0 ) ;

Re: Randomizzare una lista

In 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 pari al numero di elementi in alist. Quindi crea blist con i valori di alist nell'ordine di rslist.

alist={a,b,c, 1 , 2 , 3 };

rslist= mescolamento casuale ( 1 :: nitems (una lista));

blist=alist[rslist[ 1 :: nitems (una lista)]];

Non importa se stai utilizzando numeri, caratteri o una combinazione nell'elenco.

Sono abbastanza sicuro di aver preso questa idea dal libro complementare JSL

-Byron

Re: Randomizzare una lista

Ecco 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 fosse chiaro cosa sto facendo 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 (ad esempio per sopra: [4, 1, 5, 2, 3] ) che viene utilizzato per restituire l'elenco originale in un ordine ordinato di numeri casuali.

-Jeff

Re: Randomizzare una lista

Ecco un modo per farlo.Mi piacerebbe vedere altri approcci!

randomizeList = Funzione ({ Elenco } , { Locale predefinito } ,

n = nitems ( Elenco ) ;

dt = Nuova tabella ( "" , invisibile , Aggiungi righe ( n ) ,

Nuova colonna ( "Dati" , Numerico , Continuo , Formato ( "Migliore" , 12 ) ,

Imposta 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 ;

vicino ( dt , nosalva ) ;

lista_casuale ;

) ;

elenco = { 1 , 2 , 3 , 4 , 5 } ;

lista casuale = randomizeList ( elenco ) ;

stampa ( lista casuale ) ; //Risultato previsto simile a {2,4,5,1,3}

Re: Randomizza un elenco

Ecco 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 fosse chiaro cosa sto facendo qui

• La funzione J() crea una matrice di numeri casuali, ad esempio [0,04757597646676, 0,738883488578722, 0,935981905087828, 0,0233044682536274, 0,493906983872876]
• La funzione rango() restituisce una matrice (ad esempio per quanto sopra: [4, 1, 5, 2, 3] ) che viene utilizzata per restituire l'elenco originale in un ordine ordinato di numeri casuali.

-Jeff

Re: Randomizza un elenco

Ecco un modo per farlo. Mi piacerebbe vedere altri approcci!

randomizeList = Function({List}, {Default Local},


    nr = nitems(List);
    dt = New Table( "", invisible, Add Rows( nr ),
        New Column( "Data", Numeric, Continuous, Format( "Best", 12 ),
            Set Values( List ) ),
        New Column( "Randomized", Numeric, Continuous, Format( "Best", 12 ),
            Formula( Random Uniform() ) )
    );


    dt << sort(replace table, by(:Randomized));

    random_list = dt:Data << get values;
    close(dt, nosave);
    random_list;
);


list = {1,2,3,4,5};
randomList = randomizeList(list);
print(randomList); //Expected output something like {2,4,5,1,3}

Randomizza un elenco

Ho bisogno di randomizzare una lista.

randomizeList = Function({List}, {Default Local},

     //Code goes here

     return List;

);

list = {1,2,3,4,5};

randomList = randomizeList(list);

print(randomList); //Expected output something like {2,4,5,1,3}

Ci sono molti modi per farlo e nessuna risposta sbagliata. Apprezzo qualsiasi feedback, grazie!

Personalizzazione di massaRe: Randomizza un elenco

Molto interessante. La mia soluzione per le tabelle sembrava un po' forza bruta, ma supera le altre due funzioni quando il numero di elementi della lista supera i 15.000. A quanto pare, le funzioni per le tabelle sono molto efficienti.

Ecco il codice che ho utilizzato:

// pmroz version
pmroz_randomizeList = Function({aList}, {Default Local},
    nr = nitems(aList);
    dt = New Table( "", invisible, Add Rows( nr ),
        New Column( "Data", Numeric, Continuous, Format( "Best", 12 ),
            Set Values( aList ) ),
        New Column( "Randomized", Numeric, Continuous, Format( "Best", 12 ),
            Formula( Random Uniform() ) )
    );
    dt << sort(replace table, by(:Randomized));
    random_list = dt:Data << get values;
    close(dt, nosave);
    random_list;
);


// Jeff Perkinson Jul 13, 2016 2:00 PM (in response to Peter Mroz)
jeff_randomizeList =Function({aList},{Default Local},
    aList[rank(j(nitems(aList), 1, random uniform()))]
);


// Byron's function
byron_randomizeList = Function({aList},{Default Local},
    nr = nitems(alist);
    rslist = random shuffle(1::nr);
    blist  = alist[rslist[1::nr]];
);


nm = 4000;   // Set the number of list elements
my_list = (as list(1::nm))[1];
start = today();
randomList = pmroz_randomizeList(my_list);
elapsed = today() - start;
print("pmroz: " || char(elapsed));
wait(0);


my_list = (as list(1::nm))[1];
start = today();
randomList = jeff_randomizeList(my_list);
elapsed = today() - start;
print("Jeff: " || char(elapsed));
wait(0);


my_list = (as list(1::nm))[1];
start = today();
randomList = byron_randomizeList(my_list);
elapsed = today() - start;
print("Byron: " || char(elapsed));
wait(0);

Re: Randomizza un elenco

Le funzioni tabella sono molto efficienti per set di dati di grandi dimensioni. Uno dei motivi principali è che JMP sfrutta più core, mentre JSL no. Tuttavia, per set di dati di piccole dimensioni, il processo di creazione della tabella aggiunge molto overhead. Per l'applicazione per cui lo sto utilizzando, avevo in realtà qualcosa di simile alla risposta di PMroz, ma poiché le mie liste erano tutte <1000 elementi, ho notato che aggiungeva un bel po' di tempo.

Grazie a tutti!

Nota: Today() ha una precisione al secondo, Tick Seconds() a 1/60 di secondo e HP TIME() a un microsecondo. Ovviamente, tutto dipende dal computer. Inoltre, per offrire un vantaggio ragionevole, ho modificato le tabelle in private e ho rimosso l'istruzione close, il che velocizzerà lo script.

Names Default to Here(1);



// pmroz version

pmroz_randomizeList = Function({aList}, {Default Local},

    dt = New Table( "", private,

              New Column( "Data", Set Values( aList ) ),

        New Column( "Randomized", Numeric, Continuous, Formula( Random Uniform() ) )

    );

    dt << sort(replace table, by(:Randomized));

    random_list = dt:Data << get values;

);



// Jeff Perkinson Jul 13, 2016 2:00 PM (in response to Peter Mroz)

jeff_randomizeList =Function({aList},{Default Local},

    aList[rank(j(nitems(aList), 1, random uniform()))]

);



// Byron's function

byron_randomizeList = Function({aList},{Default Local},

    nr = nitems(alist);

    rslist = random shuffle(1::nr);

    blist = alist[rslist[1::nr]];

);



nm = 100;   // Set the number of list elements

imax = 100; // Set number of iterations

my_list = (as list(1::nm))[1];

start = HP TIME();

For(i=1, i<=imax, i++,

       randomList = pmroz_randomizeList(my_list);

);

elapsed = HP TIME() - start;

print("pmroz: " || char(elapsed));

wait(0);



start = HP TIME();

For(i=1, i<=imax, i++,

       randomList = jeff_randomizeList(my_list);

);

elapsed = HP TIME() - start;

print("Jeff: " || char(elapsed));

wait(0);



start = HP TIME();

For(i=1, i<=imax, i++,

       randomList = byron_randomizeList(my_list);

);

elapsed = HP TIME() - start;

print("Byron: " || char(elapsed));

wait(0);

 

//OUTPUT

"pmroz: 121646"

"Jeff: 3990"

"Byron: 3488"