19506_de-DE

liliconcom

Randomisieren Sie eine Liste<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />

Ich muss eine Liste randomisieren.

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

//Code kommt hierher

Rückgabeliste;

);

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

randomList = randomizeList(list);

print(randomList); //Erwartete Ausgabe etwa {2,4,5,1,3}

Dafür gibt es viele Möglichkeiten und keine falsche Antwort.Ich freue mich über jedes Feedback, danke! 

Betreff: Eine Liste randomisieren

liebe die geraden Linien; Das N^2-Verhalten für Listen ist behoben!

Betreff: Eine Liste randomisieren

Ich habe die Listengröße erhöht, um die Unterscheidung etwas besser zu erleichtern, obwohl die Unterschiede zwischen den Methoden nicht so groß sind. Überraschend sind die Zeitunterschiede zwischen den obigen und diesen Ergebnissen. Außerdem erscheint es seltsam, dass die Methode von pmroz bei 100 Zeilen langsamer ist als bei 10000. Vielleicht liegt es daran, dass die Aufgabe, den Tisch zu erstellen, wiederholt wird?

JMP 13 Beta 8

Mac 2,5 GHz Intel Core i7

16 GB 1600 MHz DDR3

N Artikel	pmroz	Jeff	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

Betreff: Eine Liste randomisieren

Der folgende Code vergleicht die vier Algorithmen.Die Daten werden in einer Tabelle gespeichert und dann grafisch dargestellt.Ich bin gespannt, wie das in JMP 13 aussieht?

// PMROZ-Version

pmroz_randomizeList = Funktion ({ eine Liste } , { Standardmäßig lokal } ,

Nr = nitems ( eine Liste ) ;

dt = Neuer Tisch ( „“ , Privat , Zeilen hinzufügen ( Nr ) ,

Neue Spalte ( "Daten" , Numerisch , Kontinuierlich , Format ( "Am besten" , 12 ) ,

Werte festlegen ( eine Liste ) ) ,

Neue Spalte ( "Zufällig" , Numerisch , Kontinuierlich , Format ( "Am besten" , 12 ) ,

Formel ( Zufällige Uniform () ) )

) ;

dt << Sortieren ( Tisch ersetzen , von ( : Zufällig )) ;

random_list = dt : Daten << Werte erhalten ;

) ;

// Jeff Perkinson 13. Juli 2016 14:00 Uhr (als Antwort an Peter Mroz)

jeff_randomizeList = Funktion ({ eine Liste } , { Standardmäßig lokal } ,

eine Liste [ Rang ( J ( nitems ( eine Liste ) , 1 , zufällige Uniform ()))]

) ;

// Byrons Funktion

byron_randomizeList = Funktion ({ eine Liste } , { Standardmäßig lokal } ,

Nr = nitems ( eine Liste ) ;

rslist = zufälliges Mischen ( 1 :: Nr ) ;

Blister = eine Liste [ rslist [ 1 :: Nr ]] ;

) ;

// Philip Brown 14. Juli 2016 9:50 Uhr

phil_randomizeList = Funktion ({ eine Liste } , { Standardmäßig lokal } ,

eine Liste [ Rang ( Wiederholen ({ zufällige Uniform ()} , nitems ( eine Liste ) ) )]

) ;

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

dt = neuer Tisch ( „Liste randomisieren“ , Zeilen hinzufügen ( nitems ( nlist ) ) ,

Neue Spalte ( „N Artikel“ , Numerisch , Kontinuierlich , Format ( "Am besten" , 12 ) ) ,

Neue Spalte ( „pmroz“ , Numerisch , Kontinuierlich , Format ( "Am besten" , 12 ) ) ,

Neue Spalte ( „Jeff“ , Numerisch , Kontinuierlich , Format ( "Am besten" , 12 ) ) ,

Neue Spalte ( „Byron“ , Numerisch , Kontinuierlich , Format ( "Am besten" , 12 ) ) ,

Neue Spalte ( „Phil“ , Numerisch , Kontinuierlich , Format ( "Am besten" , 12 ) )

) ;

