19506_ko-KR

liliconcom

목록 무작위화<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />

목록을 무작위로 추출해야 합니다.

randomizeList = 함수({목록}, {기본 로컬},

//여기에 코드가 들어갑니다

목록 반환;

);

목록 = {1,2,3,4,5};

randomList=randomizeList(목록);

인쇄(randomList); //예상되는 출력은 {2,4,5,1,3}과 같습니다.

이를 수행하는 방법에는 여러 가지가 있으며 잘못된 대답은 없습니다.어떤 피드백이라도 감사하겠습니다. 감사합니다! 

Re: 목록 무작위화

직선을 좋아합니다. 목록의 N^2 동작이 수정되었습니다!

Re: 목록 무작위화

방법 간의 차이는 그다지 크지 않지만 좀 더 쉽게 구별할 수 있도록 목록 크기를 늘렸습니다. 놀라운 점은 위 결과와 이들 결과 사이의 시간 차이입니다. 또한 pmroz의 방법이 10000행보다 100행에서 더 느리다는 것이 이상해 보입니다. 아마도 테이블을 만드는 작업을 반복했기 때문일까요?

JMP 13 베타 8

맥 2.5GHz 인텔 코어 i7

16GB 1600MHz DDR3

N개 품목	오후로즈	제프	바이런	필
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: 목록 무작위화

아래 코드는 네 가지 알고리즘을 비교합니다.데이터는 테이블에 저장된 후 그래프로 표시됩니다.JMP 13에서는 이것이 어떻게 보이는지 궁금합니다.

// pmroz 버전

pmroz_randomizeList = 기능 ({ 목록 } , { 기본 로컬 } ,

nr = 항목 ( 목록 ) ;

dt = 새 테이블 ( "" , 사적인 , 행 추가 ( nr ) ,

새 열 ( "데이터" , 숫자 , 마디 없는 , 체재 ( "최상의" , 12 ) ,

값 설정 ( 목록 ) ) ,

새 열 ( "무작위" , 숫자 , 마디 없는 , 체재 ( "최상의" , 12 ) ,

공식 ( 무작위 유니폼 () ) )

) ;

dt << 종류 ( 테이블 교체 , ~에 의해 ( : 무작위로 )) ;

무작위_목록 = dt : 데이터 << 가치를 얻다 ;

) ;

// Jeff Perkinson 2016년 7월 13일 오후 2:00 (Peter Mroz에게 응답)

jeff_randomizeList = 기능 ({ 목록 } , { 기본 로컬 } ,

목록 [ 계급 ( 제이 ( 항목 ( 목록 ) , 1 , 무작위 유니폼 ()))]

) ;

// 바이런의 함수

byron_randomizeList = 기능 ({ 목록 } , { 기본 로컬 } ,

nr = 항목 ( 목록 ) ;

rslist = 무작위 셔플 ( 1 :: nr ) ;

물집 = 목록 [ rslist [ 1 :: nr ]] ;

) ;

// 필립 브라운 2016년 7월 14일 오전 9:50

phil_randomizeList = 기능 ({ 목록 } , { 기본 로컬 } ,

목록 [ 계급 ( 반복하다 ({ 무작위 유니폼 ()} , 항목 ( 목록 ) ) )]

) ;

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

dt = 새 테이블 ( "무작위 목록" , 행 추가 ( 항목 ( 목록 ) ) ,

새 열 ( "N개 품목" , 숫자 , 마디 없는 , 체재 ( "최상의" , 12 ) ) ,

새 열 ( "pmroz" , 숫자 , 마디 없는 , 체재 ( "최상의" , 12 ) ) ,

새 열 ( "제프" , 숫자 , 마디 없는 , 체재 ( "최상의" , 12 ) ) ,

새 열 ( "바이런" , 숫자 , 마디 없는 , 체재 ( "최상의" , 12 ) ) ,

새 열 ( "필" , 숫자 , 마디 없는 , 체재 ( "최상의" , 12 ) )

) ;

