Là giải Sudoku quá khó? Ngay cả phiên bản vũ phu ? Đây là một bài tập mã hóa dễ dàng hơn một chút. Tôi hi vọng. :-P

Viết hàm ngắn nhất để thực hiện bogosort. Cụ thể, chức năng của bạn nên:

• Lấy một mảng (hoặc tương đương với ngôn ngữ của bạn) làm đầu vào
• Kiểm tra nếu các yếu tố của nó được sắp xếp theo thứ tự; nếu vậy, trả về mảng
• Nếu không, trộn các phần tử và bắt đầu lại

Các mục ngắn nhất chiến thắng. Trong trường hợp hòa, một chức năng hỗ trợ bộ so sánh tùy chỉnh (và / hoặc trình tạo số giả ngẫu nhiên) được ưa thích. Bất kỳ mối quan hệ còn lại được giải quyết bằng cách ủng hộ trình trước đó.

Làm rõ: Bạn có thể sử dụng bất kỳ loại phần tử nào bạn muốn, miễn là có một số cách để đặt hàng chúng, tất nhiên. Ngoài ra, việc xáo trộn phải được thống nhất; không ai trong số này "tôi sẽ nhanh chóng chuyển nó và gọi nó là doanh nghiệp". :-)

APL (Dyalog), 20

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

Giải trình

⍵là đối số (phải)
⍵≡⍵[⍋⍵]: Kiểm tra nếu được ⍵sắp xếp bằng ⍵chính nó
:⍵: Nếu có, sau đó trả về ⍵
∇⍵[?⍨⍴⍵]: Khác, tạo một mảng từ 1 đến ⍴⍵(độ dài ⍵) theo thứ tự ngẫu nhiên, sắp xếp lại ⍵theo đó ( ⍵[...]) và áp dụng hàm cho nó ( ∇)

Đột nhiên xem xét lại vấn đề này và ...

APL (Dyalog), 19

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

Chỉ nghĩ về việc sắp xếp một mảng trong kiểm tra làm cho nó trở nên vô nghĩa (không nói rằng Bogosort có ý nghĩa), việc thực hiện chính xác hơn sẽ ∧/2≤/⍵xảy ra, và điều đó xảy ra để làm giảm số lượng char.

Perl 6: 23 ký tự

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

APL (22)

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

Sử dụng:

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

Giải trình:

• ⍋⍵: trả về các chỉ mục của các mục theo thứ tự được sắp xếp, do đó ⍋30 10 20cung cấp2 1 3
• (⍳X←⍴⍵)≡⍋⍵:⍵Lưu trữ độ dài của danh sách đầu vào trong X. Nếu phạm vi [1..X]bằng với thứ tự chỉ mục được sắp xếp, danh sách được sắp xếp, vì vậy hãy trả lại nó.
• ⋄∇⍵[X?X]: nếu đây không phải là trường hợp, lặp lại với mảng xáo trộn.

Ruby - 33 ký tự

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

Toán học , 40 37

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

Với khoảng trắng:

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

J - 34 27

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

ví dụ:

f 5 4 1 3 2
1 2 3 4 5

f 'hello'
ehllo

Phần {~? ~ @ # Xáo trộn đầu vào:

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

Con trăn 61

Sắp xếp tại chỗ.

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

Con trăn 94

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

Các câu trả lời python khác sử dụng Random.shuffle (). Các tài liệu của mô-đun ngẫu nhiên python nêu:

Lưu ý rằng đối với len (x) khá nhỏ, tổng số hoán vị của x lớn hơn khoảng thời gian của hầu hết các trình tạo số ngẫu nhiên; điều này ngụ ý rằng hầu hết các hoán vị của một chuỗi dài không bao giờ có thể được tạo ra.

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 ký tự)

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

Sắp xếp các số nguyên theo thứ tự số tăng dần. Lưu ý rằng các giải pháp đệ quy, như

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

sẽ thất bại do tràn ngăn xếp cho các đầu vào nhỏ (giả sử N> 5), vì Python không thực hiện tối ưu hóa cuộc gọi đuôi.

