挑战说明

序列的“排列”是一种排列，其中没有元素出现在其原始位置。例如，ECABD是的排列ABCDE，但CBEDA不是：

ABCDE
 | |   <- B and D are in their orignal positions
CBEDA

给定一个序列，生成它的随机排列。

笔记

• 您可以将字符串作为输入或元素（整数，字符，对象...）的数组/列表

• 无需返回新对象，而是可以通过交换其元素来修改现有对象

• 每次错序产生的可能性均等

• 您可以假设序列中有多个元素，并且没有一个以上元素出现

CJam，14个字节

q:X{mr_X.=:|}g

在线尝试！

不断改组输入，直到出现混乱为止。

说明

q:X   e# Read input and store it in X.
{     e# While the condition at the end of the loop is truthy...
  mr  e#   Shuffle the string.
  _X  e#   Duplicate it and push the input.
  .=  e#   Element-wise equality check.
  :|  e#   Reduce OR over the list, gives something truthy if any character
      e#   remained in its original position.
}g

果冻，6个字节

Ẋ=³S$¿

在线尝试！

说明

Ẋ    ¿    Shuffle the given list while this is nonzero for it:
    $       A two-step process:
 =³           Element-wise equality of it and L (the original list)...
   S          Sum the ones in this binary array.

乔纳森·艾伦（Jonathan Allan）保存了一个字节。

Python，85个字节

修改传递给它的列表（由meta和问题允许）。

from random import*
def D(l):
 o=l[:]
 while any(x==y for x,y in zip(o,l)):shuffle(l)

在这里在线尝试！

ES6（JavaScript）， 71，69字节

输入和输出是数组，应该与任何元素类型（字符串，数字等）一起使用，只要它们可以与“ ==”进行比较即可。

打高尔夫球

F=s=>(r=[...s]).sort(_=>Math.random()-.5).some((e,i)=>s[i]==e)?F(s):r

测试

F=s=>(r=[...s]).sort(_=>Math.random()-.5).some((e,i)=>s[i]==e)?F(s):r

F(['A','B','C','D'])
Array [ "D", "C", "A", "B" ]

F(['A','B','C','D'])
Array [ "D", "A", "B", "C" ]

F(['A','B','C','D'])
Array [ "C", "D", "B", "A" ]

F(['A','B','C','D'])
Array [ "D", "C", "B", "A" ]

F(['A','B','C','D'])
Array [ "C", "D", "B", "A" ]

互动片段

F=s=>(r=[...s]).sort(_=>Math.random()-.5).some((e,i)=>s[i]==e)?F(s):r

function G() {
    console.log(F(T.value.split``).join``); 
}

<input id=T value="ABCDEF"><button id=G onclick="G()">GENERATE</button>

Perl 6、33字节

{first (*Zne$_).all,.pick(*)xx *}

一个以整数或字符组成的列表作为输入并返回一个新列表的lambda。

如果必须支持任意值列表，则必须ne替换为!eqv（+2字节）。

（在线尝试。）

说明：

• { }：定义一个lambda。
• .pick(*)：生成输入列表的随机混洗。
• .pick(*) xx *：创建此类混洗的惰性无限序列。
• (* Zne $_).all：一个lambda，使用（负字符串相等）运算符压缩两个列表（其参数*和外部lambda的参数$_）ne，产生一个布尔值列表，然后创建一个all结点以将它们折叠为单个布尔值状态。
• first PREDICATE, SEQUENCE：从满足“失序”测试的无限排列序列中选取第一个元素。

Brachylog，19 18 15 13字节

@~.:?z:#da;?&

在线尝试！

说明

@~.                Output is a shuffle of the input
  .:?z             Zip the output with the input
      :#da         All couples of integers of the zip must be different
          ;      Or
           ?&      Call recursively this predicate with the same input

Perl 6、45字节

{(@^a,{[.pick(*)]}...{none @a Zeqv@$_})[*-1]}

{(@^a,{[.pick(*)]}...{!sum @a Zeqv@$_})[*-1]}

试试吧

输入是任何东西的数组。

展开：

{
  (

    @^a,          # declare parameter, and seed sequence generator

    {             # lambda with implicit parameter ｢$_｣
      [           # store into an array
        .pick(*)  # shuffle ｢$_｣
      ]
    }

    ...           # keep generating the sequence until

    {
      none        # none
      @a          # of the outer blocks input
      Z[eqv]      # is zip equivalent
      @$_         # with the current value being tested
    }

  )[ * - 1 ]      # return the last value
}

MATL，7个字节

这是我的Octave帖子的翻译（与此处的其他一些提交内容相似）。我昨天发布了我的第一条MATL帖子（CNR破解），所以我认为这不是最佳选择，但这是我到目前为止所取得的最好成绩。

老实说，我不确定t那里是否需要它，但这是我可以使用它的唯一方法。使用它可以比较用户输入（G）与随机排列进行比较。我想我可以比较没有它的两个，但是...？

无论如何，这里是这样：

`Z@tG=a

`          % Loop
 Z@        % Random permutation of input
   t       % Duplicating the stack
    G      % Paste from clipboard G (user input)
     =     % Comparing the random permutation with the input (retrieved from clipboard)
      a    % any(input == random permutation)
           % Implicit end and display

在线尝试！

实际上，13个字节

;;WX╚│♀=ΣWX)X

在线尝试！

说明：

