每日随机高尔夫＃1：随机排列

35

关于系列

我将围绕随机性主题运行一系列代码高尔夫球挑战。这基本上是一个9洞 高尔夫球场，但涉及多个问题。您可以单独参加任何挑战，就像是正常问题一样。

但是，我将在所有挑战中保持领先。该系列将运行9个挑战（目前），每隔几天发布一次。参加所有9个挑战的每个用户都有资格赢得整个系列赛。他们的总体分数是每个挑战中最短提交的总和（因此，如果您回答一次挑战两次，则只有得分更高的一个才计入分数）。如果有任何人在28天的时间里保持排行榜榜首，我将奖励他们500代表。

尽管我在本系列中有很多想法，但未来的挑战还没有定下来。如果您有任何建议，请在相关的沙箱帖子上让我知道。

漏洞1：随机排列数组

第一项任务非常简单：给定一个非空的整数数组，将其随机洗牌。但是有一些规则：

  • 必须以相同的概率返回所有可能的排列（因此，混洗应具有均匀的分布）。您可以通过在Will It Shuffle上的JavaScript中实现算法来检查算法是否统一/无偏，这将生成偏差矩阵-结果看起来应与内置的Fisher-Yates或sort（随机顺序）一样均匀。
  • 您不得使用任何内置方法或第三方方法来随机排列数组或生成随机排列（或枚举所有排列）。特别是，您可能使用的唯一内置随机函数是一次获取一个随机数。您可以假定任何内置随机数方法都在O（1）中运行并且在请求的间隔内完全统一（从数学意义上讲，您可以在此处忽略浮点表示的详细信息）。如果您的语言允许您一次获取m个随机数的列表，则可以使用此功能，前提是m个数彼此独立，并将其计为O（m）。
  • 您的实现不得超过O（N）的时间复杂度，其中N是要改组的数组的大小。例如，您不能“按随机数排序”。
  • 您可以在适当位置随机排列数组，也可以创建一个新数组（在这种情况下，可以根据需要修改旧数组）。

您可以编写完整的程序或函数，并通过STDIN，命令行参数，函数参数或提示接受输入，并通过返回值或通过打印到STDOUT（或最接近的替代方法）来产生输出。如果编写的函数可以在适当的位置随机排列数组，那么您当然不需要返回它（前提是您的语言允许您在函数返回后访问修改后的数组）。

输入和输出可以是任何方便的列表或字符串的格式，但必须支持任意的整数范围-2 31 ≤X <2 31。原则上，您的代码应适用于长度最大为2 31的数组，尽管这不一定必须适合您的内存或在合理的时间内完成。（我只是不想看到硬编码循环或其他内容的任意大小限制。）

这是代码高尔夫球，因此最短的提交（以字节为单位）获胜。

排行榜

以下代码片段将在该系列的所有挑战中产生一个排行榜。

为确保您的答案显示出来，请使用以下Markdown模板以标题开头每个答案：

# Language Name, N bytes

N您提交的文件大小在哪里。如果您提高了分数，则可以通过打败旧分数来保持标题。例如：

# Ruby, <s>104</s> <s>101</s> 96 bytes

（目前未显示该语言，但是该代码段确实需要并对其进行解析，并且将来我可能会添加一个语言排行榜。）

显示代码段

