入力は5-255の正の整数のリスト/シーケンス/ベクトル/配列であり、必ずしも一意ではありません。どのような入力形式が最も適切であり、各整数（および整数の量）が5〜255の範囲から一様にランダムに選択されると想定できます。

目標は、同じ（または同等の）形式で同じリストを出力することですが、昇順（非降順）にソートされます。言語学習の一般的な初期の練習。含める提出物：

1. 正しく機能し、目標を達成する回答。そして

2. 迷惑なバグを含む2番目の回答。時間の1％から10％の間、出力は正しい形式で、正しい要素を含むリストである必要がありますが、順序は正しくありません（正しくソートされていない任意の順序）。残りの時間、プログラムは正しく動作し、目標を達成する必要があります。

2つの答えには、レーベンシュタイン距離 1 が必要です。つまり、1バイトを削除するか、1バイトを追加するか、1バイトを変更することで、一方から他方を取得できます。

通常の抜け穴を禁止した状態で、2つの回答のうち短い方に基づいて、コードゴルフで通常どおりスコアリングします。

迷惑なバグが入力に依存しない場合、つまり同じ入力を再度使用してもバグが再現されない場合は、10％のボーナス（スコアの減少）（1％から10％の間を除く）。

Python 3、36バイト

バグのないバージョン、37バイト

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

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

迷惑なバージョン、36バイト

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

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

これは入力に依存するため、ボーナスの対象にはなりません。
失敗する確率は約2％です。入力長が10より小さい場合、失敗します。

LyricLyの回答と組み合わせると、これは34バイトになります。

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

05AB1E、5 * 0.9 = 4.5バイト

実用的なソリューション

{TLΩi

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

説明

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

バグを含む解決策

時間の10％で間違ったソリューションを提供します（入力に依存しません）。

{TLΩiR

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

説明

選択された数値がtrueの場合にリストを逆にすることを除いて、作業ソリューションと同じです。

ゼリー、7 *（100％-10％）= 6.3バイト

Ṣ¹⁵X:¤¡

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

バギー版：

ṢẊ⁵X:¤¡

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

両方のリンクには、コードを100回実行し、そのたびに引数として指定したリストを使用して、結果を返すテストハーネスがあります。

各入力長の確率は次のとおりです。

0.1 - 0.1/(length!)

したがって、長さ1の場合は0％の確率、長さ2の場合は5％、長さ3の場合は8.83 4％、長さ4の場合は9.583̅％など、10％の確率を持つ長さ∞までです。

Python 3、スコア58 57-10％= 51.3

ovsのおかげで1バイト節約できました。

バグのないバージョン、57バイト

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

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

バグバージョン、57バイト

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

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

ボーナスを使用するソリューションを試すことにしました。他のPythonの答えに勝るものはありませんが、考えてみるのは楽しかったです。

C、71 * 0.9 = 63.9バイト

バグフリー：

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

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

バギー：

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

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

Groovy、31バイト

バグのあるソリューション：

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

実用的なソリューション：

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

Groovyの添字演算子（getAtメソッド）は、インデックスがサイズより大きい場合、リストに対してnullを返します。したがって、9番目の要素がある場合、並べ替えられたリストと同じままになりますが、そうでない場合（1.99203187％の確率）、元に戻ります。ただし、リストのサイズは常に5以上であるため、常に最初の要素が存在します。したがって、0 in a[0]は1、2、3、または4と交換できます。

Wolfram言語（Mathematica）、29バイト

これはボーナスで26.1バイトですが、ボーナスを獲得できるかどうかはわかりません。すでにソートされた入力では、両方のバージョンが常にソートされた出力を生成します。

バグのないバージョン（29バイト）

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

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

迷惑なバージョン（30バイト）

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

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

PHP、70バイト

バグのないバージョン、70バイト

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

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

バグバージョン、70バイト

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

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

バグのあるバージョンは、10％の時間の逆順でソートされます（乱数ジェネレーターに基づく）。

Python 2、26バイト

バギー：

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

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

出力入力リストを修正します。リストの長さが少なくとも10の場合にのみリストをソートします。バギーではないバージョンは、常に9a 0に置き換えられます。

ワーキング：

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

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

4バイトのコストでリストを返すように関数を変更できます（合計30バイト）：

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

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

いくつかの規則の範囲を持つ25バイト：

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

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

id(0)ランダムソースとして使用して、並べ替えまたはIDである関数リテラルを出力します。変更>に>=修正する、または0します~0。

殻、6バイト

バギー版：

?OIV¦9

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

正しいバージョン：

?OIVK9

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

説明

これらのプログラムは完全に決定的です。実際、Huskは現在、乱数をまったくサポートしていません。

?  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.

バギープログラムの出力は、1％〜2％の確率でソートされていないと主張します。表すN = 251の要素の可能な値の数。長さLのランダムリストに9の倍数が含まれない確率は（（NK）/ N）^ Lです。ここで、Kは9で割り切れる値の数です（この例ではK = 28）。合計確率はこの平均で5≤L≤255 1.98パーセント程度です。これらのリストの一部は、すでにソートされているため、誤検知です。ソートされる長さLのランダムリストの確率は、最大で（（N + N *（N-1）/ 2）/ N ^ 2）^⌊L/2⌋です：リストを長さのチャンクに分割する場合2、それぞれ⌊L/2⌋チャンクはソートする必要があります。ソートされるリストの合計確率は、5≤L≤255の上記の平均によって制限されます。これは約0.30％です。したがって、関数がソートされていないリストを返す確率は1.67％〜1.98％です。

Bash、26バイト

正しいバージョン

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

オンラインでお試しください！または、確率を確認します。

バグバージョン

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

オンラインでお試しください！または、確率を確認します。

入力を改行区切りの数値として受け取ります。組み込み変数を使用します。組み込み変数はRANDOM、常に0〜32767の範囲の（擬似）乱数を返します。%20約5％の失敗率で結果を使用します（@Titusの問題を明確にしてくれてありがとう%10）。

このランダム性は、故障率が入力に依存しないことを意味しますが、故障出力は辞書式にソートされるため、入力配列には少なくとも1桁以上の数字が含まれている必要があります。

代替バージョン、27バイト

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

盗聴のバージョンが置き換えられ+て%。オンラインそれを試してみたり、それが盗聴してみてください。

Pyth、スコア8 * 0.9 = 7.2

最初のスニペット（正しいもの）：

h.uSNT.S

ここで試してみてください！

2番目のスニペット（バグのあるスニペット）：

O.uSNT.S

ここで試してみてください！

isaacgのおかげで2バイト（および1.8スコア）節約できました！

JavaScript（ES6）、24バイト

バグのないバージョン（少なくとも0-2147483647の範囲の整数の場合、指定された範囲内のすべてのもの）：

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

バギー版：

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

a）エンジンのソートアルゴリズムとb）1の異なる間違った順序の2つの値を含む入力リストに依存します（その確率が低すぎると判明した場合は、1増加する可能性がありますが、8それだけで範囲内のものをソートしません5-255。）

PHP、62バイト

ジョーのソリューションに触発された（そして私はちょうど気づいた：それはジャスティンマリナーのポートです）：

作業中（昇順で並べ替え）：

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

バギー（降順ソートの約5％の確率）：

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

で実行 -nr

Pushy、9バイト-10％= 8.1

バグのあるソリューション：

g0TUn?};_

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

ワーキングソリューション：

g1TUn?};_

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

