19506_zh-TW

liliconcom

隨機化列表<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />

我需要隨機化一個清單。

randomizeList = Function({列表}, {預設本地},

//程式碼放在這裡

返回列表；

）；

列表 = {1,2,3,4,5};

randomList = randomizeList(列表);

列印（隨機列表）； //預期輸出類似{2,4,5,1,3}

有很多方法可以做到這一點，並且沒有錯誤的答案。感謝任何反饋，謝謝！ 

回覆：隨機化列表

喜歡直線；列表的 N^2 行為是固定的！

回覆：隨機化列表

我增加了列表大小以幫助更好地區分，儘管方法之間的差異並不大。 令人驚訝的是上述結果與這些結果之間的時間差異。 另外，pmroz 的方法在處理 100 行時比處理 10000 行時慢，這似乎很奇怪。 也許是因為重複做桌子的任務？

JMP 13 測試版 8

Mac 2.5 GHz 英特爾酷睿 i7

16 GB 1600 MHz 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
50萬	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

回覆：隨機化列表

下面的程式碼比較了四種演算法。數據儲存在表格中，然後繪製成圖表。我很好奇這在 JMP 13 中是什麼樣子？

// pmroz 版本

pmroz_randomizeList =功能({一個列表} , {預設本地} ,

號=尼特姆斯（一個列表） ;

dt =新表（ ”” ,私人的,新增行（號） ,

新專欄（ “數據” ,數位,連續的,格式（ “最好的” , 12 ） ,

設定值（一個列表） ） ,

新專欄（ “隨機” ,數位,連續的,格式（ “最好的” , 12 ） ,

公式（隨機制服() ） ）

） ;

dt <<種類（更換表,經過（ :隨機化）） ;

隨機列表= dt :數據<<獲取值;

） ;

// Jeff Perkinson 2016 年 7 月 13 日下午 2:00（回覆 Peter Mroz）

jeff_randomizeList =功能({一個列表} , {預設本地} ,

一個列表[秩（ j （尼特姆斯（一個列表） , 1 ,隨機制服()))]

） ;

// 拜倫函數

byron_randomizeList =功能({一個列表} , {預設本地} ,

號=尼特姆斯（一個列表） ;

RS列表=隨機洗牌（ 1 ::號） ;

水泡=一個列表[ RS列表[ 1 ::號]] ;

） ;

// 菲利普布朗 2016 年 7 月 14 日上午 9:50

phil_randomizeList =功能({一個列表} , {預設本地} ,

一個列表[秩（重複({隨機制服()} ,尼特姆斯（一個列表） ） )]

） ;

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

dt =新表（ “隨機清單” ,新增行（尼特姆斯（清單） ） ,

新專欄（ “N 項” ,數位,連續的,格式（ “最好的” , 12 ） ） ,

新專欄（ “pmroz” ,數位,連續的,格式（ “最好的” , 12 ） ） ,

新專欄（ “傑夫” ,數位,連續的,格式（ “最好的” , 12 ） ） ,

新專欄（ “拜倫” ,數位,連續的,格式（ “最好的” , 12 ） ） ,

新專欄（ “菲爾” ,數位,連續的,格式（ “最好的” , 12 ） ）

） ;

為了（我= 1 ,我<=尼特姆斯（清單） ,我++,

奈米=清單[我] ;

dt : N 項[我] =奈米;

我的列表= （作為列表（ 1 ::奈米))[ 1 ] ;

開始=滴答秒() ;

隨機列表= pmroz_randomizeList （我的列表） ;

過去=滴答秒() -開始;

dt ：普羅茲[我] =過去;

等待（ 0 ） ;

開始=滴答秒() ;

隨機列表= jeff_randomizeList （我的列表） ;

過去=滴答秒() -開始;

dt :傑夫[我] =過去;

等待（ 0 ） ;

開始=滴答秒() ;

隨機列表= byron_randomizeList （我的列表） ;

過去=滴答秒() -開始;

dt :拜倫[我] =過去;

等待（ 0 ） ;

開始=滴答秒() ;

隨機列表= phil_randomizeList （我的列表） ;

過去=滴答秒() -開始;

dt :菲爾[我] =過去;

等待（ 0 ） ;

） ;

dt <<圖形產生器（顯示控制面板（ 0 ） ,

變數（ X （ : N 項） ,是（ :普羅茲） ,是（ ：傑夫,位置（ 1 ） ） ,是（ :拜倫,位置（ 1 ） ） ,

是（ :菲爾,位置（ 1 ） ） ） ,

元素（積分（ X ,是（ 1 ） ,是（ 2 ） ,是（ 3 ） ,是（ 4 ） ,傳奇（ 1 ） ,抖動（ 1 ） ） ,

更順暢（ X ,是（ 1 ） ,是（ 2 ） ,是（ 3 ） ,是（ 4 ） ,傳奇（ 2 ） ） ）

） ;

回覆：隨機化列表

私有表非常有用，但要小心，因為每個表佔用的記憶體較少；他們更難追蹤。透過建立和開啟私有資料表，您可以快速佔用大量內存，並且很容易錯過，因為它們沒有實體視窗（如我上面的範例）。

但是，它們可以為您節省大量時間，因為您不需要關閉它們，您只需重新分配保存它們的變數即可（這就是我上面的目的，但沒有意識到您的函數有一個 {Default Local} — —衛生部！）。

來自腳本指南：

私人資料表

透過包含 private 參數，從視圖中完全隱藏資料表：

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

將表設定為私有可以防止腳本開啟和關閉多個表時出現記憶體問題

表。私有資料表沒有實體窗口，因此需要的記憶體比私有資料表少

看不見的桌子。

與不可見表一樣，在私有資料表上執行的分析也連結到該表。

為了避免遺失私有資料表，您必須為其指派一個引用，如前面所示

例子。否則，JMP 會立即從記憶體中刪除私有資料表。

稍後在腳本中對該表的其他使用會產生錯誤。

回覆：隨機化列表

還有另一種方式......

// 菲利普布朗 2016 年 7 月 14 日上午 9:50

phil_randomizeList =功能({aList},{預設本地},

一個列表[秩（重複({隨機制服()},尼特姆斯（一個列表） ） ）]

）；

我不認為這比內建函數 Random Shuffle 更快，但我一直喜歡使用 Repeat({}, n) 為某些應用程式產生清單。

回覆：隨機化列表

這私人的關鍵字很有趣 - 該表甚至沒有顯示在視窗列表中。我想它可以節省一點內存。我可以在很多地方使用它。謝謝msharp！

回覆：隨機化列表

那麼 JMP 13 Insert Into 變更將解決相同的問題嗎？這是個好消息！

回覆：隨機化列表

表函數對於大型資料集非常有效。主要原因之一是 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 =功能({一個列表} , {預設本地} ,

一個列表[秩（ j （尼特姆斯（一個列表） , 1 ,隨機制服()))]

） ;

// 拜倫函數

byron_randomizeList =功能({一個列表} , {預設本地} ,

號=尼特姆斯（一個列表） ;

RS列表=隨機洗牌（ 1 ::號） ;

水泡=一個列表[ RS列表[ 1 ::號]] ;

） ;

奈米= 100 ; // 設定列表元素數量

大麥克= 100 ; // 設定迭代次數

我的列表= （作為列表（ 1 ::奈米))[ 1 ] ;

開始=惠普時間() ;

為了（我= 1 ,我<=大麥克,我++,

隨機列表= pmroz_randomizeList （我的列表） ;

） ;

過去=惠普時間() -開始;

列印（ “pmroz：” ||字元（過去）） ;

等待（ 0 ） ;

開始=惠普時間() ;

為了（我= 1 ,我<=大麥克,我++,

隨機列表= jeff_randomizeList （我的列表） ;

） ;

過去=惠普時間() -開始;

列印（ “傑夫：” ||字元（過去）） ;

等待（ 0 ） ;

開始=惠普時間() ;

為了（我= 1 ,我<=大麥克,我++,

隨機列表= byron_randomizeList （我的列表） ;

） ;

過去=惠普時間() -開始;

列印（ “拜倫：” ||字元（過去）） ;

等待（ 0 ） ;

//輸出

“pmroz：121646”

“傑夫：3990”

“拜倫：3488”

回覆：隨機化列表

結果將在 JMP 13 中發生變化。

快速列表

400,000 在 JMP 13 中如下所示：

“pmroz：0.533333333332848”

“傑夫：0.233333333333576”

“拜倫：0.216666666667152”

回覆：隨機化列表

很有意思。我的表解決方案似乎有點蠻力，但當列表元素的數量超過 15,000 時，它的性能優於其他兩個函數。表函數顯然非常有效。

這是我使用的程式碼：

// pmroz 版本

pmroz_randomizeList =功能({一個列表} , {預設本地} ,

號=尼特姆斯（一個列表） ;

dt =新表（ ”” ,無形的,新增行（號） ,

新專欄（ “數據” ,數位,連續的,格式（ “最好的” , 12 ） ,

設定值（一個列表） ） ,

新專欄（ “隨機” ,數位,連續的,格式（ “最好的” , 12 ） ,

公式（隨機制服() ） ）

） ;

dt <<種類（更換表,經過（ ：隨機化）） ;

隨機列表= dt :數據<<獲取值;

關閉（ dt ,不保存） ;

隨機列表;

） ;

// Jeff Perkinson 2016 年 7 月 13 日下午 2:00（回覆 Peter Mroz）

jeff_randomizeList =功能({一個列表} , {預設本地} ,

一個列表[秩（ j （尼特姆斯（一個列表） , 1 ,隨機制服()))]

） ;

// 拜倫函數

byron_randomizeList =功能({一個列表} , {預設本地} ,

號=尼特姆斯（一個列表） ;

RS列表=隨機洗牌（ 1 ::號） ;

水泡=一個列表[ RS列表[ 1 ::號]] ;

） ;

奈米= 4000 ; // 設定列表元素數量

我的列表= （作為列表（ 1 ::奈米))[ 1 ] ;