code-golf  random  array-manipulation  permutations 
— 马丁·恩德
source
7
令我们失望的是，我们不允许“聪明”地使用库函数，而不是“获取随机数”。我们是否还要查看Fisher-Yates改组的另外69种实现？请考虑在以后的任务中删除此规则。另外，为什么要限制时间复杂度？请考虑将其放宽到至少O（n ^ 2）；我还认为，如果您允许O（n！），则有人可能会发现一种特别出色的实现。
— anatolyg 2015年
7
@anatolyg取消限制意味着每个答案要么是sortby(random)（时间限制的原因），要么仅仅是.shuffle()（内置限制的原因），我认为这比必须实施Fisher-Yates或其他方法要聪明得多。方法。
— 马丁·恩德
1
如果改组到位，函数是否必须返回数组，或者对其进行修改是否足够？我可以写一个函数shuffle(array)，而不是newArray=shuffle(array)？
— Geobits'2
1
@Bakuriu声称如果数字固定则可以按线性时间排序，这有点像声称如果输入大小固定就可以在O（1）中进行任何操作。同样相关的限制是固定大小的数组，而不是固定大小的整数-因为数组大小决定了您需要随机数的大小。无论如何，时间复杂度的限制当然是要实现的通用算法，而输入大小的限制已经到位，因此，如果您的语言没有开箱即用地使用它们，则不必使用任意精度的整数。
— 马丁·恩德
2
为什么Adám的解决方案实际上是14个字节，却变成了43319个字节？
— boboquack

Answers:

20

Dyalog APL，25个 24字节

25个字符的解决方案的第一个： i{⊃a[⍺⍵]←a[⍵⍺]}¨?i←⌽⍳⍴a←⎕

                      a←⎕ ⍝ evaluated input, assign to "a"
                     ⍴a   ⍝ length
                    ⍳⍴a   ⍝ 1 2 .. length
                   ⌽⍳⍴a   ⍝ length .. 2 1
                 i←       ⍝ assign to "i"
                ?i        ⍝ random choices: (1..length)(1..length-1)..(1 2)(1)
i{            }¨?i        ⍝ for each index ⍺ and corresponding random choice ⍵
   a[⍺⍵]←a[⍵⍺]            ⍝ swap a[⍺] and a[⍵]
        ←                 ⍝ in Dyalog, assignment returns its right-hand side
  ⊃                       ⍝ first element, i.e. a[⍵]
                          ⍝ the result from {} is an array of all those a[⍵]

经过以上的等效转换后：

i {}¨ ?i  ←→  i {}¨∘? i   ⍝ because A f∘g B ←→ A f g B
          ←→  {}¨∘?⍨ i    ⍝ because f⍨ B ←→ B f B

我们可以摆脱分配i←并保存一个字符：

{⊃a[⍺⍵]←a[⍵⍺]}¨∘?⍨⌽⍳⍴a←⎕

— ngn
source
3
...介意。吹
— danwyand'2
1
我必须从右到左阅读的语言？哇！
— 发光的
5
@Luminous，通常是用数学符号表示的情况：sin cos ln sqrt x
— ngn
4
用@ngn表示时，我以前的评论看起来很可笑。哈。
— 发光的
5
@ronalchn存在用于APL 8位编码，像这样的一个或这另一个; 我听说 Dyalog使用其中一种作为Unicode的替代方法。
— anatolyg 2015年
12

80386计算机代码，44 24字节

代码的十六进制转储：

60 8b fa 0f c7 f0 33 d2 f7 f1 49 8b 04 8f 87 04
97 89 04 8f 75 ed 61 c3

感谢FUZxxl，他建议使用该rdrand说明。

这是源代码（可以由Visual Studio编译）：

__declspec(naked) void __fastcall shuffle(unsigned size, int array[])
{
    // fastcall convention:
    // ecx = size
    // edx = array
    _asm
    {
        pushad;             // save registers
        mov edi, edx;       // edi now points to the array

    myloop:
        rdrand eax;         // get a random number
        xor edx, edx;
        div ecx;            // edx = random index in the array

        dec ecx;            // count down
        mov eax, [edi + 4 * ecx];   // swap elements
        xchg eax, [edi + 4 * edx];  // swap elements
        mov [edi + 4 * ecx], eax;   // swap elements
        jnz myloop;

        popad;              // restore registers
        ret;
    }
}

Fisher-Yates的另一个实现。大部分高尔夫运动都是通过在寄存器中传递参数来实现的。

