Grundlegende Art, mit nervigem Bug

28

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

code-golf  array-manipulation  random  integer 
— Vadim Ponomarenko
quelle
9
Willkommen bei PPCG! Ich schlage vor, den Bonus zu streichen, es ist keine wirklich gute Übung.
— Mr. Xcoder
2
Es ist unklar, wie hoch die Wahrscheinlichkeit für jede mögliche Eingabelänge ist.
— user202729
12
Sollte die Spezifikation zwischen 1% und 10% der Zeit für erfüllt jeden Eingang oder insgesamt für den Satz von möglichen Eingaben? Für einige Eingaben wie [5,5,5]es ist unmöglich, die falsche Reihenfolge zu produzieren
— Luis Mendo
4
Es gibt eine Feinheit in Bezug auf unsere Standard-E / A-Formate . Wenn unser Code eine Funktion definiert, ist es in Ordnung, wenn er die Möglichkeit hat, die Funktion konsistent fehlerhaft zu definieren, anstatt eine Funktion zu definieren, die die Möglichkeit hat, fehlerhaft zu sein?
— Xnor
1
@VadimPonomarenko Auf dieser Website dürfen sowohl Funktionen als auch vollständige Programme bereitgestellt werden. xnor fragt, ob eine Funktion zulässig ist, die in 1% bis 10% der Zeit, in der sie erstellt wurde, eine fehlerhafte Funktion ist, die immer einen Fehler aufweist. Wenn Sie sich an den Buchstaben Ihrer Frage halten, ist die Antwort wahrscheinlich nein , aber es würde mehr Spaß machen, wenn es ja wäre .
— wizzwizz4

Antworten:

9

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]
— ovs
quelle
Ich glaube nicht, dass Sie den Platz in der fehlerfreien Version brauchen.
— wizzwizz4
@ wizzwizz4 ohne Leerzeichen or1wird als Variablenname interpretiert und löst einen Syntaxfehler aus.
— Ovs
9

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.

— Emigna
quelle
Ernsthaft was zum Teufel. Die Ausgabe ist nicht einmal von der richtigen Kardinalität.
— Joshua
@ Joshua Was meinst du?
— Erik der Outgolfer
Online ausprobieren zeigt die Ausgabe einer Liste von Listen.
— Joshua
4
@Joshua Der TiO-Link enthält eine Kopf- 100Fund eine Fußzeile },, mit deren Hilfe wir das Ergebnis der Funktion, die für den Eingang aufgerufen wird, mehrmals visualisieren können. Dies zeigt uns, dass die funktionierende Lösung immer korrekte Ergebnisse liefert, während die fehlerhafte Ausgabe fehlerhaft ist.
— Mr. Xcoder
Bitte, jemand, erkläre den Algorithmus. Bald werde ich die bestplatzierte Einsendung (oder eine der bestplatzierten Einsendungen) akzeptieren. Ich kann keine Lösung akzeptieren, die ich nicht verstehen kann.
— Vadim Ponomarenko
7

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.

— Erik der Outgolfer
quelle
Sollte sein 0.1 - 0.1/(length!).
— user202729
@ user202729 sicher
— Erik der Outgolfer
Ṣ⁵X’¤¡und Ṣ⁵X¤¡sollte auch funktionieren: Buggy-Version gibt die Liste <10% der Zeit unsortiert zurück, und wenn die Eingabe einheitlich zufällig gewählt wird, sollte es funktionieren, 2 Bytes sparen.
— user202729
Wenn Ihnen diese Lösung nicht gefällt, können Sie natürlich einfach das ¹zu speichernde 1 Byte löschen (die Anzahl der Bytes für die Regel = das kürzere); Außerdem gibt es nach dem zweiten 6in eine zusätzliche Zeile für das Kombinieren 6.6̅%.
— user202729
@ user202729 Leider ist es dann nicht mehr unabhängig von der Eingabe, und nein, ich kann das nicht "einfach entfernen ¹", weil es dann in 10% der Fälle überhaupt nicht sortieren würde.
— Erik der Outgolfer
6

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.

