Votre entrée est une liste / séquence / vecteur / tableau de 5 à 255 entiers positifs, pas nécessairement unique. Vous pouvez supposer que le format d'entrée est le plus approprié et que chaque entier (ainsi que la quantité d'entiers) est choisi uniformément au hasard dans la plage 5-255.

Le but est de sortir la même liste, dans le même format (ou équivalent), mais trié par ordre croissant (non décroissant). Un exercice précoce courant pour apprendre une langue. Les soumissions doivent inclure:

1. Une réponse qui fonctionne correctement et atteint l'objectif; et

2. Une deuxième réponse qui contient un bug gênant. Entre 1% et 10% du temps, la sortie doit être une liste au format correct et contenant les éléments corrects, mais dans le mauvais ordre (tout ordre sauf correctement trié). Le reste du temps, le programme doit fonctionner correctement et atteindre l'objectif.

Les deux réponses doivent avoir une distance de Levenshtein un; c'est-à-dire que nous pouvons obtenir l'un de l'autre en supprimant un octet, en ajoutant un octet ou en modifiant un octet.

Marquer comme d'habitude dans le code-golf (basé sur la plus courte de vos deux réponses), avec les failles habituelles interdites.

Bonus de 10% (diminution du score) si le bug ennuyeux est indépendant de l'entrée, c'est-à-dire que l'utilisation de la même entrée ne reproduit pas le bug (sauf entre 1% et 10% du temps).

Python 3 , 36 octets

Version sans bug, 37 octets

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

Essayez-le en ligne!

Version ennuyeuse, 36 octets

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

Essayez-le en ligne!

Cela dépend de l'entrée et ne donne donc pas droit au bonus.
Il a une probabilité d'environ 2% d'échouer. Il échoue lorsque la longueur d'entrée est inférieure à 10.

Combiné avec la réponse de LyricLy, cela donne 34 octets:

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

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

Solution de travail

