Ihre Eingabe ist eine Liste / Sequenz / Vektor / Array von 5 bis 255 positiven ganzen Zahlen, die nicht unbedingt eindeutig sind. Sie können davon ausgehen, welches Eingabeformat am besten geeignet ist und dass jede Ganzzahl (sowie die Anzahl der Ganzzahlen) einheitlich zufällig im Bereich von 5 bis 255 ausgewählt wird.

Ziel ist es, die gleiche Liste im gleichen (oder einem gleichwertigen) Format auszugeben, jedoch in aufsteigender (nicht absteigender) Reihenfolge. Eine übliche frühe Übung zum Erlernen einer Sprache. Einsendungen mit:

1. Eine Antwort, die richtig funktioniert und das Ziel erreicht; und

2. Eine zweite Antwort, die einen nervigen Bug enthält. Zwischen 1% und 10% der Zeit muss die Ausgabe eine Liste im richtigen Format sein und die richtigen Elemente enthalten, jedoch in der falschen Reihenfolge (jede Reihenfolge, außer richtig sortiert). In der restlichen Zeit muss das Programm korrekt funktionieren und das Ziel erreichen.

Die zwei Antworten müssen Levenshtein Abstand eins haben; Das heißt, wir können eines von dem anderen erhalten, indem wir ein Byte löschen, ein Byte hinzufügen oder ein Byte ändern.

Wie beim Code-Golf üblich punkten (basierend auf der kürzeren Ihrer beiden Antworten), wobei die üblichen Lücken verboten sind.

10% Bonus (Abnahme der Punktzahl), wenn der nervige Fehler unabhängig von der Eingabe ist, dh wenn der Fehler erneut verwendet wird, wird er nicht reproduziert (außer zwischen 1% und 10% der Zeit).

Python 3 , 36 Bytes

Fehlerfreie Version, 37 Bytes

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

Probieren Sie es online!

Nervige Version, 36 Bytes

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

Probieren Sie es online!

Dies hängt von der Eingabe ab und qualifiziert sich daher nicht für den Bonus.
Das Scheitern ist mit einer Wahrscheinlichkeit von rund 2% zu erwarten. Es schlägt fehl, wenn die Eingabelänge kleiner als 10 ist.

Kombiniert mit der Antwort von LyricLy ergibt dies 34 Bytes:

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

05AB1E , 5 * 0,9 = 4,5 Bytes

Funktionierende Lösung

