Girişiniz mutlaka benzersiz değil bir liste / dizi / vektör / 5-255 pozitif tamsayı dizisidir. Hangi girdi formatının en uygun olduğunu ve her bir tamsayı (ve tamsayıların miktarının) 5-255 aralığından rasgele seçildiği varsayılabilir.

Amaç, aynı listeyi aynı (veya eşdeğer) biçimde, ancak artan (azalan) düzende sıralamaktır. Dil öğrenmede yaygın bir erken alıştırma. Eklenecek gönderiler:

1. Doğru çalışan ve hedefe ulaşan bir cevap; ve

2. Can sıkıcı bir hata içeren ikinci bir cevap. Zamanın% 1 ila% 10'u arasında, çıktının doğru formatta ve doğru elemanları içeren, ancak yanlış sırada (doğru şekilde sıralananlar hariç herhangi bir sıra) bir liste olması gerekir . Zamanın geri kalanı, programın düzgün çalışması ve amacına ulaşması gerekir.

İki cevap Levenshtein mesafesine bir olmalıdır ; yani, bir bayt'ı silerek, bir bayt ekleyerek veya bir bayt değiştirerek birini diğerinden alabiliriz.

Her zaman olduğu gibi kod golfünde puanlama (iki cevabınızın kısaltmasına dayanarak), her zamanki boşluklar yasaklanmıştır.