~을 위한 ( 나 = 1 , 나 <= 항목 ( 목록 ) , 나 ++,

nm = 목록 [ 나 ] ;

dt : N개 품목 [ 나 ] = nm ;

나의 목록 = ( 목록으로 ( 1 :: nm ))[ 1 ] ;

시작 = 틱 초 () ;

무작위목록 = pmroz_randomizeList ( 나의 목록 ) ;

경과 = 틱 초 () - 시작 ;

dt : 오후로즈 [ 나 ] = 경과 ;

기다리다 ( 0 ) ;

시작 = 틱 초 () ;

무작위목록 = jeff_randomizeList ( 나의 목록 ) ;

경과 = 틱 초 () - 시작 ;

dt : 제프 [ 나 ] = 경과 ;

기다리다 ( 0 ) ;

시작 = 틱 초 () ;

무작위목록 = byron_randomizeList ( 나의 목록 ) ;

경과 = 틱 초 () - 시작 ;

dt : 바이런 [ 나 ] = 경과 ;

기다리다 ( 0 ) ;

시작 = 틱 초 () ;

무작위목록 = phil_randomizeList ( 나의 목록 ) ;

경과 = 틱 초 () - 시작 ;

dt : 필 [ 나 ] = 경과 ;

기다리다 ( 0 ) ;

) ;

dt << 그래프 빌더 ( 제어판 표시 ( 0 ) ,

변수 ( 엑스 ( : N개 품목 ) , 와이 ( : 오후로즈 ) , 와이 ( : 제프 , 위치 ( 1 ) ) , 와이 ( : 바이런 , 위치 ( 1 ) ) ,

와이 ( : 필 , 위치 ( 1 ) ) ) ,

강요 ( 포인트들 ( 엑스 , 와이 ( 1 ) , 와이 ( 2 ) , 와이 ( 삼 ) , 와이 ( 4 ) , 전설 ( 1 ) , 지터 ( 1 ) ) ,

더 매끄럽게 ( 엑스 , 와이 ( 1 ) , 와이 ( 2 ) , 와이 ( 삼 ) , 와이 ( 4 ) , 전설 ( 2 ) ) )

) ;

Re: 목록 무작위화

개인 테이블은 매우 유용하지만 조심하세요. 각 테이블은 더 적은 메모리를 보유합니다. 추적하기가 더 어렵습니다.개인 테이블을 만들고 열면 많은 메모리를 빠르게 차지할 수 있으며 위의 예와 같이 물리적 창이 없기 때문에 놓치기 쉽습니다.

그러나 닫을 필요가 없기 때문에 많은 시간을 절약할 수 있습니다. 변수를 보유하는 변수를 다시 할당하기만 하면 됩니다(이것이 위에서 의도한 것이지만 함수에 {Default Local}이 있다는 것을 인식하지 못했습니다). -- 맙소사!).

스크립팅 가이드에서:

개인 데이터 테이블

개인 인수를 포함하여 보기에서 데이터 테이블을 완전히 숨깁니다.

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

테이블을 비공개로 설정하면 스크립트가 많은 테이블을 열고 닫을 때 메모리 문제를 방지할 수 있습니다.

테이블. 프라이빗 데이터 테이블에는 물리적인 창이 없으므로 기존보다 적은 메모리가 필요합니다.

보이지 않는 테이블.

보이지 않는 테이블과 마찬가지로 개인 데이터 테이블에서 실행되는 분석은 테이블에 연결됩니다.

개인 데이터 테이블의 손실을 방지하려면 이전에 표시된 대로 참조를 할당해야 합니다.

예. 그렇지 않으면 JMP는 즉시 개인 데이터 테이블을 메모리에서 제거합니다.

나중에 스크립트에서 테이블을 추가로 사용하면 오류가 발생합니다.

Re: 목록 무작위화

또 다른 방법....

// 필립 브라운 2016년 7월 14일 오전 9:50

phil_randomizeList = 기능 ({aList},{기본 로컬},

목록[ 계급 ( 반복하다 ({ 무작위 유니폼 ()}, 항목 (목록) ) )]

);

이것이 내장 기능인 Random Shuffle보다 빠르다고는 생각하지 않지만 저는 항상 Repeat({}, n)을 사용하여 특정 애플리케이션에 대한 목록을 생성하는 것을 좋아했습니다.

Re: 목록 무작위화