— Textlich
quelle
4

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.

— Hlaaftana
quelle
1
Willkommen auf der Seite und schönen ersten Beitrag!
— Caird Coinheringaahing
3

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

— Jo.
quelle
Das Tag mit -r(-2 Bytes) ist nicht erforderlich . Beitritt durch Unterstrich; Das sollte äquivalent sein (-2 Bytes). Verwenden Sie asortanstelle von sort(-1 Byte).
— Titus
... oder verwenden Sie das ganze Wort anstelle des Präfixes (oder nicht): unset($argv[0]);(rand(1,9)?sort:rsort)($argv);echo join(_,$argv); (auch 65 Bytes)
— Titus
3

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.

— xnor
quelle
3

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

— Zgarb
quelle
teilbar durch 9 ergibt eine Ausfallwahrscheinlichkeit von ca. 11%. und nicht sortieren garantiert nicht, dass die Liste unsortiert ist.
— Titus
1
@Titus Ich adressiere dies in der Analyse. Ein Sortierfehler tritt nur auf, wenn die Liste keine durch 9 teilbaren Elemente enthält . Die Wahrscheinlichkeit hierfür liegt bei 1,98%. Und es ist wahr, dass, wenn die Liste bereits sortiert ist, das Nichtbeachten auch eine sortierte Liste ergibt. Die Wahrscheinlichkeit, dass die Liste bereits sortiert ist, beträgt jedoch höchstens 0,30%, was niedrig genug ist, dass die Gesamtwahrscheinlichkeit für die Ausgabe einer nicht sortierten Liste über 1% liegt.
— Zgarb
true ... und die zu sortierende Eingabe ändert nichts an dem Fehler.
— Titus
Könnten Sie vielleicht ↓9anstelle von verwenden V¦9und es nur 9für die richtige Version kürzen ? Dies würde dazu führen, dass es bei kurzen Eingaben immer fehlschlägt und bei längeren Eingaben immer korrekt funktioniert. Da die Eingabelänge jedoch einer zufälligen Verteilung folgt, sollte es sich dennoch um eine gültige Antwort handeln
— Leo,
3

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 .

— Justin Mariner
quelle
penny picking: %10hat eine höhere Wahrscheinlichkeit 0, 7als 8oder zurückzukehren 9, so dass die Wahrscheinlichkeit des Scheiterns über 10% liegt;)
— Titus
@Titus Danke, das habe ich vergessen. Aktualisiert, um zu verwenden, %20wie es Ihre Antwort tut.
— Justin Mariner
3

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 !

— Mr. Xcoder
quelle
Ich denke, 9 statt 10 neue Exemplare wären in Ordnung. Die Möglichkeit .S, die Eingabe unverändert zurückzugeben, bedeutet, dass in diesen (seltenen) Fällen die Wahrscheinlichkeit einer falschen Antwort von 10% auf 0% sinkt - im Durchschnitt also immer noch im richtigen Bereich. Natürlich sind auch 10 Exemplare in Ordnung.
— Mischa Lawrow
@ Mischa Lawrow Ich habe einen Fehler in meiner Erklärung gemacht, jetzt angesprochen. Ich sagte, es .Skönnte auch die Eingabe selbst zurückgeben (was kein Problem wäre), aber ich meinte, es .Skönnte auch die sortierte Liste zurückgeben .
— Mr. Xcoder
Richtig, das habe ich auch gemeint.
— Mischa Lawrow
Gleiche Idee, aber kürzer:O.uSNT.S
— isaacg
2

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

— Neil
quelle
2

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

— Titus
quelle
2

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.

— FlipTack
quelle
2

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
— Stewie Griffin
quelle
1

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!

— jq170727
quelle
1

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

— Giuseppe
quelle
1

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

— fergusq
quelle
1

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
— Kevin Cruijssen
quelle
0

JavaScript, 25 * 0,9 = 22,5

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

x eingeben

— l4m2
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.