Can sıkıcı hata girdiden bağımsız ise% 10 bonus (puana düşme), yani aynı girişi tekrar kullanmak hatayı yeniden üretmez (zamanın% 1 ila% 10'u hariç).

Python 3 , 36 bayt

Sorunsuz versiyon, 37 bayt

lambda l:sorted(l,reverse=l[-9:]==[])

Çevrimiçi deneyin!

Can sıkıcı sürüm, 36 bayt

lambda l:sorted(l,reverse=l[9:]==[])

Çevrimiçi deneyin!

Bu girişe bağlıdır ve bu nedenle bonus için uygun değildir.
Başarısızlık olasılığı% 2 civarındadır. Giriş uzunluğu 10'dan düşük olduğunda başarısız olur.

LyricLy'nin cevabı ile birleştirildiğinde, bu 34 bayt alır:

lambda l:sorted(l)[::l[9:]>[]or 1]
lambda l:sorted(l)[::l[9:]>[]or-1]

05AB1E , 5 * 0.9 = 4.5 bayt

Çalışma çözümü

{TLΩi

Çevrimiçi deneyin!

açıklama

{      # sort input
 TL    # push the range [1 ... 10]
   Ω   # pick a random number in the range
    i  # if true (equal to 1), do nothing

Hatayı içeren çözüm

Yanlış çözelti, zamanın% 10'unu verir (girişte bağımsız).

{TLΩiR

Çevrimiçi deneyin!

açıklama

Çalışılan çözümle aynıdır, ancak seçilen sayı doğru ise listeyi tersine çevirir.

Jöle , 7 * (% 100 -% 10) = 6,3 bayt

Ṣ¹⁵X:¤¡

Çevrimiçi deneyin!

Buggy versiyonu:

ṢẊ⁵X:¤¡

Çevrimiçi deneyin!

Her iki bağlantıda da, kodu her defasında verdiğiniz listeyle birlikte her seferinde 100 kez çalıştıracak ve sonra sonuçları döndürecek bir test kablo demeti vardır.

Her giriş uzunluğunun olasılığı:

0.1 - 0.1/(length!)

Yani uzunluk 1 için% 0 olasılık, uzunluk 2% 5, uzunluk 3% 8.83 8., uzunluk 4% 9.583̅, vs.

Python 3, skor 58 57 -% 10 = 51.3

Ovs sayesinde bir bayt kaydedildi.

Sorunsuz versiyon, 57 bayt

lambda m:sorted(m)[::random()>.1or 1]
from random import*

Çevrimiçi deneyin!

Bugged sürümü, 57 bayt

lambda m:sorted(m)[::random()>.1or-1]
from random import*

Çevrimiçi deneyin!

Bonusu kullanan bir çözümü denemeye karar verdim. Diğer Python cevabını geçmedi, ama düşünerek eğlendim.

C, 71 * 0.9 = 63.9 bayt

Hata içermeyen:

c(int*a,int*b){return*a-*b;}f(a,n)int*a;{if(rand()%1<9)qsort(a,n,4,c);}

Çevrimiçi deneyin!

Buggy:

c(int*a,int*b){return*a-*b;}f(a,n)int*a;{if(rand()%10<9)qsort(a,n,4,c);}

Çevrimiçi deneyin!

Groovy , 31 bayt

Bugged çözüm:

{a->a.sort()[a[9]?0..-1:-1..0]}

Çalışma çözümü:

{a->a.sort()[a[0]?0..-1:-1..0]}

Groovy abone operatörü ( getAtyöntem), dizin boyutundan büyükse listeler için null değerini döndürür. Yani dokuzuncu bir öğe varsa, sıralanan listeyle aynı kalır, ancak değilse (% 1.99203187 şansı) tersine çevrilir. Bununla birlikte, her zaman bir birinci öğe olacaktır, çünkü listenin boyutu her zaman 5'ten büyük veya ona eşittir a[0].

Wolfram Dili (Mathematica) , 29 bayt

Bu bonus ile 26.1 bayttır, ancak bonusu kazandığımdan emin değilim; önceden sıralanmış girişlerde, her iki sürüm de daima sıralanmış çıkış üretir.

Sorunsuz versiyon (29 bytes)

If[RandomReal[]<0.,#,Sort@#]&

Çevrimiçi deneyin!

Can sıkıcı sürüm (30 bayt)

If[RandomReal[]<0.1,#,Sort@#]&

Çevrimiçi deneyin!

PHP, 70 bayt

Sorunsuz versiyon, 70 bayt

<?unset($argv[0]);((rand(1,9)?"":r).sort)($argv);echo join(" ",$argv);

Çevrimiçi deneyin!

Bugged sürüm, 70 bayt

<?unset($argv[0]);((rand(0,9)?"":r).sort)($argv);echo join(" ",$argv);

Çevrimiçi deneyin!

Hatalı sürüm, zamanın% 10'unu ters sırada sıralar (rastgele sayı üreticisine göre).

Python 2 , 26 bayt

Buggy:

lambda l:l[9:]and l.sort()

Çevrimiçi deneyin!

Giriş listesini değiştirerek çıktılar . Listeyi yalnızca uzunluğu en az 10 ise sıralar. Buggy olmayan sürüm 9, a ' 0yı her zaman sıralayacak şekilde değiştirir.

Çalışma:

lambda l:l[0:]and l.sort()

Çevrimiçi deneyin!

Listeyi, toplam 30 bayt olmak üzere 4 bayt pahasına döndürmek için işlevi değiştirebiliriz:

lambda l:l[9:]and l.sort()or l

Çevrimiçi deneyin!

Bazı kuralların genişletilmesiyle 25 bayt:

[list,sorted][id(0)%17>0]

Çevrimiçi deneyin!

id(0)Rastgele bir kaynak olarak kullanan, kimliği sıralayan ya da kılan bir fonksiyon değişkeni . Değişim >için >=düzeltme, ya 0hiç ~0.

Kabuğu , 6 bayt

Buggy versiyonu:

?OIV¦9

Çevrimiçi deneyin!

Doğru versiyonu:

?OIVK9

Çevrimiçi deneyin!

açıklama

Bu programlar tamamen belirleyicidir. Aslında, şu anda Husk'un rasgele sayılar için hiçbir desteği yoktur.

?  V    If any element
    ¦9  is divisible by 9 (in buggy version),
    K9  is truthy when replaced by 9 (in correct version),
 O      sort the list,
  I     otherwise return it unchanged.

Buggy programının çıktısının% 1 ile% 2 arasında bir olasılıkla sıralanmadığını iddia ediyorum. Tarafından Göstermek N = 251 elemanlarının mümkün olan değerler. L uzunluklarının rastgele bir listesinin 9 katları içermemesi olasılığı ((NK) / N) ^ L'dir , burada K , 9'a bölünebilen değerlerin sayısıdır ( K = 28 ). Toplam olasılık , bunun yaklaşık% 1.98 olduğu 5 ≤ L ≤ 255 için ortalamasıdır . Bu listelerin bazıları, zaten sıralandığından yanlış pozitif. Sıralama için L uzunluğunun rastgele bir listesinin olasılığı en fazladır ((N + N * (N-1) / 2) / N ^ 2) ^ ⌊L / 2⌋ : eğer listeyi uzunluk parçalarına bölersek 2, her biri⌊L / 2⌋ topakları sıralanmalıdır. Bir listenin sıralanmasının toplam olasılığı , yaklaşık% 0,30 olan 5 ≤ L ≤ 255 için yukarıdakilerin ortalaması ile sınırlıdır . Dolayısıyla, sıralanmamış bir liste döndüren işlevin olasılığı% 1.67 ile% 1.98 arasındadır.

Bash , 26 bayt

Doğru versiyonu

s=n
sort -${s:RANDOM%20<0}

Çevrimiçi deneyin! veya olasılıkları kontrol et .

Bugged sürüm

s=n
sort -${s:RANDOM%20<1}

Çevrimiçi deneyin! veya olasılıkları kontrol et .

Girdiyi yeni satır ayrılmış sayılar olarak alır. Yerleşik değişkeni kullanır RANDOM, 32767 - her zaman aralığı 0 bir (sözde) rasgele sayı ile döner . Kullanılması %20(ilgili sorunların netleştirilmesi için teşekkürler @Titus% 5 başarısızlık oranı hakkında sonuçlar %10).

Bu rasgelelik, başarısızlık oranının girdiden bağımsız olduğu anlamına gelir, ancak bu, başarısızlık çıktısının sözlüksel olarak sıralandığından, giriş dizisinin birden fazla rakam içeren en az bir sayı içermesini gerektirir.

Alternatif sürüm, 27 bayt

((RANDOM+20))||cat&&sort -n

Bugged sürüm +, a ile değiştirilir %. Çevrimiçi deneyin ya da tıkalı deneyin .

Pyth , puan 8 * 0,9 = 7,2

İlk pasaj (doğru olanı):

h.uSNT.S

Burada dene!

İkinci snippet (bir bugged):

O.uSNT.S

Burada dene!

İsaacg sayesinde iki bayt (ve 1.8 puan) kaydedildi !

JavaScript (ES6), 24 bayt

Hatasız sürüm (en azından 0-2147483647 aralığındaki tamsayılar için verilen aralıktaki herhangi bir şey için):

a=>a.sort((a,b)=>a-b>>0)

Buggy versiyonu:

a=>a.sort((a,b)=>a-b>>1)

A) motorun sıralama algoritmasına bağlı olarak ve b) yanlış sırada iki değer içeren girdi listesi 1 ile değişir. (Eğer olasılığı çok düşükse o zaman o 1zaman artabilirsin. için 8kendisine sadece aralığında bir şey sıralamak olmaz 5-255.)

PHP, 62 bayt

Jo’nun çözümünden ilham aldı (ve şunu fark ettim: Justin Mariner’in bir limanı ):

çalışma (artan türler):

unset($argv[0]);(r[rand()+20].sort)($argv);echo join(_,$argv);

adamcağız (yaklaşık% 5 azalan sıralama olasılığı):

unset($argv[0]);(r[rand()%20].sort)($argv);echo join(_,$argv);

İle koş -nr

Saldırgan , 9 bayt -% 10 = 8,1

Bugged Çözüm:

g0TUn?};_

Çevrimiçi deneyin!

Çalışma çözümü:

g1TUn?};_

Çevrimiçi deneyin!

Kodlanmış kod aşağıdakileri yapar:

g0TUn?};_

g          \ Sort the stack correctly
 0TU       \ Generate random(0, 10)
    n? ;   \ If this is zero:
      }    \    Cyclically shift the stack right once
        _  \ Print the result