— 阿纳托利格
source
1
您可能还曾经使用rdrand过狗屎和傻笑。
— FUZxxl 2015年
@FUZxxl我完全忘记了！太糟糕了，它删除了关于我的答案的最有趣的部分……
— anatolyg 2015年
9

Java中，88 101

基本的Fisher-Yates混洗可以解决问题。我觉得它在这里很常用，因为它实现起来既快捷又容易。这里也有一些循环/分配这里临时抱佛脚，但有不老实过太多的高尔夫球; 它只是天生的短暂。

void t(int[]s){for(int i=s.length,t,x;i>0;t=s[x*=Math.random()],s[x]=s[i],s[i]=t)x=i--;}

有一些换行符：

void t(int[]s){
    for(int i=s.length,t,x;
        i>0;
        t=s[x*=Math.random()],
        s[x]=s[i],
        s[i]=t
    )
        x=i--;
}

这会改组到位，从而修改原始数组s[]。测试程序：

public class Shuffle {
    public static void main(String[] args) {
        int[] a = {1,2,3,4,5,6,7,8,9};
        new Shuffle().t(a);
        for(int b:a)
            System.out.print(b+" ");
    }
    void t(int[]s){for(int i=s.length,t,x;i>0;t=s[x*=Math.random()],s[x]=s[i],s[i]=t)x=i--;}
}
— 地位
source
1
不，挑战说明您可以假设它“ 在请求范围内完全一致 ”。要求的范围的Math.random()大小是2的幂，因此不符合规格。
— 彼得·泰勒
1
@PeterTaylor Jan和Geobits的解释确实是我要遵循的规则-您不必担心PRNG的实际周期长度。
— Martin Ender
1
@MartinBüttner周期长度不是这里的问题-您的规则已涵盖了该问题。浮子的粗糙度是。
— John Dvorak
3
@TheBestOne 比当前发布的唯一python解决方案短一个字节；）
— Geobits，2015年
1
不再！：D
— Sp3000
8

Python 2，86个字节

from random import*
def S(L):i=len(L);exec"i-=1;j=randint(0,i);L[i],L[j]=L[j],L[i];"*i

该函数使用Fisher-Yates shuffle的直接实现，将数组无序地按位洗净而不返回它。从Python获取随机数非常昂贵 ...

感谢@xnor和@colevk的提示。

