チャレンジの説明

シーケンスの「混乱」とは、元の位置に要素が現れない順列です。たとえば、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.

ジョナサンアランはバイトを節約しました。

Python、85バイト

渡されたリストを変更します（メタおよび質問で許可されます）。

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 *}

入力として整数または文字のリストを受け取り、新しいリストを返すラムダ。

任意の値のリストをサポートする必要がある場合neは、!eqv（+ 2バイト）に置き換える必要があります。

（オンラインで試してください。）

説明：

• { }：ラムダを定義します。
• .pick(*)：入力リストのランダムシャッフルを生成します。
• .pick(*) xx *：このようなシャッフルのレイジー無限シーケンスを作成します。
• (* Zne $_).all：2つのリスト（その引数*、および外側のラムダの引数$_）を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）とランダム順列を比較できるようにするために使用されます。私はそれなしで2つを比較できると思いますが、...？

とにかく、ここに行きます：

`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に感謝します。したがって、2バイトnnzをnumel節約する代わりに使用できます。

MATL、13バイト

これは@LuisMendoと私が共同で行った取り組みです。ここでの他の多くの答えとは対照的に、これは混乱を得るまでランダムな順列をサンプリングしないという意味で決定論的ですが、すべての混乱を生成し、ランダムに1つを選択します。

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にaが含まれていない順列のみを保持し0ます。次に、そのセットから（均一に）ランダムな選択を行います。

PHP、85バイト

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

文字列引数を2つの配列にコピーし、それらの差（要素のインデックスも比較）が他の配列と等しくなるまで、配列の1つをシャッフルします。で実行し-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シャッフルされたリストで呼び出されます。それ以外の場合、単純にシャッフルされたリストを返します。

ルビー、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 %)))

縮小内の条件をに変更し、andインライン化することにより、-4バイトdone?ます。

-11バイトsome。縮小をに変換します。

うわー！PHPを破りました。

ブルートフォース法。無効なリストをシャッフルします。これは、重複試行を防ぐために何もしないブルートフォースメソッドであることを考慮して、愚かなことをすばやく終了します。1000要素の長いリストの1000個の障害が1秒未満で見つかりました。

ゴルフをしていない：

(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です。=2つの入力引数を使用して、何かでラップする必要はありません。

((set [false]) true)
nil

たぶん、値のいずれかが真であるかどうかを確認するより短い方法がありますか？

APL、11バイト。

正しい引数に文字列がある場合：

⍵[⍋(⍴⍵)?⍴⍵]

説明

ρ⍵ 正しい引数の長さ（または形状）を取得します。

?(⍴⍵)これらの数値のランダム配列を返します。

⍋ 重複しないようにするために、それらの順序を返します。

⍵[..] このインデックスを使用した文字列のランダムな品揃えを表します。