;;WX╚│♀=ΣWX)X
;;             make two copies of input
  WX╚│♀=ΣW     while top of stack is truthy:
   X             discard top of stack
    ╚            shuffle array
     │           duplicate entire stack
      ♀=         compare corresponding elements in shuffled and original for equality
        Σ        sum (truthy if any elements are in the same position, else falsey)
          X)X  discard everything but the derangement

八度，56 55字节

x=input('');while any(x==(y=x(randperm(nnz(x)))));end,y

input('')因为这不是函数，所以我们必须使用。另外，由于我可以选择将输入作为字符串，所以可以使用技巧nnz(x)==numel(x)。

说明：

x=input('')            % Self-explanatory
while any(x==y)        % Loop until x==y has only 0s (i.e. no elements are equal)
y=x(randperm(nnz(x)))  % Continue to shuffle the indices and assign x(indices) to y
end                    % End loop
y                      % Display y

感谢Luis注意到输入可以是字符串，因此我可以使用nnz而不是numel保存两个字节。

MATL，13个字节

这是@LuisMendo和我的共同努力。与这里的许多其他答案相反，此答案是确定性的，因为它不会对随机排列进行采样，直到发生排列失调，而是生成所有排列并随机选择一个。

Y@tG-!Af1ZrY)

在线尝试！

说明

Y@tG-!Af1ZrY)
Y@             generate all permutatoins
  t            create a duplicate
   G-!A        find the (logical) indices of all valid derangements (where no character of the string is in the same position as the original string)
       f       convert logical to linear indices
        1Zr    choose one of those indices randomly
           Y)  get the derangement (from the ones we generated earlier) at this index

Pyth- 10 9个字节

当任何字符等于输入中其索引处的字符时，这会继续对输入进行改组。

.WsqVHQ.S

在这里在线尝试。

.W           Iterate while
 s           Sum, this is works as any() on a boolean list
  qV         Vectorized equality
   H         The lambda variable for the check step
   Q         The input
 .S          Shuffle
  (Z)        Lambda variable, implicit
 (Q)         Start .W with input, implicit

Mathematica，57个字节

#/.x_:>RandomChoice@Select[Permutations@x,FreeQ[#-x,0]&]&

未命名函数，将任何内容的列表作为输入并输出列表。在生成#输入的所有排列之后x，我们仅保留那些#-x元素方面的差异集不包含0; 然后我们从该集合中进行（均匀）随机选择。

PHP，85字节

for($a=$b=str_split($argv[1]);array_diff_assoc($a,$b)!=$a;)shuffle($b);echo join($b);

将string参数复制到两个数组中，将它们中的一个进行混洗，直到它们之间的差（还比较元素的索引）等于另一个。用运行-r。

R，59个字节

z=x=1:length(y<-scan(,""));while(any(x==z))z=sample(x);y[z]

将元素列表读取到STDIN，获取列表的长度，并开始从1到长度的采样范围，直到找到与顺序列表不共享任何位置的元素。然后打印该列表。

不可思议，32字节

f\@[/>#I zip#=[#0a\shuf#0]?f a?a

用法：

f\@[/>#I zip#=[#0a\shuf#0]?f a?a];f[1 2 3 4 5]

说明

更具可读性：

f\@[
  some #I zip #= [#0; a\ shuf #0]
    ? f a
    ? a
]

递归函数f。在f的输入列表和输入列表的随机版本之间进行逐元素比较。如果比较产生任何相等的值，则f在混洗的列表上调用。否则，我们仅返回经过改组的列表。

Ruby，67个字节

def f a
while (a.zip(o=a.shuffle).map{|x,y|x-y}.index 0);end
o
end

八度，54 53字节

@(a)((p=perms(a))(L=!any(p==a,2),:))(randi(sum(L)),:)

生成的所有排列 a并随机选择一个没有公共元素的行a。

注意：偶然与@flawr MATL答案相同！

Clojure，94 90 79字节

#(let[s(shuffle %)](if(not(some(fn[[x y]](= x y))(map vector % s)))s(recur %)))

通过将条件内部的约简更改为-4字节 and并内联done?。

通过将减少量转换为-11个字节 some。

哇！击败PHP。

蛮力法。列表无效时随机播放。考虑到这是一种蛮力方法，它无法防止重复尝试，因此可以很快完成愚蠢的操作。它在不到一秒钟的时间内发现了1000个元素长的列表中的1000个变数。

取消高尔夫：

(defn dearang [ls]
  (let [s (shuffle ls)
        bad? (some (fn [[x y]] (= x y))
                (map vector ls s))]
    (if (not bad?) s (recur ls))))

Clojure，56个字节

#(let[s(shuffle %)](if((set(map = % s))true)(recur %)s))

请注意，字符串不能混洗，必须通过 seq或vec。

本来我尝试过#(first(remove(fn[s]((set(map = % s))true))(iterate shuffle %)))但是recur方法确实比iterate。

魔术是(set(map = % s))返回一组false，一组true或一组true与false。这可以用作函数，如果包含true则答案为true，否则为falsy nil。=很高兴接受两个输入参数，而无需将其包装任何东西。

((set [false]) true)
nil

也许有一种更短的方法来检查任何值是否为真？

APL，11个字节。

在正确的参数中包含字符串：

⍵[⍋(⍴⍵)?⍴⍵]

说明

ρ⍵ 获取正确参数的长度（或形状）。

?返回(⍴⍵)这些数字的随机数组。

⍋ 返回它们的顺序，以确保没有重复。

⍵[..] 代表使用此索引的字符串的随机分类。