Sabit kod basitçe değiştirir 0için 1. As random(1, 10)asla 0ifadesi çalıştırıldı asla eğer.

MATL , 7 * 0.9 = 6.3 6 * 0.9 = 5.4 bayt

Buggy versiyonu:

Gr.9<?S

Çevrimiçi deneyin!

Açıklama:

G        % Grab input
 r       % Push a random number between 0 and 1
  .9     % Push 0.9
    <    % Check if the random number is smaller than 0.9
     ?   % If true
      S  % Sort input
         % Implicit output

Sorunsuz versiyon:

Gr9<?S

Çevrimiçi deneyin!

Açıklama:

G       % Grab input
 r      % Push a random number between 0 and 1
  9     % Push 9
   <    % Check if the random number is smaller than 9 (always true)
    ?   % If true
     S  % Sort the input
        % Implicit output     

Jq 1.5 , 42 bayt

böcekli

sort|if length%13<=0then reverse else. end

Çalışıyor (= silmek)

sort|if length%13<0then reverse else. end

Satır uzunluklarının eşit olduğu varsayılarak [5,255] yaklaşık% 7 hataya neden olur

Çevrimiçi deneyin!

J, 22.5 bayt (25 bayt -% 10)

hata ile:

[:]`(1&A.)@.(0.1>?@0:)/:~

hata olmadan:

[:]`(0&A.)@.(0.1>?@0:)/:~

