Tri de base, avec bug ennuyeux

28

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

code-golf  array-manipulation  random  integer 
— Vadim Ponomarenko
source
9
Bienvenue chez PPCG! Je suggère de supprimer le bonus, ce n'est pas vraiment une bonne pratique.
— M. Xcoder
2
On ne sait pas quelle est la probabilité de chaque longueur d'entrée possible.
— user202729
12
La spécification entre 1% et 10% du temps doit-elle être remplie pour chaque entrée ou juste globalement pour l'ensemble des entrées possibles? Pour certaines entrées comme [5,5,5]il est impossible de produire le mauvais ordre
— Luis Mendo
4
Il y a une subtilité concernant nos formats d'E / S par défaut . Si notre code définit une fonction, est-ce correct s'il a une chance de définir la fonction de manière cohérente boguée, par opposition à la définition d'une fonction qui a une certaine chance d'être boguée?
— 2017 à 12h08
1
@VadimPonomarenko Sur ce site, les gens sont autorisés à fournir des fonctions ainsi que des programmes complets. xnor demande s'il est permis d'avoir une fonction qui, 1% à 10% du temps lors de sa création, est une fonction buggy qui aura toujours un bug. En gardant à la lettre de votre question la réponse est probablement non , mais ce serait plus amusant si c'était oui .
— wizzwizz4

Réponses:

9

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]
— ovs
source
Je ne pense pas que vous ayez besoin de l'espace dans la version sans bug.
— wizzwizz4
@ wizzwizz4 sans l'espace or1sera interprété comme un nom de variable et déclenche une erreur de syntaxe.
— 2017 à 15h13
9

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.

— Emigna
source
Sérieusement ce que le bon. La sortie n'est même pas de la bonne cardinalité.
— Joshua
@Joshua Que voulez-vous dire?
— Erik the Outgolfer
L'essayer en ligne montre qu'il affiche une liste de listes.
— Joshua
4
@Joshua Le lien TiO comprend un en-tête 100Fet un pied de page },qui nous aident à visualiser le résultat de la fonction appelée plusieurs fois sur l'entrée. Cela nous montre que la solution de travail retourne toujours des résultats corrects, tandis que la solution buggée a une sortie défectueuse.
— M. Xcoder
S'il vous plaît, quelqu'un, expliquez l'algorithme. Bientôt, j'accepterai la soumission la mieux classée (ou l'une des soumissions les mieux classées). Je ne peux accepter aucune solution que je ne comprends pas.
— Vadim Ponomarenko
7

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

— Erik le Outgolfer
source
Devrait l'être 0.1 - 0.1/(length!).
— user202729
@ user202729 sûr
— Erik the Outgolfer
Ṣ⁵X’¤¡et Ṣ⁵X¤¡devrait également fonctionner: la version buggy renvoie la liste non triée <10% du temps, et étant donné que l'entrée est choisie uniformément au hasard, cela devrait fonctionner, économiser 2 octets.
— user202729
Si vous n'aimez pas cette solution, vous pouvez évidemment supprimer le ¹pour enregistrer 1 octet (le nombre de règles compte d'octets = le plus court); il y a aussi un parasite combinant overline après la seconde 6dans 6.6̅%.
— user202729
@ user202729 Malheureusement, il ne sera plus indépendant de l'entrée, et non, je ne peux pas "simplement supprimer le ¹" car il ne serait pas du tout trié 10% du temps.
— Erik the Outgolfer
6

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.

— LyricLy
source
5

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!

— Steadybox
source
+1 pour% 1 (oh allez 6 de plus pour y aller tu dois me moquer de moi)
— Joshua
4

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.

— Hlaaftana
source
1
Bienvenue sur le site et bon premier post!
— caird coinheringaahing
3

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

— Jo.
source
pas besoin de la balise avec -r(-2 octets). rejoindre par un trait de soulignement; cela devrait être équivalent (-2 octets). utiliser asortau lieu de sort(-1 octet).
— Titus
... ou utilisez le mot entier au lieu du préfixe (ou non): unset($argv[0]);(rand(1,9)?sort:rsort)($argv);echo join(_,$argv);(également 65 octets)
— Titus
3

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.

— xnor
source
3

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

— Zgarb
source
divisible par 9 donne environ 11% de chances d'échec. et ne pas trier ne garantit pas que la liste n'est pas triée.
— Titus
1
@Titus J'aborde cette question dans l'analyse. L'échec du tri ne se produit que si la liste ne contient aucun élément divisible par 9. La probabilité est d'environ 1,98%. Et c'est vrai que si la liste est déjà triée, ne rien faire donnera également une liste triée. Cependant, la probabilité que la liste soit déjà triée est au plus de 0,30%, ce qui est suffisamment faible pour que la probabilité totale de sortie d'une liste non triée soit supérieure à 1%.
— Zgarb
true ... et l'entrée en cours de tri ne change pas le bug.
— Titus
Pourriez-vous peut-être utiliser à la ↓9place de V¦9, et le raccourcir juste 9pour la bonne version? Cela le ferait toujours échouer sur les entrées courtes et fonctionnerait toujours correctement sur les entrées plus longues, mais puisque la longueur d'entrée suit une distribution aléatoire, cela devrait toujours être une réponse valide
— Leo
3

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 .

— Justin Mariner
source
penny cueillette: %10a une plus grande chance de retour 0à 7de 8ou 9, si le risque de rupture est supérieure à 10%;)
— Titus
@Titus Merci, j'ai oublié ce fait. Mis à jour pour utiliser %20comme votre réponse.
— Justin Mariner
3

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 !

— M. Xcoder
source
Je pense que 9 plutôt que 10 nouveaux exemplaires conviendraient. La possibilité de .Srenvoyer l'entrée inchangée signifie que dans ces (rares) cas, nos chances d'obtenir la mauvaise réponse passent de 10% à 0% - donc en moyenne, c'est toujours dans la bonne plage. Bien sûr, 10 exemplaires sont également très bien.
— Misha Lavrov
@MishaLavrov J'ai fait une erreur dans mon explication, maintenant adressée. J'ai dit que cela .Spourrait également renvoyer l'entrée elle-même (ce qui ne serait pas un problème), mais je voulais dire que cela .Spourrait également renvoyer la liste triée .
— M. Xcoder
C'est ce que je voulais dire aussi.
— Misha Lavrov
Même idée, mais plus courte:O.uSNT.S
— isaacg
2

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

— Neil
source
2

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

— Titus
source
2

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.

— FlipTack
source
2

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

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!

— jq170727
source
1

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

— Giuseppe
source
1

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

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

JavaScript, 25 * 0,9 = 22,5

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

entrée x

— l4m2
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.