für ( ich = 1 , ich <= nitems ( nlist ) , ich ++,

nm = nlist [ ich ] ;

dt : N Artikel [ ich ] = nm ;

meine Liste = ( als Liste ( 1 :: nm ))[ 1 ] ;

Start = Sekunden ticken () ;

Zufallsliste = pmroz_randomizeList ( meine Liste ) ;

verstrichen = Sekunden ticken () - Start ;

dt : pmroz [ ich ] = verstrichen ;

Warten ( 0 ) ;

Start = Sekunden ticken () ;

Zufallsliste = jeff_randomizeList ( meine Liste ) ;

verstrichen = Sekunden ticken () - Start ;

dt : Jeff [ ich ] = verstrichen ;

Warten ( 0 ) ;

Start = Sekunden ticken () ;

Zufallsliste = byron_randomizeList ( meine Liste ) ;

verstrichen = Sekunden ticken () - Start ;

dt : Byron [ ich ] = verstrichen ;

Warten ( 0 ) ;

Start = Sekunden ticken () ;

Zufallsliste = phil_randomizeList ( meine Liste ) ;

verstrichen = Sekunden ticken () - Start ;

dt : Phil [ ich ] = verstrichen ;

Warten ( 0 ) ;

) ;

dt << Graph Builder ( Systemsteuerung anzeigen ( 0 ) ,

Variablen ( X ( : N Artikel ) , Y ( : pmroz ) , Y ( : Jeff , Position ( 1 ) ) , Y ( : Byron , Position ( 1 ) ) ,

Y ( : Phil , Position ( 1 ) ) ) ,

Elemente ( Punkte ( X , Y ( 1 ) , Y ( 2 ) , Y ( 3 ) , Y ( 4 ) , Legende ( 1 ) , Nervosität ( 1 ) ) ,

Glatter ( X , Y ( 1 ) , Y ( 2 ) , Y ( 3 ) , Y ( 4 ) , Legende ( 2 ) ) )

) ;

Betreff: Eine Liste randomisieren

Private Tabellen sind sehr nützlich, aber seien Sie vorsichtig, da jede Tabelle weniger Speicher enthält. Sie sind schwerer zu verfolgen.Durch das Erstellen und Öffnen privater Tabellen kann schnell viel Speicher beansprucht werden, was leicht übersehen wird, da sie kein physisches Fenster haben (wie in meinem Beispiel oben).

Sie können Ihnen jedoch viel Zeit sparen, da Sie sie nicht schließen müssen. Sie können einfach die Variable, die sie enthält, neu zuweisen (was ich oben beabsichtigt hatte, aber nicht wusste, dass Ihre Funktion einen {Default Local} hat). -- DOH!).

Aus dem Scripting-Guide:

Private Datentabellen

Blenden Sie die Datentabelle vollständig aus, indem Sie das private Argument einschließen:

dt = Open( "$SAMPLE_DATA/Big Class.jmp", "private" );

Wenn Sie eine Tabelle privat machen, können Sie Speicherprobleme vermeiden, wenn ein Skript viele davon öffnet und schließt

Tische. Private Datentabellen haben kein physisches Fenster, daher ist weniger Speicher erforderlich als bei

unsichtbare Tische.

Wie bei unsichtbaren Tabellen sind Analysen, die für eine private Datentabelle ausgeführt werden, mit der Tabelle verknüpft.

Um den Verlust einer privaten Datentabelle zu vermeiden, müssen Sie ihr wie oben gezeigt eine Referenz zuweisen

Beispiel. Andernfalls entfernt JMP die private Datentabelle sofort aus dem Speicher.

Weitere Verwendungen der Tabelle später im Skript führen zu Fehlern.

Betreff: Eine Liste randomisieren

Noch ein anderer Weg....

// Philip Brown 14. Juli 2016 9:50 Uhr

phil_randomizeList = Funktion ({aList},{Default Local},

eine Liste[ Rang ( Wiederholen ({ zufällige Uniform ()}, nitems (eine Liste) ) )]

);

Ich glaube nicht, dass dies schneller ist als die integrierte Funktion „Random Shuffle“, aber ich habe Repeat({}, n) schon immer gerne verwendet, um Listen für bestimmte Anwendungen zu generieren.