그만큼 사적인 키워드가 흥미롭습니다. 테이블이 창 목록에도 표시되지 않습니다.나는 그것이 약간의 메모리를 절약한다고 상상합니다.나는 이것을 여러 곳에서 사용할 수 있습니다.고마워요 msharp!

Re: 목록 무작위화

그러면 JMP 13의 삽입 항목 변경으로 동일한 문제가 해결됩니까?이것은 좋은 소식입니다!

Re: 목록 무작위화

테이블 함수는 대규모 데이터 세트에 매우 효율적입니다.주된 이유 중 하나는 b/c JMP는 다중 코어를 활용하는 반면 JSL은 그렇지 않기 때문입니다.그러나 작은 데이터 세트의 경우 테이블을 생성하는 프로세스로 인해 많은 오버헤드가 추가됩니다.내가 이것을 사용하는 애플리케이션의 경우 실제로 PMroz의 답변과 비슷한 것이 있었지만 내 목록이 모두 <1000개 항목이었기 때문에 꽤 많은 시간이 추가된다는 것을 알았습니다.

모두 감사합니다!

참고: Today()는 초까지만 정확하고, Tick Seconds()는 1/60초까지 정확하며, HP TIME()은 마이크로초까지 정확합니다.물론 이것은 모두 컴퓨터에 따라 다릅니다.또한 공정한 이점을 제공하기 위해 테이블을 비공개로 변경하고 close 문을 제거하여 스크립트 속도를 높였습니다.

기본 이름은 여기에 있습니다. ( 1 ) ;

// pmroz 버전

pmroz_randomizeList = 기능 ({ 목록 } , { 기본 로컬 } ,

dt = 새 테이블 ( "" , 사적인 ,

새 열 ( "데이터" , 값 설정 ( 목록 ) ) ,

새 열 ( "무작위" , 숫자 , 마디 없는 , 공식 ( 무작위 유니폼 () ) )

) ;

dt << 종류 ( 테이블 교체 , ~에 의해 ( : 무작위로 )) ;

무작위_목록 = dt : 데이터 << 가치를 얻다 ;

) ;

// Jeff Perkinson 2016년 7월 13일 오후 2:00 (Peter Mroz에게 응답)

jeff_randomizeList = 기능 ({ 목록 } , { 기본 로컬 } ,

목록 [ 계급 ( 제이 ( 항목 ( 목록 ) , 1 , 무작위 유니폼 ()))]

) ;

// 바이런의 함수

byron_randomizeList = 기능 ({ 목록 } , { 기본 로컬 } ,

nr = 항목 ( 목록 ) ;

rslist = 무작위 셔플 ( 1 :: nr ) ;

물집 = 목록 [ rslist [ 1 :: nr ]] ;

) ;

nm = 100 ; // 목록 요소의 수를 설정합니다.

아이맥스 = 100 ; // 반복 횟수 설정

나의 목록 = ( 목록으로 ( 1 :: nm ))[ 1 ] ;

시작 = HP 시간 () ;

을 위한 ( 나 = 1 , 나 <= 아이맥스 , 나 ++,

무작위목록 = pmroz_randomizeList ( 나의 목록 ) ;

) ;

경과 = HP 시간 () - 시작 ;

인쇄 ( "pmroz: " || 숯 ( 경과 )) ;

기다리다 ( 0 ) ;

시작 = HP 시간 () ;

을 위한 ( 나 = 1 , 나 <= 아이맥스 , 나 ++,

무작위목록 = jeff_randomizeList ( 나의 목록 ) ;

) ;

경과 = HP 시간 () - 시작 ;

인쇄 ( "제프: " || 숯 ( 경과 )) ;

기다리다 ( 0 ) ;

시작 = HP 시간 () ;

을 위한 ( 나 = 1 , 나 <= 아이맥스 , 나 ++,

무작위목록 = byron_randomizeList ( 나의 목록 ) ;

) ;

경과 = HP 시간 () - 시작 ;

인쇄 ( "바이런: " || 숯 ( 경과 )) ;

기다리다 ( 0 ) ;

//산출

"pmroz: 121646"

"제프: 3990"

"바이런: 3488"

