数独を解くのは難しいですか？でも、ブルートフォースバージョン？これは少し簡単なコーディング演習です。私は願います。:-P

bogosortを実装する最短の関数を作成します。具体的には、関数は次のことを行う必要があります。

• 入力として配列（またはあなたの言語の同等物）を取る
• 要素が並べ替えられているかどうかを確認します。もしそうなら、配列を返します
• そうでない場合は、要素をシャッフルし、再度開始します

最短のエントリーが勝ちです。同点の場合、カスタムコンパレータ（および/または擬似乱数ジェネレータ）をサポートする関数が優先されます。残りの関係は、以前の提出を支持することによって解決されます。

明確化：もちろん、それらを注文する方法がある限り、任意の要素タイプを使用できます。また、シャッフルは均一でなければなりません。この「私はそれをクイックソートしてシャッフルしたと呼ぶ」ビジネスはありません。:-)

APL（Dyalog）、20

{⍵≡⍵[⍋⍵]:⍵⋄∇⍵[?⍨⍴⍵]}

説明

⍵（右）引数
⍵≡⍵[⍋⍵]：⍵ソートが⍵それ自体に等しいかどうかをチェックします：
:⍵はいの場合、次に戻り⍵
∇⍵[?⍨⍴⍵]ます：そうでない場合、1から⍴⍵（長さ⍵）の配列をランダムな順序で生成し、⍵その順序に従って並べ替え（⍵[...]）、それに関数を適用します（∇）

突然この問題を再検討し...

APL（Dyalog）、19

{∧/2≤/⍵:⍵⋄∇⍵[?⍨⍴⍵]}

チェックで配列をソートすることを考えただけで、それは無意味になります（Bogosortに意味があると言っているわけではありません）、より正確な実装はであり∧/2≤/⍵、それは文字数を減らすために起こります。

Perl 6：23文字

@s.=pick(*)until[<=] @s

APL（22）

{(⍳X←⍴⍵)≡⍋⍵:⍵⋄∇⍵[X?X]}

使用法：

    {(⍳X←⍴⍵)≡⍋⍵:⍵⋄∇⍵[X?X]} 3 2 1
1 2 3

説明：

• ⍋⍵：アイテムのインデックスをソート順に返します。したがって⍋30 10 20、2 1 3
• (⍳X←⍴⍵)≡⍋⍵:⍵入力リストの長さをXに格納します。範囲[1..X]がソートされたインデックスの順序と等しい場合、リストはソートされるため、それを返します。
• ⋄∇⍵[X?X]：これが当てはまらない場合は、配列をシャッフルして再帰します。

ルビー-33文字

g=->l{l.shuffle!!=l.sort ?redo:l}

Mathematica、40 37