Betreff: Eine Liste randomisieren

Der Privat Schlüsselwort ist interessant - die Tabelle wird nicht einmal in der Fensterliste angezeigt.Ich stelle mir vor, dass es ein bisschen Speicher spart.Ich kann es an vielen Orten verwenden.Danke msharp!

Betreff: Eine Liste randomisieren

Die JMP 13-Änderung „Einfügen in“ behebt also das gleiche Problem?Das sind gute Nachrichten!

Betreff: Eine Liste randomisieren

Tabellenfunktionen sind für große Datenmengen sehr effizient.Einer der Hauptgründe ist, dass B/C-JMP mehrere Kerne nutzt, während JSL dies nicht tut.Bei kleinen Datensätzen verursacht das Erstellen der Tabelle jedoch einen hohen Mehraufwand.Für die Anwendung, für die ich dies verwende, hatte ich tatsächlich etwas Ähnliches wie die Antwort von PMroz, aber da meine Listen alle <1000 Elemente enthielten, bemerkte ich, dass es ziemlich viel Zeit kostete.

Vielen Dank an alle!

Hinweis: Today() ist nur auf die Sekunde genau, Tick Seconds() ist auf 1/60 Sekunde genau und HP TIME() ist auf die Mikrosekunde genau.Das hängt natürlich alles von Ihrem Computer ab.Um Ihnen einen fairen Vorteil zu verschaffen, habe ich Ihre Tabellen in „privat“ geändert und die close-Anweisung entfernt, was Ihr Skript beschleunigt.

Namen werden standardmäßig hier angezeigt ( 1 ) ;

// PMROZ-Version

pmroz_randomizeList = Funktion ({ eine Liste } , { Standardmäßig lokal } ,

dt = Neuer Tisch ( „“ , Privat ,

Neue Spalte ( "Daten" , Werte festlegen ( eine Liste ) ) ,

Neue Spalte ( "Zufällig" , Numerisch , Kontinuierlich , Formel ( Zufällige Uniform () ) )

) ;

dt << Sortieren ( Tisch ersetzen , von ( : Zufällig )) ;

random_list = dt : Daten << Werte erhalten ;

) ;

// Jeff Perkinson 13. Juli 2016 14:00 Uhr (als Antwort an Peter Mroz)

jeff_randomizeList = Funktion ({ eine Liste } , { Standardmäßig lokal } ,

eine Liste [ Rang ( J ( nitems ( eine Liste ) , 1 , zufällige Uniform ()))]

) ;

// Byrons Funktion

byron_randomizeList = Funktion ({ eine Liste } , { Standardmäßig lokal } ,

Nr = nitems ( eine Liste ) ;

rslist = zufälliges Mischen ( 1 :: Nr ) ;

Blister = eine Liste [ rslist [ 1 :: Nr ]] ;

) ;

nm = 100 ; // Anzahl der Listenelemente festlegen

imax = 100 ; // Anzahl der Iterationen festlegen

meine Liste = ( als Liste ( 1 :: nm ))[ 1 ] ;

Start = HP-ZEIT () ;

Für ( ich = 1 , ich <= imax , ich ++,

Zufallsliste = pmroz_randomizeList ( meine Liste ) ;

) ;

verstrichen = HP-ZEIT () - Start ;

drucken ( „pmroz:“ || verkohlen ( verstrichen )) ;

Warten ( 0 ) ;

Start = HP-ZEIT () ;

Für ( ich = 1 , ich <= imax , ich ++,

Zufallsliste = jeff_randomizeList ( meine Liste ) ;

) ;

verstrichen = HP-ZEIT () - Start ;

drucken ( „Jeff:“ || verkohlen ( verstrichen )) ;

Warten ( 0 ) ;

Start = HP-ZEIT () ;

Für ( ich = 1 , ich <= imax , ich ++,

Zufallsliste = byron_randomizeList ( meine Liste ) ;

) ;

verstrichen = HP-ZEIT () - Start ;

drucken ( „Byron:“ || verkohlen ( verstrichen )) ;

Warten ( 0 ) ;