D không có bộ so sánh tùy chỉnh: 59 ký tự

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

Dễ đọc hơn:

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

    return r;
}

D với bộ so sánh tùy chỉnh: 69 ký tự

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

Dễ đọc hơn:

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)

Trong Scala, chúng ta có thể kiểm tra xem trình biên dịch có thực hiện tối ưu hóa cuộc gọi đuôi hay không:

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

và vâng, nó đã làm. Tuy nhiên, đối với Danh sách ngắn gồm 100 giá trị:

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

mất gần 4 tháng để hoàn thành. ;)

C # (184 ký tự)

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();}

Thật không hay khi làm điều này trong C #. Bạn phải hỗ trợ thuốc generic để hỗ trợ cả loại giá trị và loại tham chiếu. Không có chức năng xáo trộn mảng hoặc chức năng để kiểm tra nếu một cái gì đó được sắp xếp.

Có ai có bất cứ lời khuyên để làm cho điều này tốt hơn?

Chỉnh sửa phiên bản chỉ sắp xếp int (134 ký tự):

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 ký tự

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

Chỉ cần .. làm cho vui.

Python - 61 ký tự

Đệ quy

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

PowerShell , 85 82 56 55 52 byte

^{-26 byte nhờ vào các đề xuất của mazzy
-1 byte nhờ vào admBorkBork
-3 byte nhờ vào mazzy}

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

Hãy thử trực tuyến!

PowerShell có một so sánh mảng tương đối rẻ bằng cách chuyển chúng thành chuỗi và so sánh điều đó.

Javascript 29 ký tự

tối thiểu

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}

un-min

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 byte

Cách tiếp cận tương đối thẳng về phía trước:

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

J, 22 byte

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

Đây là một đơn vị đệ quy, ngầm sử dụng một chương trình nghị sự. Đây là cách nó hoạt động:

Hãy ylà danh sách của chúng tôi. Đầu tiên, động từ bên phải của chương trình nghị sự là -:/:~. Đây là một động từ được cung cấp bởi Leaky Nun . Nó phù hợp với ( -:) cho dù đầu vào được sắp xếp ( /:~) bằng cách sử dụng một móc đơn âm. ( (f g) y = y f (g y)) Điều này trả về một hoặc không tương ứng. Phía bên trái của chương trình nghị sự là một gerund gồm hai động từ: bên phải là động từ danh tính ]và bên trái là nơi diễn ra đệ quy. Chương trình nghị sự chọn động từ danh tính ở vị trí 1nếu danh sách được sắp xếp và động từ dài hơn ở vị trí 0nếu danh sách không được sắp xếp.