{TLΩi

Probieren Sie es online!

Erläuterung

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

Lösung, die den Fehler enthält

Gibt die falsche Lösung 10% der Zeit (unabhängig von der Eingabe).

{TLΩiR

Probieren Sie es online!

Erläuterung

Entspricht der funktionierenden Lösung, mit der Ausnahme, dass die Liste umgekehrt wird, wenn die ausgewählte Zahl wahr ist.

Jelly , 7 × (100% - 10%) = 6,3 Bytes

Ṣ¹⁵X:¤¡

Probieren Sie es online!

Buggy-Version:

ṢẊ⁵X:¤¡

Probieren Sie es online!

In beiden Links gibt es ein Test-Harness, das den Code jedes Mal 100 Mal mit der von Ihnen als Argument angegebenen Liste ausführt und dann die Ergebnisse zurückgibt.

Die Wahrscheinlichkeit für jede Eingabelänge beträgt:

0.1 - 0.1/(length!)

Für die Länge 1 gibt es also eine Wahrscheinlichkeit von 0%, für die Länge 2 5%, für die Länge 3 8,83%, für die Länge 4 9,583% usw., bis die Länge ∞ eine Wahrscheinlichkeit von 10% hat.

Python 3, Ergebnis 58 57 - 10% = 51,3

Dank ovs ein Byte gespeichert.

Fehlerfreie Version, 57 Bytes

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

Probieren Sie es online!

Bugged Version, 57 Bytes

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

Probieren Sie es online!

Ich habe mich für eine Lösung entschieden, die den Bonus nutzt. Es schlägt die andere Python-Antwort nicht, aber ich hatte Spaß daran, es mir auszudenken.

C 71 * 0,9 = 63,9 Bytes

Bug-frei:

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

Probieren Sie es online!

Buggy:

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

Probieren Sie es online!

Groovy , 31 Bytes

Fehlerhafte Lösung:

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

Arbeits lösung:

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

Der Groovy-Indexoperator (die getAtMethode) gibt für Listen null zurück, wenn der Index größer als die Größe ist. Wenn es also ein neuntes Element gibt, bleibt es das gleiche wie die sortierte Liste, aber wenn nicht (1,99203187% Chance), wird es umgekehrt. Es wird jedoch immer ein erstes Element geben, da die Liste immer größer oder gleich 5 ist. Daher kann die 0 in a[0]gegen 1, 2, 3 oder 4 ausgetauscht werden.

Wolfram Language (Mathematica) , 29 Byte

Dies sind 26,1 Bytes mit dem Bonus, aber ich bin nicht ganz sicher, ob ich den Bonus verdiene. Bei bereits sortierten Eingaben erzeugen beide Versionen immer sortierte Ausgaben.

Fehlerfreie Version (29 Bytes)

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

Probieren Sie es online!

Nervige Version (30 Bytes)

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

Probieren Sie es online!

PHP, 70 Bytes

Fehlerfreie Version, 70 Bytes

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

Probieren Sie es online!

Bugged Version, 70 Bytes

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

Probieren Sie es online!

Die fehlerhafte Version wird 10% der Zeit in umgekehrter Reihenfolge sortiert (basierend auf einem Zufallszahlengenerator).

Python 2 , 26 Bytes

Buggy:

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

Probieren Sie es online!

Ausgaben durch Ändern der Eingabeliste . Sortiert die Liste nur, wenn ihre Länge mindestens 10 beträgt. Die nicht fehlerbehaftete Version ersetzt die Liste 9mit einem, 0um immer zu sortieren.

Arbeiten:

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

Probieren Sie es online!

Wir können die Funktion so ändern, dass die Liste zum Preis von 4 Bytes für insgesamt 30 Bytes zurückgegeben wird:

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

Probieren Sie es online!

25 Bytes mit einigen Abschnitten der Regeln:

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

Probieren Sie es online!

Gibt ein Funktionsliteral aus, das entweder die Identität sortiert oder id(0)als zufällige Quelle verwendet. Wechseln Sie >zu >=Fix oder 0zu ~0.

Schale , 6 Bytes

Buggy-Version:

?OIV¦9

Probieren Sie es online!

Korrekte Version:

?OIVK9

Probieren Sie es online!

Erläuterung

Diese Programme sind vollständig deterministisch. Tatsächlich unterstützt Husk derzeit überhaupt keine Zufallszahlen.

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

Ich behaupte, dass die Ausgabe des Buggy-Programms nicht mit einer Wahrscheinlichkeit zwischen 1% und 2% sortiert ist. Bezeichnen Sie mit N = 251 die Anzahl der möglichen Werte der Elemente. Die Wahrscheinlichkeit, dass eine zufällige Liste der Länge L keine Vielfachen von 9 enthält, ist ((NK) / N) ^ L , wobei K die Anzahl der durch 9 teilbaren Werte ist (in unserem Fall K = 28 ). Die Gesamtwahrscheinlichkeit ist der Durchschnitt für 5 ≤ L ≤ 255 , was ungefähr 1,98% entspricht. Einige dieser Listen sind falsch positiv, da sie bereits sortiert sind. Die Wahrscheinlichkeit, dass eine zufällige Liste der Länge L sortiert wird, beträgt höchstens ((N + N * (N-1) / 2) / N ^ 2) ^ ⌊L / 2⌋ : wenn wir die Liste in Stücke der Länge aufteilen 2, jeder der⌊L / 2⌋- Stücke müssen sortiert werden. Die Gesamtwahrscheinlichkeit, mit der eine Liste sortiert wird, ist durch den Durchschnitt der obigen für5 ≤ L ≤ 255 , was ungefähr 0,30% ist. Somit liegt die Wahrscheinlichkeit, dass die Funktion eine nicht sortierte Liste zurückgibt, zwischen 1,67% und 1,98%.

Bash , 26 Bytes

Korrekte Version

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

Probieren Sie es online! oder überprüfen Sie die Wahrscheinlichkeiten .

Bugged Version

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

Probieren Sie es online! oder überprüfen Sie die Wahrscheinlichkeiten .

Nimmt Eingaben als durch Zeilenumbrüche getrennte Zahlen vor. Verwendet die eingebaute Variable RANDOM, die immer eine (Pseudo-) Zufallszahl im Bereich von 0 bis 32767 zurückgibt . Die Verwendung von %20Ergebnissen führt zu einer Ausfallrate von ca. 5% (danke @Titus für die Klärung von Problemen mit %10).

Diese Zufälligkeit bedeutet, dass die Fehlerrate unabhängig von der Eingabe ist. Dies erfordert jedoch, dass das Eingabearray mindestens eine Zahl mit mehr als einer Ziffer enthält, da die Fehlerausgabe lexikografisch sortiert ist.

Alternative Version, 27 Byte

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

Bugged Version ersetzt die +mit einem %. Probieren Sie es online aus oder versuchen Sie es fehlerhaft .

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

Erstes Snippet (korrektes):

h.uSNT.S

Probieren Sie es hier aus!

Zweiter Ausschnitt (fehlerhafter):

O.uSNT.S

Probieren Sie es hier aus!

Dank isaacg wurden zwei Bytes (und 1,8 Punkte) gespart !

JavaScript (ES6), 24 Byte

Fehlerfreie Version (zumindest für ganze Zahlen im Bereich 0-2147483647, also alles im angegebenen Bereich):

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

Buggy-Version:

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

Hängt davon ab , a) ist der Motor Sortieralgorithmus und b) die Eingangsliste zwei Werte in der falschen Reihenfolge enthält , die aus durch 1. (Wenn die Wahrscheinlichkeit , dass die Windungen unterscheiden zu niedrig ist dann die 1erhöht werden kann, sondern durch die Zeit , die Sie erhalten , dazu 8wird einfach nichts im Sortiment sortiert 5-255.)