Re: 목록 무작위화

JMP 13에서는 결과가 변경됩니다.

빠른 목록

400,000은 JMP 13에서 다음과 같습니다.

"pmroz: 0.533333333332848"

"제프: 0.233333333333576"

"바이런: 0.216666666667152"

Re: 목록 무작위화

매우 흥미로운.내 테이블 솔루션은 일종의 무차별 대입처럼 보였지만 목록 요소 수가 15,000을 초과하면 다른 두 기능보다 성능이 뛰어납니다. 테이블 함수는 분명히 매우 효율적입니다.

내가 사용한 코드는 다음과 같습니다.

// pmroz 버전

pmroz_randomizeList = 기능 ({ 목록 } , { 기본 로컬 } ,

nr = 항목 ( 목록 ) ;

dt = 새 테이블 ( "" , 보이지 않는 , 행 추가 ( nr ) ,

새 열 ( "데이터" , 숫자 , 마디 없는 , 체재 ( "최상의" , 12 ) ,

값 설정 ( 목록 ) ) ,

새 열 ( "무작위" , 숫자 , 마디 없는 , 체재 ( "최상의" , 12 ) ,

공식 ( 무작위 유니폼 () ) )

) ;

dt << 종류 ( 테이블 교체 , ~에 의해 ( : 무작위로 )) ;

무작위_목록 = dt : 데이터 << 가치를 얻다 ;

닫다 ( dt , 노세이브 ) ;

무작위_목록 ;

) ;

// Jeff Perkinson 2016년 7월 13일 오후 2:00 (Peter Mroz에게 응답)

jeff_randomizeList = 기능 ({ 목록 } , { 기본 로컬 } ,

목록 [ 계급 ( 제이 ( 항목 ( 목록 ) , 1 , 무작위 유니폼 ()))]

) ;

// 바이런의 함수

byron_randomizeList = 기능 ({ 목록 } , { 기본 로컬 } ,

nr = 항목 ( 목록 ) ;

rslist = 무작위 셔플 ( 1 :: nr ) ;

물집 = 목록 [ rslist [ 1 :: nr ]] ;

) ;

nm = 4000 ; // 목록 요소의 수를 설정합니다.

나의 목록 = ( 목록으로 ( 1 :: nm ))[ 1 ] ;

시작 = 오늘 () ;

무작위목록 = pmroz_randomizeList ( 나의 목록 ) ;

경과 = 오늘 () - 시작 ;

인쇄 ( "pmroz: " || 숯 ( 경과 )) ;

기다리다 ( 0 ) ;

나의 목록 = ( 목록으로 ( 1 :: nm ))[ 1 ] ;

시작 = 오늘 () ;

무작위목록 = jeff_randomizeList ( 나의 목록 ) ;

경과 = 오늘 () - 시작 ;

인쇄 ( "제프: " || 숯 ( 경과 )) ;

기다리다 ( 0 ) ;

나의 목록 = ( 목록으로 ( 1 :: nm ))[ 1 ] ;

시작 = 오늘 () ;

무작위목록 = byron_randomizeList ( 나의 목록 ) ;

경과 = 오늘 () - 시작 ;

인쇄 ( "바이런: " || 숯 ( 경과 )) ;

기다리다 ( 0 ) ;

Re: 목록 무작위화

JMP에서는 어떤 작업을 수행하는 데 거의 항상 세 가지 이상의 방법이 있습니다.그럼 여기 세 번째가 있습니다.

alist로 시작하여 alist의 항목 수와 동일한 숫자를 섞은 목록을 만듭니다. 그런 다음 rslist 순서대로 alist 값을 사용하여 blist를 만듭니다.

알리스트={a,b,c, 1 , 2 , 삼 };

RS목록= 무작위 셔플 ( 1 :: 항목 (목록));

블리스트=알리스트[rslist[ 1 :: 항목 (목록)]];

목록에서 숫자, 문자 또는 조합을 사용하는지 여부는 중요하지 않습니다.

나는 JSL 안내서에서 이 아이디어를 얻었다고 확신합니다.

-바이런

Re: 목록 무작위화

내 구현은 다음과 같습니다.

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