{TLΩi

Essayez-le en ligne!

Explication

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

Solution contenant le bug

Donne la mauvaise solution 10% du temps (indépendante de l'entrée).

{TLΩiR

Essayez-le en ligne!

Explication

Identique à la solution de travail, sauf qu'elle inverse la liste si le nombre choisi est vrai.

Gelée , 7 * (100% - 10%) = 6,3 octets

Ṣ¹⁵X:¤¡

Essayez-le en ligne!

Version buggy:

ṢẊ⁵X:¤¡

Essayez-le en ligne!

Dans les deux liens, il y a un harnais de test qui exécutera le code 100 fois, chaque fois avec la liste que vous donnez comme argument, puis retourne les résultats.

La probabilité de chaque longueur d'entrée est:

0.1 - 0.1/(length!)

Donc, pour la longueur 1, il y a une probabilité de 0%, pour la longueur 2 5%, pour la longueur 3 8,83̅%, pour la longueur 4 9,583̅% etc. jusqu'à la longueur ∞ qui a une probabilité de 10%.

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

Sauvegardé un octet grâce aux ovs.

Version sans bug, 57 octets

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

Essayez-le en ligne!

Version buggée, 57 octets

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

Essayez-le en ligne!

J'ai décidé d'essayer une solution qui utilise le bonus. Cela ne bat pas l'autre réponse Python, mais je me suis amusé à y penser.

C, 71 * 0,9 = 63,9 octets

Sans bug:

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

Essayez-le en ligne!

Buggy:

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

Essayez-le en ligne!

Groovy , 31 octets

Solution buggée:

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

Solution de travail:

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

L'opérateur d'indice Groovy (la getAtméthode) renvoie null pour les listes si l'index est plus grand que la taille. Donc, s'il y a un neuvième élément, il restera le même que la liste triée, mais sinon (1,99203187% de chance), il sera inversé. Cependant, il y aura toujours un premier élément car la taille de la liste est toujours supérieure ou égale à 5. Ainsi, le 0 in a[0]pourrait être échangé avec 1, 2, 3 ou 4.

Wolfram Language (Mathematica) , 29 octets

C'est 26,1 octets avec le bonus, mais je ne suis pas tout à fait sûr de gagner le bonus; sur une entrée déjà triée, les deux versions produisent toujours une sortie triée.

Version sans bug (29 octets)

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

Essayez-le en ligne!

Version ennuyeuse (30 octets)

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

Essayez-le en ligne!

PHP, 70 octets

Version sans bug, 70 octets

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

Essayez-le en ligne!

Version buggée, 70 octets

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

Essayez-le en ligne!

La version buggée trie dans l'ordre inverse 10% du temps (sur la base d'un générateur de nombres aléatoires).

Python 2 , 26 octets

Buggy:

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

Essayez-le en ligne!

Sorties en modifiant la liste des entrées . Trie la liste uniquement si sa longueur est d'au moins 10. La version non buggée remplace le 9par un 0pour toujours trier.

Travail:

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

Essayez-le en ligne!

On peut modifier la fonction pour renvoyer la liste au prix de 4 octets, pour 30 octets au total:

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

Essayez-le en ligne!

25 octets avec quelques étirements des règles:

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

Essayez-le en ligne!

Génère un littéral de fonction qui trie ou constitue l'identité, en utilisant id(0)comme source aléatoire. Changez >pour >=fixer ou 0pour ~0.

Husk , 6 octets

Version buggy:

?OIV¦9

Essayez-le en ligne!

Version correcte:

?OIVK9

Essayez-le en ligne!

Explication

Ces programmes sont complètement déterministes. En fait, Husk n'a actuellement aucun support pour les nombres aléatoires.

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

Je prétends que la sortie du programme buggy n'est pas triée avec une probabilité comprise entre 1% et 2%. Notons N = 251 le nombre de valeurs possibles des éléments. La probabilité qu'une liste aléatoire de longueur L ne contienne pas de multiples de 9 est ((NK) / N) ^ L , où K est le nombre de valeurs divisibles par 9 (dans notre cas K = 28 ). La probabilité totale en est la moyenne pour 5 ≤ L ≤ 255 , soit environ 1,98%. Certaines de ces listes sont des faux positifs, car elles sont déjà triées. La probabilité qu'une liste aléatoire de longueur L soit triée est au plus ((N + N * (N-1) / 2) / N ^ 2) ^ ⌊L / 2⌋ : si nous divisons la liste en morceaux de longueur 2, chacun desLes morceaux ⌊L / 2⌋ doivent être triés. La probabilité totale de tri d'une liste est limitée par la moyenne de ce qui précède pour 5 ≤ L ≤ 255 , soit environ 0,30%. Ainsi, la probabilité que la fonction renvoie une liste non triée se situe entre 1,67% et 1,98%.

Bash , 26 octets

Version correcte

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

Essayez-le en ligne! ou vérifiez les probabilités .

Version buggée

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

Essayez-le en ligne! ou vérifiez les probabilités .

Prend la saisie sous forme de nombres séparés par des sauts de ligne. Utilise la variable intégrée RANDOM, qui renvoie toujours un nombre (pseudo) aléatoire compris entre 0 et 32767 . L'utilisation des %20résultats entraîne un taux d'échec d'environ 5% (merci à @Titus d'avoir clarifié les problèmes avec %10).

Ce caractère aléatoire signifie que le taux d'échec est indépendant de l'entrée, mais cela nécessite que le tableau d'entrée comprenne au moins un nombre à plus d'un chiffre, car la sortie d'échec est triée lexicographiquement.

Version alternative, 27 octets

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

La version buggée remplace le +par un %. Essayez-le en ligne ou essayez-le .

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

Premier extrait (correct):

h.uSNT.S

Essayez-le ici!

Deuxième extrait (un buggé):

O.uSNT.S

Essayez-le ici!

Enregistrement de deux octets (et score de 1,8) grâce à isaacg !

JavaScript (ES6), 24 octets

Version sans bogue (au moins pour les entiers dans la plage 0-2147483647, donc tout dans la plage donnée):

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

Version buggy:

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

Cela dépend a) de l'algorithme de tri du moteur et b) de la liste d'entrée contenant deux valeurs dans le mauvais ordre qui diffèrent de 1. (Si la probabilité de cela s'avère trop faible, la 1peut être augmentée, mais au moment où vous obtenez à 8simplement ne rien trier dans la gamme 5-255.)

PHP, 62 octets

inspiré par la solution de Jo (et je viens de remarquer: c'est un port de Justin Mariner ):

travail (tri croissant):

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

buggy (environ 5% de chances de tri décroissant):

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

Courir avec -nr

Pushy , 9 octets - 10% = 8,1

Solution buggée:

g0TUn?};_

Essayez-le en ligne!

Solution de travail:

g1TUn?};_

Essayez-le en ligne!

Le code buggé fait ce qui suit:

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

Le code fixe change simplement 0en 1. Comme random(1, 10)jamais 0, l'instruction if ne sera jamais exécutée.

MATL , 7 * 0,9 = 6,3 6 * 0,9 = 5,4 octets

Version buggy:

Gr.9<?S

Essayez-le en ligne!

Explication:

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

Version sans bug:

Gr9<?S

Essayez-le en ligne!

Explication:

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 octets

Buggy

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

Fonctionne (supprimer le =)

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

En supposant que les longueurs de ligne sont uniformes dans la plage [5 255] environ 7% déclencheront le bogue

Essayez-le en ligne!

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

avec bug:

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

sans bug:

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

Essayez-le en ligne!

R , 30 * .9 = 27 octets

(buggy)

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

Essayez-le en ligne!

(pas buggy)

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

La version buggy trie dans decreasing=T10% du temps, en échantillonnant à partir d'une distribution uniforme (0,1). La version non buggée est toujoursdecreasing=F

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

Sans bug:

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

Buggy:

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

Essayez-le en ligne!

Cela utilise la currentTimefonction pour créer des nombres aléatoires. Il semble que leur distribution varie un peu entre les machines. Le rapport 20//19peut être ajusté pour obtenir des résultats différents sans pénalité d'octet (sauf s'il est plus petit que 99//98).

Octave , 36 * 0,9 = 32,4 octets

Version buggy:

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

Essayez-le en ligne!

Version sans bug:

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

Essayez-le en ligne!

Cela trie le vecteur, puis décale tous les nombres un vers la droite si un nombre aléatoire est inférieur à 0,1.

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

Version normale:

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

Explication:

Essayez-le ici.

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

Version buggée ( 51 39 octets):

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

LD de 1: 1ajouté.

Explication:

Essayez-le ici.

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

entrée x