PHP, 62 Bytes

Inspiriert von Jo´s Lösung (und mir ist gerade aufgefallen, dass es sich um eine Portierung von Justin Mariner handelt ):

arbeiten (aufsteigend sortieren):

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

Buggy (ca. 5% Chance auf absteigende Sortierung):

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

Laufen Sie mit -nr

Pushy , 9 Bytes - 10% = 8,1

Fehlerhafte Lösung:

g0TUn?};_

Probieren Sie es online!

Arbeitslösung:

g1TUn?};_

Probieren Sie es online!

Der fehlerhafte Code bewirkt Folgendes:

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

Der feste Code ändert sich einfach 0zu 1. Wie random(1, 10)es niemals sein wird 0, wird die if-Anweisung niemals ausgeführt.

MATL , 7 × 0,9 = 6,3 6 × 0,9 = 5,4 Bytes

Buggy-Version:

Gr.9<?S

Probieren Sie es online!

Erläuterung:

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

Fehlerfreie Version:

Gr9<?S

Probieren Sie es online!

Erläuterung:

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 Bytes

Buggy

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

Arbeiten (löschen Sie das =)

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

Unter der Annahme, dass die Leitungslängen im Bereich [5.255] gleichmäßig sind, lösen etwa 7% den Fehler aus

Probieren Sie es online!

J, 22,5 Bytes (25 Bytes - 10%)

mit Fehler:

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

ohne Fehler:

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

Probieren Sie es online!

R , 30 * .9 = 27 Bytes

(Buggy)

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

Probieren Sie es online!

(nicht buggy)

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

Die Buggy-Version sortiert in decreasing=T10% der Fälle nach einer einheitlichen (0,1) Verteilung. Die Un-Buggy-Version ist immerdecreasing=F

Röda , 42 Bytes - 10% = 37,8

Bug-frei:

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

Buggy:

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

Probieren Sie es online!

Dies verwendet die currentTimeFunktion, um Zufallszahlen zu erstellen. Es scheint, dass ihre Verteilung zwischen Maschinen ein wenig variiert. Das Verhältnis 20//19kann angepasst werden, um unterschiedliche Ergebnisse für keine Byte-Strafe zu erhalten (es sei denn, es ist kleiner als 99//98).

Oktave , 36 * 0,9 = 32,4 Bytes

Buggy-Version:

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

Probieren Sie es online!

Fehlerfreie Version:

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

Probieren Sie es online!

Dies sortiert den Vektor und verschiebt dann alle Zahlen um eins nach rechts, wenn eine Zufallszahl kleiner als 0,1 ist.

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

Normale Version:

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

Erläuterung:

Probieren Sie es hier aus.

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 Version ( 51 39 Bytes):

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

LD von 1: 1hinzugefügt.

Erläuterung:

Probieren Sie es hier aus.

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 eingeben