내가 여기서 무엇을 하고 있는지 확실하지 않은 경우

• 그만큼 제이() 함수는 난수 행렬을 생성합니다. 예: [0.04757597646676, 0.738883488578722, 0.935981905087828, 0.0233044682536274, 0.493906983872876]
• 그만큼 계급() 함수는 행렬을 반환합니다(예: 위의 경우: [4, 1, 5, 2, 3] )는 난수를 정렬한 순서대로 원래 목록을 반환하는 데 사용됩니다.

-제프

Re: 목록 무작위화

이를 수행하는 한 가지 방법이 있습니다.다른 접근법을 보고 싶습니다!

무작위 목록 = 기능 ({ 목록 } , { 기본 로컬 } ,

nr = 항목 ( 목록 ) ;

dt = 새 테이블 ( "" , 보이지 않는 , 행 추가 ( nr ) ,

새 열 ( "데이터" , 숫자 , 마디 없는 , 체재 ( "최상의" , 12 ) ,

값 설정 ( 목록 ) ) ,

새 열 ( "무작위" , 숫자 , 마디 없는 , 체재 ( "최상의" , 12 ) ,

공식 ( 무작위 유니폼 () ) )

) ;

dt << 종류 ( 테이블 교체 , ~에 의해 ( : 무작위로 )) ;

무작위_목록 = dt : 데이터 << 가치를 얻다 ;

닫다 ( dt , 노세이브 ) ;

무작위_목록 ;

) ;

목록 = { 1 , 2 , 삼 , 4 , 5 } ;

무작위목록 = 무작위 목록 ( 목록 ) ;

인쇄 ( 무작위목록 ) ; //예상되는 출력은 {2,4,5,1,3}과 같습니다.

제목: 목록 무작위화

다음은 제가 구현한 코드입니다.

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

제가 여기서 무슨 일을 하고 있는지 명확하지 않으실까 봐 말씀드립니다.

• j() 함수는 [0.04757597646676, 0.738883488578722, 0.935981905087828, 0.0233044682536274, 0.493906983872876] 과 같은 난수 행렬을 생성합니다.
• 계급() 함수는 행렬(예: 위의 예: [4, 1, 5, 2, 3] )을 반환하며, 이 행렬은 원래 목록을 난수 순서대로 정렬하는 데 사용됩니다.

-제프

제목: 목록 무작위화

이것이 한 가지 방법입니다. 다른 접근 방식도 보고 싶네요!

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}

리스트를 무작위로 섞기

목록을 무작위로 배열해야 합니다.

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}

이 문제를 해결하는 방법은 여러 가지가 있으며 정답은 없습니다. 어떤 의견이든 감사히 받겠습니다!

대량 맞춤화제목: 목록 무작위화

매우 흥미롭네요. 제가 제시한 표 기반 해결책은 다소 무식해 보이지만, 리스트 요소 수가 15,000개를 넘으면 다른 두 함수보다 성능이 뛰어납니다. 표 기반 함수가 생각보다 효율적이라는 것을 알게 되었습니다.

제가 사용한 코드는 다음과 같습니다.

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

제목: 목록 무작위화

테이블 함수는 대규모 데이터 세트에 매우 효율적입니다. 주요 이유 중 하나는 JMP가 JSL과 달리 멀티 코어를 활용하기 때문입니다. 그러나 소규모 데이터 세트의 경우 테이블을 생성하는 과정에서 상당한 오버헤드가 발생합니다. 제가 이 기능을 사용하려는 애플리케이션의 경우, PMroz님의 답변과 비슷한 상황이었지만, 제 리스트들은 모두 1000개 미만의 항목으로 구성되어 있었기 때문에 시간이 상당히 많이 소요되는 것을 확인했습니다.

모두 감사합니다!

참고: Today() 함수는 초 단위까지 정확하고, Tick Seconds() 함수는 1/60초 단위까지 정확하며, HP TIME() 함수는 마이크로초 단위까지 정확합니다. 물론 이 모든 것은 컴퓨터 사양에 따라 달라집니다. 또한, 공정한 실행을 위해 테이블을 비공개로 변경하고 close 문을 제거하여 스크립트 속도를 향상시켰습니다.

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"