为解决数独太辛苦？甚至是蛮力版本？这是一个编码练习，要容易一些。我希望。:-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中。如果range [1..X]等于排序的索引顺序，则对列表进行排序，因此将其返回。
• ⋄∇⍵[X?X]：如果不是这种情况，请使用随机数组递归。

Ruby-33个字符

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

数学，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

由于即使很小的输入（例如N> 5）的堆栈溢出也会失败，因为Python不会进行尾部调用优化。

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 /重击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我们的List。首先，议程右侧的动词是-:/:~。这个动词由Leaky Nun慷慨地提供。-:是否/:~使用单子钩对输入进行排序（）匹配（）。（(f g) y = y f (g y)）相应地返回一或零。议程的左侧是两个动词的动名词：右侧是恒等动词]，而左侧是递归发生的地方。议程选择无论是在位置上的身份动词1如果列表被排序，动词较长的位置0，如果列表不排序。

$:@({~?~@#)$:在{~?~@#on 的结果上方调用（包含它的最长动词）y。这会随机排列索引为，对列表进行改编，并?~@#采用长度的排列y方式y。{~在单子钩子中，返回列表，y其索引为正确的arg。然后，此混编的列表将再次与议程一起调用，并重复进行直到分类。

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被交换了最后两个元素，依此类推，直到列表长度的阶乘（这是相反顺序的列表）。因此，对于一个已排序的列表，它的值为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()和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扩展），15字节

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

在线尝试！

Brachylog，5个字节

∈&ṣ≤₁

在线尝试！

当我第一次看到ais523的Brachylog答案（与他的Jelly答案相对，因为如果我没记错的话user62131也是他），我想知道它是否使用回溯而不是递归？所以起初，我尝试过ṣ≤₁。事实证明，由于随机选择某事物不会产生太多输出，而只是不确定地产生一个输出ṣ，因此不能将shuffle谓词回溯到原来的状态，因此除非您有幸将其正确洗掉，否则运行将失败第一次尝试。之后，我尝试了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}

在线尝试！

匿名代码块，将列表随机排序直到排序。请注意，它至少对列表排序一次，这是允许的。不，{.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个字符，无输入循环：仅函数）

#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]);}}

编译可能会发出警告（隐式声明）。Hardencoded数组的大小限制为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]);}}

（使用全局变量而不是函数args）。