//AUSGABE

„pmroz: 121646“

„Jeff: 3990“

„Byron: 3488“

Betreff: Eine Liste randomisieren

Die Ergebnisse werden sich in JMP 13 ändern.

Schnelle Liste

400.000 sieht in JMP 13 so aus:

„pmroz: 0,533333333332848“

„Jeff: 0,233333333333576“

„Byron: 0,216666666667152“

Betreff: Eine Liste randomisieren

Sehr interessant.Meine Tabellenlösung schien eine Art Brute-Force-Lösung zu sein, aber sie übertrifft die beiden anderen Funktionen, wenn die Anzahl der Listenelemente 15.000 übersteigt. Tabellenfunktionen sind offenbar sehr effizient.

Hier ist der Code, den ich verwendet habe:

// PMROZ-Version

pmroz_randomizeList = Funktion ({ eine Liste } , { Standardmäßig lokal } ,

Nr = nitems ( eine Liste ) ;

dt = Neuer Tisch ( „“ , unsichtbar , Zeilen hinzufügen ( Nr ) ,

Neue Spalte ( "Daten" , Numerisch , Kontinuierlich , Format ( "Am besten" , 12 ) ,

Werte festlegen ( eine Liste ) ) ,

Neue Spalte ( "Zufällig" , Numerisch , Kontinuierlich , Format ( "Am besten" , 12 ) ,

Formel ( Zufällige Uniform () ) )

) ;

dt << Sortieren ( Tisch ersetzen , von ( : Zufällig )) ;

random_list = dt : Daten << Werte bekommen ;

schließen ( dt , nosave ) ;

random_list ;

) ;

// Jeff Perkinson 13. Juli 2016 14:00 Uhr (als Antwort an Peter Mroz)

jeff_randomizeList = Funktion ({ eine Liste } , { Standardmäßig lokal } ,

eine Liste [ Rang ( J ( nitems ( eine Liste ) , 1 , zufällige Uniform ()))]

) ;

// Byrons Funktion

byron_randomizeList = Funktion ({ eine Liste } , { Standardmäßig lokal } ,

Nr = nitems ( eine Liste ) ;

rslist = zufälliges Mischen ( 1 :: Nr ) ;

Blister = eine Liste [ rslist [ 1 :: Nr ]] ;

) ;

nm = 4000 ; // Anzahl der Listenelemente festlegen

meine Liste = ( als Liste ( 1 :: nm ))[ 1 ] ;

Start = Heute () ;

Zufallsliste = pmroz_randomizeList ( meine Liste ) ;

verstrichen = Heute () - Start ;

drucken ( „pmroz:“ || verkohlen ( verstrichen )) ;

Warten ( 0 ) ;

meine Liste = ( als Liste ( 1 :: nm ))[ 1 ] ;

Start = Heute () ;

Zufallsliste = jeff_randomizeList ( meine Liste ) ;

verstrichen = Heute () - Start ;

drucken ( „Jeff:“ || verkohlen ( verstrichen )) ;

Warten ( 0 ) ;

meine Liste = ( als Liste ( 1 :: nm ))[ 1 ] ;

Start = Heute () ;

Zufallsliste = byron_randomizeList ( meine Liste ) ;

verstrichen = Heute () - Start ;

drucken ( „Byron:“ || verkohlen ( verstrichen )) ;

Warten ( 0 ) ;

Betreff: Eine Liste randomisieren

In JMP gibt es fast immer mindestens drei Möglichkeiten, etwas zu tun.Hier ist also der Dritte.

Beginnen Sie mit alist und erstellen Sie eine Liste gemischter Zahlen, die der Anzahl der Elemente in alist entspricht. Erstellen Sie dann eine Blist mit den Werten von alist in der Reihenfolge von rslist.

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

rslist= zufälliges Mischen ( 1 :: nitems (eine Liste));

blist=alist[rslist[ 1 :: nitems (eine Liste)]];

Es spielt keine Rolle, ob Sie Zahlen oder Zeichen oder eine Kombination in der Liste verwenden.

Ich bin mir ziemlich sicher, dass ich diese Idee aus dem JSL-Begleitbuch habe

