nav[aria-label="Primary Navigation"] { padding: 0; & ul { list-style: none; width: 100%; display: flex; flex-direction: row; justify-content: start; align-items: start; gap: 30px; padding: 0; & li { margin: 0; } & ul li { list-style: none; } } }

19506_zh-CN

liliconcom

随机化列表

我需要随机化一个列表。

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 时，它的性能优于其他两个函数。表函数显然非常有效。

12002_Randomize List Algorithms.png

这是我使用的代码：

// 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, 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 时，它的性能优于其他两种函数。表格函数显然非常高效。

12002_Randomize List Algorithms.png

以下是我使用的代码：

// 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"

Comments

There are no comments yet