— Sp3000
source
该范围表达式看起来很麻烦。当然，手动倒数为会更短while i:i-=1;...吗？
— xnor
@xnor是的-谢谢。我忘了，这种趋势while往往比for这种事情要短……
— Sp3000
1
Awww ...现在我的Java回答还不行。我很高兴很短的时间:(
— Geobits
您可以通过i=len(L)将减量放在while循环的开始处来另外节省2个字节。
— colevk
8

J，45 44个字符

这是一个棘手的问题。

<@({.,?@#@}.({,<^:3@[{])}.)&>/@(<"0@i.@#,<)

这里是一个解释：

  1. # y：该帐簿的y，即，在元件的数量y。
  2. ?@# y：一个随机数均匀分布在从1到的范围内(#y)-1。
  3. x { y：来自 y index 的项目x。
  4. (<<<x) { y：除中索引x中的项目外的所有项目y。
  5. x , y：y 附加到x。
  6. x ({ , <^:3@[ { ]) y：索引项x中y，则所有其他项目。
  7. (?@# ({ , <^:3@[ { ]) ]) y从中随机抽取y，然后是所有其他项目。
  8. x {. y：从中提取的第一x项。y
  9. x }. y：第一x项下降的y。
  10. x ({. , }.) y：从提取第一个x项目，然后从删除第一个项目yxy
  11. x ({. , (?@# ({ , <^:3@[ { ]) ])@}.) y：第一x项采取从y，则第一x项从y处理为在编号7。
  12. x ({. , ?@#@}. ({ , <^:3@[ { ]) }.) y：放下相同的东西以保存一个字符。
  13. u/ y：u 插入 的项目之间y。
  14. < y：y 盒装。
  15. <"0 y：每y 盒装。
  16. i. y：从到的整数。0y - 1
  17. i.@# y：从到的整数。0(#y) - 1
  18. (<"0@i.@# , <) y：整数从0到(#y) - 1每个装箱的框，然后y在一个框内。这是必需的，因为J中的数组是统一的。框会隐藏其内容的形状。
  19. x u&v y：喜欢(v x) u (v y)。
  20. > y：y 打开，即没有其框。
  21. x ({. , ?@#@}. ({ , <^:3@[ { ]) }.)&> y 来自数字12的短语应用于其未装箱的参数。
  22. ({. , ?@#@}. ({ , <^:3@[ { ]) }.)&>/ y在21个 项目之间插入的 21号短语y。
  23. ({. , ?@#@}. ({ , <^:3@[ { ]) }.)&>/@(<"0@i.@# , <) y将来自22的短语应用于来自18的短语的结果，或者对的各项进行统一排列y。
— FUZxxl
source
1
我只是无法区分所有括号。而那个三重拳击<@<@<@[也是一个谜...等待解释。：）
— randomra
2
一旦对此做出解释，我可能会更愿意赞成这个答案；-)
— John Dvorak 2015年
@randomra你去。
— FUZxxl 2015年
@JanDvorak的解释是否令人满意？
— FUZxxl 2015年
很好的解释！我不知道from（{）的所有框式用法。我真的很喜欢&>/操纵列表的技巧。我敢肯定我以前可以使用几次。
— randomra 2015年
5

Pyth，25个字节

在这里测试。

Fisher-Yates的另一个实现。基本上与pyth中的@ Sp3000 python解决方案相同。

FNrlQ1KONJ@QN XXQN@QKKJ)Q

感谢@Jakube的交换技巧

<implicit>    Q=input()
FNrlQ1        For N in len(Q) to 1, only goes len Q-1 because how range implemented in pyth
 KON          K = random int 0-N
 J@QN         J=Q[N]
 <space>      Suppress print
 XXQN@QKKJ    Swap K and J
)             End for
Q             Print Q
— 马尔蒂森
source
您可以通过合并这两个列表分配来节省两个字节：XXQN @ QKKJ而不是XQN @ QK XQKJ。
— 雅库布2015年
@Jakube感谢您的提示。我知道一定有一种方法可以交换列表中的值，这确实很聪明。您应该将其添加到提示列表中。
— Maltysen 2015年
4

Perl，68 56 44

像许多其他解决方案一样，它使用Fisher-Yates算法。

使用nutki的注释，通过使用$_代替$i并在数组索引中执行操作来保存12个字符。

44：

sub f{@_[$_,$j]=@_[$j=rand$_,--$_]for 1..@_}

56：

sub f{$i=@_;$j=int(rand$i),@_[$i,$j]=@_[$j,$i]while$i--}

这是我的第一个代码高尔夫。

— 盆景
source
不错的开始，我不知道您可以@_[...]像这样用作右值。可以进一步打高尔夫球sub f{@_[$_,$j]=@_[$j=rand$_,--$_]for 1..@_}。
— nutki'2
3

C，63 61 60字节

i,t;s(a,m)int*a;{for(;m;a[m]=t)t=a[i=rand()%m--],a[i]=a[m];}

Fischer-Yates的直接实现即可对给定数组进行排序。可以使用Visual Studio编译器（vs2013，尚未测试其他版本）和Intel编译器完美地进行编译和链接。漂亮的功能签名是s(int array[], int length)。我打败Python和Ruby给我留下了深刻的印象。

这确实假定srand()已被调用并且rand（）已正确实现，但是我相信该规则可以实现这一点：

You may assume that any built-in random number method runs in O(1) and is perfectly uniform over the requested interval

格式良好的版本：

index, temp;
shuffle(array, length) int* array;  {
    for(;length; array[index] = temp)
        index = rand() % length--,
        temp = array[length],
        array[length] = array[index];
}
— 117
source
我认为创建函数标头就足够了s(a,m)*a{，但是我不确定，也不想进行测试。您可能想要进行xor-swap，例如in中a[i]^=a[m]^=a[i]^=a[m]。这也避免了需要声明t。
— FUZxxl 2015年
@FUZxxl我相信xor交换会导致问题，如果i==m。
— Geobits'2
确实是@Geobits。我错过了这种可能性。
— 2015年
我只是想弄清楚为什么它不起作用...应该记住这一点。另外，我确实需要s(a,m)int*aVisual Studio和Intel编译器。没有安装gcc或clang进行测试，但是我想他们也会抱怨。
— pseudonym117
这是非常令人印象深刻的高尔夫球场。在尝试了许多不保存任何内容的修改之后，我确实设法找到了一种保存2个字符的方法。如果更改交换顺序以使第一个swap语句变为t=a[i]，则可以将其i=rand()%m--作为数组索引移入内部。
— 2015年
3

八度，88 77字节

function s=r(s)for(i=length(s):-1:1)t=s(x=randi(i));s(x)=s(i);s(i)=t;end;end

另一个Fisher-Yates的实现...如果我添加通常的换行符和间距，应该相当简单：

function s=r(s)
  for(i=length(s):-1:1) # Counting down from i to 1
    t=s(x=randi(i));    # randi is builtin number generator for an int from 0 to i
    s(x)=s(i);
    s(i)=t;
  end
end

不幸的是，“ end”关键字确实杀死了这里的高尔夫成绩。嘿，我可以用“ end”代替“ endfor”和“ endfunction”！

— dcsohl
source
1
仅供参考，在“字节”是不是真的由代码需要，它只是确保有是一个标题，其中包含逗号后面一个逗号（分隔的语言）和至少一个数字，然后就选择了最后没有划掉的数字。虽然那里有“字节”仍然很好。;）
— Martin Ender 2015年
1
您可以使用numel代替来节省1个字节lenght。作为奖励，您的程序也可以与二维数组又称为矩阵一起工作;）
— paul.oderso
2

Java 8、77

(x)->{for(int i=x.length,j,t;;t=x[j*=Math.random()],x[j]=x[i],x[i]=t)j=i--;};

这是一个lambda int[]，返回并返回void。我的第一次尝试似乎不太有趣，因此我决定通过引发异常将其退出。

测试程序：

interface shuff {
    void shuff(int[] x);
}
class Ideone
{
    public static void main (String[] args) throws java.lang.Exception
    {
        shuff s = (x)->{for(int i=x.length,j,t;;t=x[j*=Math.random()],x[j]=x[i],x[i]=t)j=i--;};
        int[] x = {3, 9, 2, 93, 32, 39, 4, 5, 5, 5, 6, 0};
        try {
            s.shuff(x);
        } catch(ArrayIndexOutOfBoundsException _) {}
        for(int a:x) System.out.println(a);
    }
}
— 费瑟姆
source
1
当您必须提供委托以便在任何地方使用lambda时，使用lambda来绕过不得不编写函数签名的做法是不是很欺骗？另外...您不能在圆括号中加上括号Math.random()吗？
— Rawling
1
@Rawling您可以在这个meta问题中投票。目前，有9票赞成lambdas，0票反对。是的，括号可以删除。
— feersum
呵呵，如果有一个meta帖子和一个到目前为止的共识，那就开除。（并且享受我的两分低的高尔夫成绩：p）
— Rawling
3
我认为，正常情况下函数异常停止是不公平的，是吗？
— 2015年
1
@Qwertiy对每个人...您认为这不公平，我认为这很棒。
— feersum'2
2

戈尔夫卢阿（37）

如何运行Golflua？

~@i=1,#X`r=M.r(i)X[i],X[r]=X[r],X[i]$

输入作为变量X中的表提供。表在适当位置随机排列。

用法示例：

> X={0,-45,8,11,2}
> ~@i=1,#X`r=M.r(i)X[i],X[r]=X[r],X[i]$
> w(T.u(X))
-45 0 8 11 2
— ni
source
2

R，79个字节

f=function(x){n=length(x);for(i in 1:n){j=sample(i:n,1);x[c(i,j)]=x[c(j,i)]};x}

这是Fisher-Yates随机播放的直接实现。R函数sample以相等的概率从给定的向量中抽取给定大小的简单随机样本。在这里，我们在每次迭代中从整数i...，绘制一个大小为1的随机样本n。如问题中所述，可以假定为O（1），因此在所有此实现中都应为O（N）。

— 亚历克斯·A
source
2

Matlab，67岁

还实施Fisher-Yates。

a=input('');n=numel(a);for i=1:n;k=randi(i);a([i,k])=a([k,i]);end;a

我以为我不能使用Matlab的randperm功能太糟糕了。但是经过一番摆弄之后，我想我可能会看一下它的来源，randperm看看它是如何完成的，我惊讶地发现只有一行：[~,p] = sort(rand(1,n))=）

— 瑕疵
source
2

Perl，44岁

sub f{($_[$x],$_)=($_,$_[$x=rand++$i])for@_}

另一个perl以44个字符表示。使用示例：

@x=(1..9);f(@x);print@x
— 坚果
source
2

Mathematica，82 90 83 93字节

注意：Fisher-Yates改组的这种变体实际上是MartinBüttner的解决方案，并通过alephalpha进行了一些代码解析。s是输入数组。没什么幻想的，但是有时候简单的事情是最难以捉摸的。

f@s_:=(a=s;m=Length@a;Do[t=a[[r=RandomInteger@{1,m-1}]];a[[r]]=a[[m]]; a[[m]]=t,{n,1,m-1}];a)
— 戴维
source
您可以Do在这里使用。比短While。
— alephalpha
2

Ruby，57个字节

->a{a.size.times{|i|j=rand(i+1);a[i],a[j]=a[j],a[i]};p a}

输入（作为lambda函数）：

f.([1,2,3,4,5])

输出：

[2, 1, 4, 3, 5]
— 零纤维
source
2

TI-BASIC，46个字节

For(X,dim(L1),2,-1:randInt(1,X→Y:L1(X→Z:L1(Y→L1(X:Z→L1(Y:L1

1   111   2  1111112       1111112 111112 1112 111112 1112

字节数来源

— p
source
1
您错过了End。
— lirtosiast
2

K，31个字符

f:{{l[i:x,1?x]:l@|i}'|!#l::x;l}

不像我之前提出的那样短（被取消资格）……哦，很好。

这是基本的Fisher-Yates随机播放。这是在Kona邮件列表的大量帮助下构建的。

— kirbyfan64sos
source
2

JavaScript（ES6），66

此功能可将数组随机排列。它还返回一个不是随机输出的副产品数组，因此不能考虑。

F=a=>a.map((v,i)=>a[a[i]=a[j=0|i+Math.random()*(a.length-i)],j]=v)
— edc65
source
2

MATL，16字节

XH`HnYr&)XHxvHHn

在线尝试！

MATL中的Fisher-Yates。该程序中几乎有三分之一专门用于letter H，它对应于MATL中的剪贴板功能。

基本上，H存储输入中未使用的项目，而堆栈则跟踪改组后的列表。

— 桑切斯
source
2

贾普特12岁

rÈiMqZÄ Y}[]

试试吧！

-10（大约一半;）感谢@Shaggy！

我一直想尝试一种高尔夫语言，而Japt解释器则提供了很好的文档以及一种在浏览器中进行尝试的方法。

以下是我采取的策略：

  • 使用空数组减少输入种子
  • 在每个步骤中，找到一个随机插槽以插入当前元素
— 达娜
source
1
欢迎来到Japt，很高兴与您在一起。我认为这使用相同的方法可以工作9个字节。但是，如果RNG效果不理想，请尝试使用此方法。
— 毛茸茸的
@Shaggy-感谢您的提示！:)我最终使用了第二种解决方案的略微修改版本。由于reduce函数的第三个参数是一个索引，因此我们已经知道长度。
— dana
1

Javascript ES6、69

a=>{m=a.length;while(m)[a[m],a[i]]=[a[i=~~(Math.random()*m--)],a[m]]}

是费舍尔·耶茨。

PS：可以在Firefox中进行测试

— Qwertiy
source
@MartinBüttner，将其删除了：)
— Qwertiy 2015年
1

哈斯克尔，170

import System.Random
import Data.Array.IO
s a=do(_,n)<-getBounds a;sequence$map(\i->do j<-randomRIO(i,n);p<-a%i;q<-a%j;writeArray a j p;return q)[1..n]where(%)=readArray

受算法启发的另一个Fisher-Yates解决方案位于https://wiki.haskell.org/Random_shuffle。

s 是具有签名的功能： IOArray Int a -> IO [a]

— 杰马克
source
1

果酱-30

q~_,,W%{_I=I)mr:J2$=@I@tJ@t}fI

在http://cjam.aditsu.net/上尝试

输入示例：[10 20 30 40 50]
输出示例：（在代码末尾3020401050添加a p进行漂亮的打印）

如果允许代码从堆栈中获取输入（如函数），则可以删除前2个字符，从而将大小减小到28。

说明：

由于缺少用于数组的“交换”运算符，因此代码比我希望的要长
（稍后将实现：p）

q~            read and evaluate the input (let's call the array "A")
_,,           make an array [0 1 2 ... N-1] where N is the size of A
W%            reverse the array, obtaining [N-1 ... 2 1 0]
{…}fI         for I in this array
    _I=       push A[I]
    I)mr:J    push a random number from 0 to I (inclusive) and store it in J
              stack: A, A[I], J
    2$=       get A[J]
    @I@t      set A[I] = A[J]
              stack: former A[I], A
    J@t       set A[J] = former A[I]
— di
source
如评论中所述，恐怕这是无效的。至少_是O（N）（在O（N）循环内部）。不幸的是，我在CJam中找不到解决此问题的方法。
— 马丁·恩德
列表的处理就像不可变的对象一样，因此复制只是实现为复制引用。实际上t是杀死它的原因，因为它无法更改列表，现在必须创建一个副本。
— 2015年
@MartinBüttner我正要发布与Runer112相同的东西；是的，可能存在问题t，我想在将来的版本中进行改进
— 。.– aditsu
因此，由于内部语言实现问题，此代码遵循问题的实质，而不遵循“字母”的实质。
— aditsu
1

JavaScript（ES 6），61

S=a=>(a.map((c,i)=>(a[i]=a[j=Math.random()*++i|0],a[j]=c)),a)

您可以在这里通过添加一行shuffle = S（仅限Firefox）进行测试。

— 核心1024
source
1

STATA，161

di _r(s)
set ob wordcount($s)
token $s
g a=0
foreach x in $s{
gl j=floor(runiform()*_n)+1
replace a=`$j' if word($s,_n)=`x'
replace a=`x' if word($s,_n)=`$j'
}
l

期望以空格分隔的数字形式输入。如果您愿意，我可以从输出中删除标题和观察号，但是这样会更短一些。

— 商标
source
这到底是_n什么
— Martin Ender
_n是当前观察值。
— bmark's
1

SQF，91字节

params["i"];{n=floor random count i;i set[_forEachIndex,i select n];i set[n,_x]}forEach i;i
— 巨大
source
1
这是偏置（见“交换（我< - >随机）”关于将它随机播放），但你可以通过替换使之成为费希尔-耶茨（这是偏）%x用%i。
— 马丁·恩德
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.