-Byron

Betreff: Eine Liste randomisieren

Hier ist meine Implementierung.

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

Falls nicht klar ist, was ich hier mache

• Der J() Funktion erstellt eine Matrix aus Zufallszahlen, z [0,04757597646676, 0,738883488578722, 0,935981905087828, 0,0233044682536274, 0,493906983872876]
• Der Rang() Funktion gibt eine Matrix zurück (z. B. für oben: [4, 1, 5, 2, 3] ), der verwendet wird, um die ursprüngliche Liste in einer nach Zufallszahlen sortierten Reihenfolge zurückzugeben.

-Jeff

Betreff: Eine Liste randomisieren

Hier ist eine Möglichkeit, dies zu tun.Würde gerne andere Ansätze sehen!

randomizeList = Funktion ({ Aufführen } , { Standardmäßig lokal } ,

Nr = nitems ( Aufführen ) ;

dt = Neuer Tisch ( „“ , unsichtbar , Zeilen hinzufügen ( Nr ) ,

Neue Spalte ( "Daten" , Numerisch , Kontinuierlich , Format ( "Am besten" , 12 ) ,

Werte festlegen ( Aufführen ) ) ,

Neue Spalte ( "Zufällig" , Numerisch , Kontinuierlich , Format ( "Am besten" , 12 ) ,

Formel ( Zufällige Uniform () ) )

) ;

dt << Sortieren ( Tisch ersetzen , von ( : Zufällig )) ;

random_list = dt : Daten << Werte erhalten ;

schließen ( dt , nosave ) ;

random_list ;

) ;

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

Zufallsliste = randomizeList ( Liste ) ;

drucken ( Zufallsliste ) ; //Erwartete Ausgabe etwa {2,4,5,1,3}

Betreff: Liste randomisieren

Hier ist meine Implementierung.

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

Falls nicht klar ist, was ich hier tue.

• Die Funktion J() erzeugt eine Matrix von Zufallszahlen, z. B. [0,04757597646676, 0,738883488578722, 0,935981905087828, 0,0233044682536274, 0.493906983872876].
• Die Funktion Rang() gibt eine Matrix zurück (z. B. für das obige Beispiel: [4, 1, 5, 2, 3] ), die dazu dient, die ursprüngliche Liste in einer Reihenfolge zu erhalten, in der die Zufallszahlen sortiert sind.

-Jeff

Betreff: Liste randomisieren

Hier ist eine Möglichkeit. Ich bin gespannt auf weitere Ansätze!

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}

Liste randomisieren

Ich muss eine Liste randomisieren.

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}

Es gibt viele Wege, das zu tun, und keine falsche Antwort. Ich freue mich über jedes Feedback, danke!

MassenanpassungBetreff: Liste randomisieren

Sehr interessant. Meine Tabellenlösung wirkte zwar etwas umständlich, ist aber den anderen beiden Funktionen überlegen, sobald die Anzahl der Listenelemente 15.000 übersteigt. Tabellenfunktionen sind offenbar sehr effizient.

Hier ist der von mir verwendete Code:

// 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);

Betreff: Liste randomisieren

Tabellenfunktionen sind für große Datensätze sehr effizient. Das liegt unter anderem daran, dass JMP mehrere Prozessorkerne nutzt, JSL hingegen nicht. Bei kleinen Datensätzen verursacht das Erstellen der Tabelle jedoch einen erheblichen Mehraufwand. In meiner Anwendung hatte ich etwas Ähnliches wie PMroz in seiner Antwort, aber da meine Listen alle weniger als 1000 Einträge enthielten, bemerkte ich, dass dies die Laufzeit deutlich verlängerte.

Vielen Dank an alle!

Hinweis: Today() ist nur sekundengenau, Tick Seconds() auf 1/60 Sekunde genau und HP TIME() auf die Mikrosekunde. Dies hängt natürlich von Ihrem Computer ab. Um Ihnen einen fairen Vorteil zu verschaffen, habe ich Ihre Tabellen auf privat gesetzt und die Schließanweisung entfernt, was Ihr Skript beschleunigt.

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"