Is Sudoku çözme çok sert? Hatta kaba kuvvet sürümü? İşte biraz daha kolay bir kodlama alıştırması. Umuyorum. :-P

Bogosort'u uygulamak için en kısa işlevi yazın. Özel olarak, fonksiyonunuz:

• Girdi olarak bir dizi (veya dilinizin eşdeğeri) alın
• Öğelerinin sıralı sırada olup olmadığını kontrol edin; öyleyse diziyi döndür
• Değilse, elemanları karıştırın ve yeniden başlayın

En kısa giriş kazanır. Bağlanma durumunda, özel bir karşılaştırıcıyı (ve / veya sözde rasgele sayı üretecini) destekleyen bir işlev tercih edilir. Geriye kalan tüm bağlar, önceki başvuruyu destekleyerek çözülür.

Açıklamalar: Elbette, onları sipariş etmenin bir yolu olduğu sürece istediğiniz herhangi bir eleman türünü kullanabilirsiniz. Ayrıca, karıştırmanın tek tip olması gerekir; Bunların hiçbiri "Sadece hızlıca pes ettireceğim ve karıştırıyorum" işi. :-)

APL (Dyalog), 20

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

açıklama

⍵(sağ) argümanı
⍵≡⍵[⍋⍵]: Sıralamanın kendisine ⍵eşit olup olmadığını kontrol ⍵eder
:⍵: Evet ise, o zaman geri dönün ⍵
∇⍵[?⍨⍴⍵]: Başka, rastgele sırayla 1'den ⍴⍵(uzunluğa kadar ⍵) bir dizi oluşturun , ⍵buna göre yeniden sıralayın ⍵[...]ve işlevi ona uygulayın ( ∇)

Birdenbire bu sorunu tekrar gözden geçirin ve ...

APL (Dyalog), 19

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

Sadece çek dizisindeki bir diziyi sıralamayı düşünmek, onu anlamsızlaştırıyor (Bogosort'un anlamlı olduğunu söylememek), daha doğru bir uygulama olurdu ∧/2≤/⍵ve bu da char sayısını düşürür.

Perl 6: 23 karakter

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

APL (22)

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

Kullanımı:

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

Açıklama:

• ⍋⍵: Maddelerin indekslerini sıralı sırada ⍋30 10 20verir,2 1 3
• (⍳X←⍴⍵)≡⍋⍵:⍵Giriş listesinin uzunluğunu X olarak saklayın. Aralık [1..X], sıralanmış dizin sırasına eşitse, liste sıralanır, bu nedenle geri dönün.
• ⋄∇⍵[X?X]: durum böyle değilse, karıştırılmış diziyle yineleyin.

Ruby - 33 karakter

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

Mathematica , 40 37

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

Boşluk ile:

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

J - 34 27

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

Örneğin:

f 5 4 1 3 2
1 2 3 4 5

f 'hello'
ehllo

? {~ ~ @ # Parçası girişini karıştırır:

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

Python 61

Sıralar.

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]

Diğer python cevapları random.shuffle () işlevini kullanır. Python rasgele modülünün dokümantasyonu şunları belirtir:

Çok küçük len (x) için bile, x'in toplam permütasyon sayısının, rastgele sayı üreteçlerinin çoğundan daha büyük olduğunu unutmayın; bu, uzun bir sekansın permütasyonlarının çoğunun asla üretilemeyeceği anlamına gelir.

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 karakter)

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

Sayısal sırayı artırırken tam sayıları sıralar. Özyinelemeli çözümler gibi

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

Python kuyruk çağrısı optimizasyonu yapmadığından, küçük girişlerde bile yığın taşması nedeniyle başarısız olur (N> 5 deyin).

Özel karşılaştırıcı olmadan D: 59 Karakter

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

Daha okunaklı:

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

    return r;
}

Özel karşılaştırıcı ile D: 69 Karakter

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

Daha okunaklı:

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'da, derleyicinin kuyruk çağrısı optimizasyonu yapıp yapmadığını kontrol edebiliriz:

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

ve evet, yaptı. Ancak, 100 değerin kısa bir listesi için:

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

tamamlamak için yaklaşık 4 ay sürdü. ;)

C # (184 karakter)

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

Bunu C # ile yapmak pek hoş değil. Hem değer hem de referans türlerini desteklemek için jenerikleri desteklemelisiniz. Bir şeyin sıralanıp sıralanmadığını kontrol etmek için herhangi bir dizi karıştırma fonksiyonu ya da fonksiyonu yoktur.

Bunu daha iyi hale getirmek için herhangi bir ipucu olan var mı?

Yalnızca int (134 karakter) sıralayan Sürümü Düzenle:

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 karakter

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

Sadece .. eğlence için yapılmış.

Python - 61 karakter

Recursive

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

PowerShell , 85 82 56 55 52 bayt

^{Mazzy'nin önerileri sayesinde -26 bayt; AdmBorkBork sayesinde
-1 bayt -3mazzy
sayesinde bayt.}

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

Çevrimiçi deneyin!

PowerShell, bunları dizelere dönüştürerek ve karşılaştırarak nispeten ucuz bir dizi karşılaştırmasına sahiptir.

Javascript 291 karakter

min

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 dakika

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 bayt

Nispeten dümdüz ileri yaklaşım:

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

J, 22 bayt

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

Bu bir gündem kullanarak özyinelemeli, salak bir monad. İşte nasıl çalışıyor:

Let ybizim listesi olacak. Birincisi, gündemin sağındaki fiildir -:/:~. Bu nezaketle Leaky Nun tarafından sağlanan bir fiil . Monadik bir kanca kullanarak -:girişin sıralanıp sıralanmadığı ( /:~) ile eşleşir ( ) . ( (f g) y = y f (g y)) Buna göre bir veya sıfır döndürür. Gündemin sol tarafı iki fiilden oluşuyor: sağda kimlik fiili ], solda ise özyinelemenin gerçekleştiği yer. Gündemi seçer ya pozisyonunda fiil kimlik 1liste halinde olduğu pozisyonda uzun fiil sıralanır ve 0liste halinde değil sıralanmış.

$:@({~?~@#)çağrılar $:sonucu tepesinde (o bulunan en uzun fiil) {~?~@#üzerinde y. Bu, listedeki rasgele sıralanan endekslerin ?~@#uzunluğundaki değişimleri alır . , monadik bir kancada, dizinleri doğru arg olan listeyi döndürür . Bu karışık liste daha sonra tekrar gündemle birlikte çağrılır ve sıralanıncaya kadar tekrar eder.yy{~y

C ++ 14, 158 bayt

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

Jöle , 6 byte, dil sonlandırma tarihi mücadelesi

ẊŒ¿’$¿

Çevrimiçi deneyin!

açıklama

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

Œ¿bir listenin her permütasyonuna bir sayı atar; 1 sıralanır, 2 liste uzunluğunun faktörüne (tersi sıradaki listedir) kadar değiş tokuş edilen son iki elemana vb. Sahiptir. Bu nedenle, sıralı bir liste için, bu değer 1'dir ve ’bir süre döngü koşulunda bir Boole olarak kullanılabilen bir "sıralanmamış" test üretmek için kullanarak azaltabiliriz . $Durum bir grup olarak ayrıştırmak için neden olmaktır.

C ++, 166 bayt

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

Bu begin()ve sahip olan tüm STL kaplarında çalışmalıdır end().

Ungolfed:

#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 Genişletilmiş) , 15 bayt

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

Çevrimiçi deneyin!

Brachylog , 5 bayt

∈&ṣ≤₁

Çevrimiçi deneyin!

Ais523'ün Brachylog cevabını ilk gördüğümde (Jelly'in cevabının aksine, çünkü yanılmıyorsam, kullanıcı 62131 de oydu), merak ettim, peki ya özyinelik yerine geri izleme kullandıysa? İlk başta denedim ṣ≤₁. Tesadüfen bir şeyi seçmek rastgele olmayan bir çıktı ürettiği için çok fazla çıktı üretmediği için, karışık belirti ṣgeri alınamaz, bu nedenle doğru şekilde karıştırmak için yeterince şanslı olmadığınız sürece, sadece başarısız olacak ilk denemede. Ondan sonra, pṣ≤₁çoğu zaman işe yarayan denedim , ancak son derece uzun bir listenin son derece sayıda permütasyonu olduğundan, bazen rastgele olarak başarısız oldu. Uzunluk azaltma hedefini bıraktıktan sonra nihayet şunu buldum:

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

(Rastgeleliğin gösterilmesi)

Gerçekte biraz daha kısa olsa da G / Ç ile bazı özgürlükler alırsak ...

Brachylog , 4 bayt

⊆ṣ≤₁

Çevrimiçi deneyin!

Çıktının kullanışlı olması için, girişin herhangi bir yinelenen eleman içermemesi gerekir; çünkü girişi sıralamaya ek olarak, bu bogosort yordamı, rastgele sayıda yinelenen eleman ve sıfır ekler. (Varsayımsal olarak, herhangi bir şey ekleyebilir, ancak sadece bir şey yapmaz.) Normalde, doğru işleyişten çok uzak bir şeyden bahsetmekten zahmete girmezdim, ama zorluğun ruhunda olduğunu hissediyorum.

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

Perl 6 , 28 bayt

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

Çevrimiçi deneyin!

Sıralanana kadar listeyi karıştıran adsız kod bloğu. Listenin en az bir kez sıralanacağına dikkat edin. Ve hayır, {.pick(*)}değiştirilemez*.pick(*)

Pyth , 11 bayt

Wn=Q.SQSQ;Q

Bu oldukça mutlu, muhtemelen biraz daha golf olabilir

açıklama

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

Çevrimiçi deneyin!

Japt , 11 9 bayt

_eZñ}a@öx

Dene

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

≤₁|ṣ↰

Çevrimiçi deneyin!

İşlev sunumu. (TIO bağlantısı, bir işlevi otomatik olarak tam bir programa saracak bir komut satırı argümanı kullanır.)

açıklama

≤₁|ṣ↰
≤₁      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'un derlediği dil) kuyruk özyinelemelidir, bu nedenle bu işlev sıkı bir döngü halinde derlenir.

C (203 karakter, giriş döngüsü yok: yalnızca işlev)

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

Bu, stdin'den de dizi okuduğumuz ve sıralanmış diziyi yazdığımız aşağıdaki gibidir. Q işlevi değil tüm programı istediğinden beri ...

C (296 karakter)

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

Derleme, uyarı verebilir (örtük beyanlar). Hardencoded dizi boyutu 999 elementlerin sınırı. Kırılgan.

Dizinin sıralanıp sıralanmadığını kontrol etmeye gerek yoksa, 284'te yapılabilir.

C (251 karakter, 284 idi)

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

(fonksiyon argüleri yerine globals kullanarak).