$:@({~?~@#)các cuộc gọi $:(động từ dài nhất được chứa trong) ở trên kết quả của {~?~@#ngày y. Điều này xáo trộn danh sách, như ?~@#lấy các hoán vị của độ dài y, là các chỉ số được sắp xếp ngẫu nhiên của y. {~, trong một hook đơn điệu, trả về một danh sách từ ycác chỉ số của chúng là đối số đúng. Danh sách được xáo trộn này sau đó được gọi lại với chương trình nghị sự và lặp lại cho đến khi nó được sắp xếp.

C ++ 14, 158 byte

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

Jelly , 6 byte, thách thức ngôn ngữ

ẊŒ¿’$¿

Hãy thử trực tuyến!

Giải trình

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

Œ¿gán một số cho mỗi hoán vị của danh sách; 1 được sắp xếp, 2 có hai phần tử cuối cùng được trao đổi, v.v., cho đến giai thừa của độ dài danh sách (là danh sách theo thứ tự ngược lại). Vì vậy, đối với một danh sách được sắp xếp, giá trị này có giá trị 1 và chúng ta có thể giảm nó bằng cách sử dụng ’để tạo ra một thử nghiệm "không được sắp xếp" có thể sử dụng như một Boolean trong điều kiện vòng lặp while. Các $là nguyên nhân gây ra tình trạng này để phân tích theo nhóm.

C ++, 166 byte

Meh.

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

Điều này sẽ làm việc trên tất cả các container STL có begin()và end().

Ung dung:

#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 mở rộng) , 15 byte

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

Hãy thử trực tuyến!

Brachylog , 5 byte

∈&ṣ≤₁

Hãy thử trực tuyến!

Khi tôi lần đầu tiên nhìn thấy câu trả lời Brachylog của ais523 (trái ngược với câu trả lời Jelly của anh ấy, bởi vì nếu tôi không nhầm người dùng62131 cũng là anh ấy), tôi tự hỏi, nếu nó sử dụng quay lui thay vì đệ quy thì sao? Vì vậy, lúc đầu, tôi đã cố gắng ṣ≤₁. Hóa ra, vì việc chọn một cái gì đó ngẫu nhiên không tạo ra nhiều kết quả đầu ra vì nó chỉ tạo ra một đầu ra không nhất định, nên vị từ xáo trộn ṣkhông thể quay lại được, do đó, việc chạy đó sẽ thất bại trừ khi bạn đủ may mắn để xáo trộn nó ngay trong lần thử đầu tiên. Sau đó, tôi đã cố gắng pṣ≤₁, hoạt động hầu hết thời gian, nhưng vì một danh sách dài có nhiều hoán vị, đôi khi nó vẫn thất bại một cách ngẫu nhiên. Sau khi từ bỏ mục tiêu giảm chiều dài, cuối cùng tôi đã nghĩ ra điều này:

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

(Trình diễn sự ngẫu nhiên)

Mặc dù nó thực sự có thể ngắn hơn một chút nếu chúng ta có một số quyền tự do với I / O ...

Brachylog , 4 byte

⊆ṣ≤₁

Hãy thử trực tuyến!

Để đầu ra có ích, đầu vào không được chứa bất kỳ phần tử trùng lặp nào, vì ngoài việc sắp xếp đầu vào, vị từ bogosort này thêm vào một số phần tử và số 0 trùng lặp ngẫu nhiên. (Theo giả thuyết, nó có thể thêm vào bất cứ thứ gì, nhưng nó chỉ là loại không.) Thông thường tôi sẽ không bận tâm đến việc đề cập đến thứ gì đó không hoạt động chính xác, nhưng tôi cảm thấy đó là tinh thần của thách thức.

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

Perl 6 , 28 byte

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

Hãy thử trực tuyến!

Khối mã ẩn danh xáo trộn danh sách cho đến khi nó được sắp xếp. Lưu ý rằng nó sắp xếp danh sách ít nhất một lần, được phép. Và không, {.pick(*)}không thể thay thế bằng*.pick(*)

Bình thường , 11 byte

Wn=Q.SQSQ;Q

Khá hài lòng với điều này, có lẽ có thể chơi golf nhiều hơn một chút

Giải trình

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

Hãy thử trực tuyến!

Japt , 11 9 byte

_eZñ}a@öx

Thử nó

_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 byte

≤₁|ṣ↰

Hãy thử trực tuyến!

Chức năng trình. (Liên kết TIO sử dụng đối số dòng lệnh tự động bao bọc một chức năng thành một chương trình đầy đủ.)

Giải trình

≤₁|ṣ↰
≤₁      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 (ngôn ngữ mà Brachylog biên dịch thành) là đệ quy đuôi, do đó, chức năng này cuối cùng được biên dịch thành một vòng lặp chặt chẽ.

C (203 ký tự, không có vòng lặp đầu vào: chỉ có chức năng)

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

Điều này giống như sau, trong đó chúng ta cũng đọc mảng từ stdin và viết ra mảng đã sắp xếp. Vì Q yêu cầu chức năng chứ không phải toàn bộ chương trình ...

C (296 ký tự)

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

Biên dịch có thể đưa ra cảnh báo (khai báo ngầm). Giới hạn kích thước mảng được mã hóa cứng của 999 phần tử. Mong manh.

nếu không cần kiểm tra trước nếu mảng được sắp xếp, nó có thể được thực hiện trong 284.

C (251 ký tự, là 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]);}}

(sử dụng toàn cầu thay vì hàm args).