バグのあるコードは次のことを行います。

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

固定コードは単純に変更0します1。のrandom(1, 10)よう0に、ifステートメントは実行されません。

MATL、7 * 0.9 = 6.3 6 * 0.9 = 5.4バイト

バギー版：

Gr.9<?S

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

説明：

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

バグのないバージョン：

Gr9<?S

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

説明：

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バイト

バギー

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

作業中（=を削除）

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

行の長さが[5,255]の範囲で均一であると仮定すると、約7％がバグを引き起こします

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

J、22.5バイト（25バイト-10％）

バグあり：

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

バグなし：

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

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

R、30 * .9 = 27バイト

（バギー）

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

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

（バグではありません）

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

バグのあるバージョンdecreasing=Tは、時間の10％でソートされ、uniform（0,1）ディストリビューションからサンプリングされます。バグのないバージョンは常にdecreasing=F

ローダ、42バイト-10％= 37.8

バグフリー：

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

バギー：

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

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

これは、currentTime関数を使用して乱数を作成します。それらの分布はマシン間で少し異なるようです。比率20//19は、バイトペナルティなしで異なる結果を得るために調整できます（それがより小さい場合を除く99//98）。

オクターブ、36 * 0.9 = 32.4バイト

バギー版：

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

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

バグのないバージョン：

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

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

これにより、ベクトルが並べ替えられ、乱数が0.1未満の場合、すべての数値が1つ右にシフトされます。

Javaの8、45 34.2（50 38から10パーセント）バイト

通常版：

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

説明：

ここで試してみてください。

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

バグバージョン（51 39バイト）：

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

1：のLD 1。

説明：

ここで試してみてください。

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

入力x