NestWhile[RandomSample,#,Sort@#!=#&]&

空白あり：

NestWhile[RandomSample, #, Sort@# != # &] &

J- 34 27

f=:({~?~@#)^:(1-(-:/:~))^:_

例えば：

f 5 4 1 3 2
1 2 3 4 5

f 'hello'
ehllo

？{~~ @＃の部分は、入力をシャッフル：

({~ ?~@#) 1 9 8 4
4 8 9 1
({~ ?~@#) 'abcd'
bdca

Python 61

所定の位置に並べ替えます。

import random
def f(l):
 while l!=sorted(l):random.shuffle(l)

Python 94

from itertools import*
def f(a):return [x for x in permutations(a) if x==tuple(sorted(a))][0]

他のPythonの回答ではrandom.shuffle（）を使用します。python randomモジュールの状態のドキュメント：

かなり小さいlen（x）の場合でも、xの順列の総数は、ほとんどの乱数ジェネレーターの周期よりも大きいことに注意してください。これは、長いシーケンスのほとんどの順列を生成できないことを意味します。

K、31 25

{while[~x~x@<x;x:x@(-#x)?#x];x}

{x@(-#x)?#x}/[{~x~x@<x};]

。

k){x@(-#x)?#x}/[{~x~x@<x};] 3 9 5 6 7 9 1
`s#1 3 5 6 7 9 9

。

k){x@(-#x)?#x}/[{~x~x@<x};] "ascsasd"
`s#"aacdsss"

Python（69文字）

from random import*
def f(a):
 while a>sorted(a):shuffle(a)
 return a

整数を昇順でソートします。次のような再帰的なソリューションに注意してください

from random import*;f=lambda a:a>sorted(a)and(shuffle(a)or f(a))or a

Pythonは末尾呼び出しの最適化を行わないため、小さな入力（N> 5など）でもスタックオーバーフローが原因で失敗します。

カスタムコンパレータなしのD：59文字

R f(R)(R r){while(!isSorted(r))r.randomShuffle();return r;}

より読みやすく：

R f(R)(R r)
{
    while(!r.isSorted)
        r.randomShuffle();

    return r;
}

カスタムコンパレータを使用したD：69文字

R f(alias p,R)(R r){while(!isSorted!p(r))r.randomShuffle();return r;}

より読みやすく：

R f(alias p, R)(R r)
{
    while(!isSorted!p(r))
        r.randomShuffle();

    return r;
}

Scala 73：

def s(l:Seq[Int]):Seq[Int]=if(l==l.sorted)l else s(util.Random.shuffle l)

Scalaでは、コンパイラーが末尾呼び出しの最適化を行ったかどうかを確認できます。

@annotation.tailrec
def s(l:Seq[Int]):Seq[Int]=if(l==l.sorted)l else s(util.Random shuffle l)

はい、そうでした。ただし、100個の値の短いリストの場合：

val rList = (1 to 100).map(x=>r.nextInt (500))
s(rList) 

完了するにはほぼ4か月かかりました。;）

C＃（184文字）

T[]S<T>(T[]i)where T:IComparable<T>{T l=default(T);while(!i.All(e=>{var r=e.CompareTo(l)>=0;l=e;return r;})){i=i.OrderBy(a=>Guid.NewGuid()).ToArray();l=default(T);}return i.ToArray();}

C＃でこれを行うのはあまり良くありません。値型と参照型の両方をサポートするには、ジェネリックをサポートする必要があります。配列シャッフル関数または何かがソートされているかどうかをチェックする関数はありません。

これを改善するためのヒントはありますか？

int（134文字）のみをソートするバージョンの編集：

int[]S(int[]i){var l=0;while(!i.All(e=>{var r=e>=l;l=e;return r;})){i=i.OrderBy(a=>Guid.NewGuid()).ToArray();l=0;}return i.ToArray();}

GNU / BASH 65

b(){ IFS=$'\n';echo "$*"|sort -C&&echo "$*"||b $(shuf -e "$@");}

C ++ 11、150文字

#include<deque>
#include<algorithm>
void B(std::deque &A){while(!std::is_sorted(A.begin(),A.end())std::random_shuffle(myvector.begin(),myvector.end());}

ただ..楽しみのために作られました。

Python-61文字

再帰的

from random import*;f=lambda l:l==sorted(l)or shuffle(l)>f(l)

PowerShell、85 82 56 55 52バイト

^{-26バイト、mazzyの提案に
感謝-1バイト、AdmBorkBorkに
感謝-3バイト、mazzyに感謝}

for($l=$args;"$l"-ne($l|sort)){$l=$l|sort{random}}$l

オンラインでお試しください！

PowerShellには、文字列にキャストして比較することで、比較的安価な配列比較があります。

Javascript 291文字

分

function f(e){var t=[].concat(e).sort();t.e=function(e){var n=true;t.forEach(function(t,r){if(t!=e[r])n=false});return n};while(!t.e(e.sort(function(){return Math.floor(Math.random()*2)?1:-1}))){console.log(e)}return e}

ウンミン

function f(a) {
var b = [].concat(a).sort();
b.e = function (z) {
    var l = true;
    b.forEach(function (v, i) {
        if (v != z[i]) l = false;
    });
    return l
};
while (!b.e(a.sort(function () {
    return Math.floor(Math.random() * 2) ? 1 : -1;
}))) {
    console.log(a);
}
return a;
}

Matlab、59バイト

比較的単純なアプローチ：

x=input('');while~issorted(x);x=x(randperm(numel(x)));end;x

J、22バイト

$:@({~?~@#)`]@.(-:/:~)

これは、アジェンダを使用した再帰的で暗黙のモナドです。仕組みは次のとおりです。

yリストにしましょう。まず、議題の右側の動詞は-:/:~です。これはLeaky Nunによって丁寧に提供された動詞です。-:入力が/:~モナドフックを使用してソートされているかどうか（）に一致します（）。（(f g) y = y f (g y)）これにより、1または0が返されます。議題の左側は2つの動詞の動詞です。右側はアイデンティティ動詞]、左側は再帰が行われる場所です。アジェンダは1、リストがソートされている場合は位置のアイデンティティ動詞を選択し、リストがソートされていない0場合は位置の長い動詞を選択します。

$:@({~?~@#)on $:の結果に{~?~@#加えて（含まれる最長の動詞）を呼び出しますy。これはリストをシャッフルします。これ?~@#は、の長さの順列を取り、のyインデックスをランダムにソートしたものですy。{~、モナドフックでは、yインデックスが正しい引数であるリストを返します。このシャッフルされたリストはアジェンダで再度呼び出され、ソートされるまで繰り返されます。

C ++ 14、158バイト

#include <algorithm>
#include <random>
[](int*a,int s){std::random_device r;for(std::knuth_b g(r());!std::is_sorted(a,a+s);std::shuffle(a,a+s,g));return a;};

ゼリー、6バイト、言語のポストデートチャレンジ

ẊŒ¿’$¿

オンラインでお試しください！

説明

ẊŒ¿’$¿
     ¿  While
 Œ¿’$     the input is not in its earliest possible permutation (i.e. sorted)
Ẋ       shuffle it

Œ¿リストの各順列に番号を割り当てます。1はソートされ、2は最後の2つの要素が交換されます。リストの長さの階乗（逆順のリスト）まで。したがって、ソートされたリストの場合、これは値1を持ち、’whileループ条件でブール値として使用できる「ソートされていない」テストを生成するために、値をデクリメントできます。これ$は、条件をグループとして解析することです。

C ++、166バイト

えー

#import<algorithm>
#import<random>
#define r b.begin(),b.end()
template<class v>
v f(v b){auto a=std::mt19937();while(!std::is_sorted(r))std::shuffle(r,a);return b;}

これはbegin()、とを持つすべてのSTLコンテナで機能するはずend()です。

ゴルフをしていない：

#include <algorithm>
#include <random>
template <class v>
v f(v b) {
    auto a = std::mt19937();
    while (!std::is_sorted(b.begin(),b.end()))
        std::shuffle(b.begin(),b.end(),a);

    return b;
}

APL（Dyalog Extended）、15バイト

(?⍨∘≢⊇⊢)⍣{⍺≡∧⍺}

オンラインでお試しください！

Brachylog、5バイト

∈&ṣ≤₁

オンラインでお試しください！

私が最初にais523のBrachylogの答えを見たとき（彼のジェリーの答えとは対照的に、ユーザー62131も間違っていなかったので）だから、最初はを試しましたṣ≤₁。ランダムに何かを選択しても、1つの出力が非決定的に生成されるだけなので、複数の出力は生成されないため、シャッフル述語ṣをバックトラックすることはできません。最初の試行で。その後、私pṣ≤₁はほとんどの場合うまくいきましたが、有限の長いリストには有限の多くの順列があるため、時々ランダムに失敗しました。長さの短縮を達成するという目標を放棄した後、私は最終的にこれを思いつきました：

         The input
∈        is an element of
         an unused implicit variable,
 &       and the input
  ṣ      shuffled randomly
   ≤₁    which is increasing
         is the output.

（ランダム性の実証）

I / Oにある程度の自由を与えれば、実際には少し短くなる可能性があります...

Brachylog、4バイト

⊆ṣ≤₁

オンラインでお試しください！

出力を有効にするには、入力の並べ替えに加えて、このbogosort述語がランダムな数の重複要素とゼロを追加するため、入力に重複要素が含まれていてはなりません。（仮に、それは何かを追加することができますが、それは何もしません。）通常、私はこれまで正しく機能することから遠く離れた何かに言及することはありませんが、それは挑戦の精神にあると感じます。

⊆        An ordered superset of the input
 ṣ       shuffled randomly
  ≤₁     which is increasing
         is the output.

Perl 6、28バイト

{({.pick(*)}...~.sort).tail}

オンラインでお試しください！

ソートされるまでリストをシャッフルする匿名コードブロック。リストを少なくとも1回ソートすることに注意してください。これは許可されています。そして、いいえ、{.pick(*)}に置き換えることはできません*.pick(*)

Pyth、11バイト

Wn=Q.SQSQ;Q

これにかなり満足して、おそらくもう少しゴルフすることができます

説明

Wn=Q.SQSQ;Q
W    While
  =Q.SQ    Variable Q (input variable) shuffled 
 n  Does not equal
       SQ    Variable Q sorted
             ;  Do nothing (loop ends)
              Q    And output variable Q

オンラインでお試しください！

Japt、11 9 バイト

_eZñ}a@öx

それを試してみてください

_eZñ}a@öx     :Implicit input of array U
_             :Function taking an array as argument via parameter Z
 e            :  Test Z for equality with
  Zñ          :  Z sorted
    }         :End function
     a        :Repeat and return the first result that returns true
      @       :Run this function each time and pass the result to the first function
       öx     :  Random permutation of U

Brachylog（v2）、5バイト

≤₁|ṣ↰

オンラインでお試しください！

関数の提出。（TIOリンクは、関数を完全なプログラムに自動的にラップするコマンドライン引数を使用します。）

説明

≤₁|ṣ↰
≤₁      Assert that {the input} is (nonstrictly) sorted in ascending order
  |     Output it
  |     Exception handler: if an assertion fails:
   ṣ      Randomly shuffle {the input}
    ↰     and run this function recursively on it, {outputting its output}

Prolog（Brachylogがコンパイルする言語）は末尾再帰であるため、この関数は最終的にタイトループにコンパイルされます。

C（203文字、入力ループなし：funcのみ）

#include <stdio.h>
#define P (int*a,int n){
#define F for(i=0;i<n;i++){
int i,j,v;s P F if(a[i]>a[i+1])return 0;}return 1;}void h P F v=a[i];a[i]=a[j=rand()%n];a[j]=v;}}void b P while(!s(a,n-1))h(a,n);}

これは次と同じです。ここでは、stdinから配列を読み取り、ソートされた配列を書き出します。Qはプログラム全体ではなく機能を要求したので...

C（296文字）

#include <stdio.h>
#define P (int*a,int n){
#define F for(i=0;i<n;i++){
int i,j,n,v,x[999];s P F if(a[i]>a[i+1])return 0;}return 1;}void h P F j=rand()%n;v=a[i];a[i]=a[j];a[j]=v;}}void b P while(!s(a,n-1))h(a,n);}main(){while(scanf("%d",&v)==1)x[n++]=v;if(!s(x,n))b(x,n);F printf("%d\n",x[i]);}}

コンパイルにより警告が発生する場合があります（暗黙の宣言）。999要素のハードエンコードされた配列サイズ制限。壊れやすい。

配列が並べ替えられているかどうかを事前に確認する必要がない場合は、284で行うことができます。

C（251文字、284でした）

#include <stdio.h>
#define F for(i=0;i<n;i++){
int i,j,n,v,a[999];s(int n){F if(a[i]>a[i+1])return 0;}return 1;}void h(){F v=a[i];a[i]=a[j=rand()%n];a[j]=v;}}void b(){while(!s(n-1))h();}main(){while(scanf("%d",&a[n++])>0);b();F printf("%d\n",a[i]);}}

（関数引数の代わりにグローバルを使用）。