Çevrimiçi deneyin!

R , 30 * .9 = 27 bayt

(Arabası)

function(l)sort(l,runif(1)<.1)

Çevrimiçi deneyin!

(adamcağız değil)

function(l)sort(l,runif(1)<.0)

Buggy versiyonu decreasing=Tzamanın% 10'unu sıralar ve tek tip (0,1) dağılımdan örnekleme yapar. Un-buggy versiyonu her zamandecreasing=F

Röda , 42 bayt -% 10 = 37.8

Hata içermeyen:

{sort key={|i|currentTime|[_%20//19*0+i]}}

Buggy:

{sort key={|i|currentTime|[_%20//19*i+i]}}

Çevrimiçi deneyin!

Bu, currentTimerastgele sayılar oluşturmak için işlevi kullanır . Dağıtımlarının makineler arasında biraz farklı olduğu görülüyor. Oran 20//19, herhangi bir bayt cezası için farklı sonuçlar elde etmek için ayarlanabilir (daha küçük değilse 99//98).

Oktav , 36 * 0.9 = 32,4 bayt

Buggy versiyonu:

@(x)sort(x)(shift(1:end,+(rand<.1)))

Çevrimiçi deneyin!

Sorunsuz versiyon:

@(x)sort(x)(shift(1:end,+(rand<.0)))

Çevrimiçi deneyin!

Bu, vektörü sıralar, ardından rastgele bir sayı 0,1'den küçükse, tüm sayıları birer sağa kaydırır.

Java 8, 45 34,2 ( 50 38 - 10%) bayt

Normal sürüm:

a->{if(Math.random()>0.)a.sort(null);}

Açıklama:

Burada dene.

a->{                    // Method with ArrayList<Integer> parameter and no return-type
  if(Math.random()>0.)  //  If the random 0-1 double is larger than 0:
    a.sort(null);       //   Sort the input-List
}                       // End of method

Bugged sürüm ( 51 39 bayt):

a->{if(Math.random()>0.1)a.sort(null);}

1 / LD: 1 eklendi.

Açıklama:

Burada dene.

a->{                     // Method with ArrayList<Integer> parameter and no return-type
  if(Math.random()>0.1)  //  If the random 0-1 double is larger than 0.1:
    a.sort(null);        //   Sort the input-List
}                        // End of method

JavaScript, 25 * 0.9 = 22,5

new Date%25?x:x.sort()

giriş x