開始=今天() ;

隨機列表= pmroz_randomizeList （我的列表） ;

過去=今天() -開始;

列印（ “pmroz：” ||字元（過去）） ;

等待（ 0 ） ;

我的列表= （作為列表（ 1 ::奈米))[ 1 ] ;

開始=今天() ;

隨機列表= jeff_randomizeList （我的列表） ;

過去=今天() -開始;

列印（ “傑夫：” ||字元（過去）） ;

等待（ 0 ） ;

我的列表= （作為列表（ 1 ::奈米))[ 1 ] ;

開始=今天() ;

隨機列表= byron_randomizeList （我的列表） ;

過去=今天() -開始;

列印（ “拜倫：” ||字元（過去）） ;

等待（ 0 ） ;

回覆：隨機化列表

在 JMP 中，幾乎總是至少有三種方法可以完成任何操作。這是第三個。

從 alist 開始，建立一個與 alist 中的項目數相等的打亂數字清單。 然後用alist的值按照rslist的順序製作blist。

列表={a,b,c, 1 , 2 , 3 };

rs列表=隨機洗牌（ 1 ::尼特姆斯（一個列表））;

blist=列表[rslist[ 1 ::尼特姆斯（一個列表）]];

無論您使用清單中的數字、字元還是組合，都沒關係。

我很確定我是從 JSL 配套書中得到這個想法的

——拜倫

回覆：隨機化列表

這是我的實現。

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] ）用於按隨機數排序的順序傳回原始列表。

-傑夫

回覆：隨機化列表

這是一種方法。很想看到其他方法！

隨機列表=功能({清單} , {預設本地} ,

號=尼特姆斯（清單） ;

dt =新表（ ”” ,無形的,新增行（號） ,

新專欄（ “數據” ,數位,連續的,格式（ “最好的” , 12 ） ,

設定值（清單） ） ,

新專欄（ “隨機” ,數位,連續的,格式（ “最好的” , 12 ） ,

公式（隨機制服() ） ）

） ;

dt <<種類（更換表,經過（ ：隨機化）） ;

隨機列表= dt :數據<<獲取值;

關閉（ dt ,不保存） ;

隨機列表;

） ;

清單= { 1 , 2 , 3 , 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, 0828, 0.0233044682536274, 0.493872383873838387387276838387387387 ]
• 秩（）函數傳回一個矩陣（例如，對於上面的範例： [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"