Écrire un code de buggy [fermé]

Il est maintenant temps de montrer vos capacités à écrire du mauvais code. J'essaie un nouveau type de puzzle de programmation, le plus similaire, je pense, au concours C sournois. La principale différence est que ce n'est pas aussi néfaste: c'est juste un bon amusement propre. Le but du puzzle est de regrouper autant de bugs que possible dans un programme. Le gagnant de ce concours est celui qui écrit le programme avec le plus de bugs par personnage.

Pour éviter un énorme fil de commentaires demandant des éclaircissements, je devrais définir dès maintenant ce que je considère comme des bogues éligibles.

Tout d'abord, un bug n'est pas une erreur . S'il s'agit d'un problème qui peut être détecté par l'interpréteur comme une erreur (par exemple, délimiteurs incompatibles, syntaxe mal formée, accès à une propriété d'un objet nul, etc.) ou s'il empêche le programme de s'exécuter ou de continuer, il n'est pas un bug. Sinon, vous pourriez taper quatre caractères et l'interpréteur pourrait répertorier huit erreurs de syntaxe et vous pourriez réclamer un rapport de caractères de bogue de 2.

Deuxièmement, le bogue ne doit pas être manifestement faux et un bogue n'est pas un œuf de Pâques . C'est certainement un critère subjectif, mais je pense indispensable à ce genre de concours. Cela signifie que vous ne pouvez pas avoir de code conditionnel qui modifie spécifiquement le code de manière évidente. (Lisez: utilisez un langage de fosse turing, car personne ne saura la différence).

Troisièmement, le bug doit être plausible . C'est subjectif, comme celui ci-dessus, mais le bogue doit avoir l'air d'avoir pu être écrit par une personne peu méticuleuse ou peut-être ignorante, ou quelqu'un qui vient de faire une erreur. Cela inclut, par exemple, des erreurs ou une syntaxe décalées qui sont valides et qui semblent correctes mais qui provoquent un comportement indésirable (par exemple, en utilisant des crochets au lieu de parenthèses).

Le bogue peut provoquer tout type de comportement indésirable du programme, y compris, mais sans s'y limiter, la sortie indésirable dans certains cas exceptionnels, avoir un comportement différent basé sur quelque chose qui ne semble pas lié (par exemple, la sortie s'affiche différemment selon que l'heure actuelle se termine ou non) avec un nombre pair ou impair de secondes), des fuites de mémoire, une perte de données, etc.

Exemple de problème:

Créez un programme qui affiche tous les caractères ASCII dans l'ordre croissant de leur valeur numérique.

Exemple de réponse:

Brainf ***, 5 caractères, 1 bug, rapport 0,2 bug-char

+[+.]

Bug: n'affiche pas le caractère ASCII pour 1. Pourrait être corrigé en changeant pour .+[.+].

Ok, je pense que vous auriez surtout dû l'obtenir maintenant, voici votre puzzle:

Décoder un chiffre César et trier les mots par ordre alphabétique

Un chiffre César est créé en prenant une série de lettres et en les déplaçant de n lettres dans l'alphabet. S'il va jusqu'au début ou à la fin de l'alphabet, A vient après Z et Z vient avant A. Par exemple:

Mannequin
Nboofrvjo //Shifted over 1 or -25
Wkxxoaesx //Shifted over 10 -16
Ftggxjnbg //Shifted over -7 or 19

Vous recevrez deux entrées (vous pouvez en obtenir, mais cela vous convient le mieux, dans des limites raisonnables). La première entrée correspond aux mots et la deuxième entrée correspond à la valeur sur laquelle elle est décalée. Votre tâche consiste à sortir les mots décodés, puis à sortir les mots décodés après leur tri alphabétique.

Exemple (n'offense pas les mauvais garçons, c'est juste un exemple):

Première entrée: gtdx wjbfwiji. ljy Gfi hfssty

Deuxième entrée: 5

Première sortie: les garçons récompensés. devenir mauvais ne peut pas

Deuxième sortie: les mauvais garçons ne peuvent pas être récompensés.

Bonne chance!

Ruby, 136 caractères, 7 bugs, ratio = 0,051

o=gets[/\d+/].to_i
$,='\s'
a=gets.split(/ /).map{|w|w.gsub(/[^.,:;?!]/){(97+($&.ord-97-o)%26).chr}}
print a.join,a.sort_by{|a|a[0]}.join

1. [/\d+/]: les nombres négatifs ont leur signe supprimé (une tentative apparente de validation d'entrée)

2. '\s': les retours d'échappement ne sont interprétés que dans des chaînes entre guillemets, donc cela ne générera pas d'espace mais plutôt un littéral \s

3. split(/ /): contrairement à une simple split, cela ne se divisera pas sur les retours à la ligne (donc le dernier mot gardera le retour à la ligne)

4. /[^.,:;?!]/: cette expression régulière exclut la ponctuation, mais pas les caractères majuscules, les chiffres ou les traits de soulignement, et, plus important encore, les retours à la ligne

5. 97: tout autre élément que la ponctuation ou les lettres minuscules sera brouillé

6. sort_by{|a|a[0]}: apparemment, le programmeur n'était pas au courant sortet a plutôt utilisé cette méthode ridicule, qui ne trie pas les mots commençant par la même lettre

7. print: contrairement à puts, n'imprime pas de nouvelle ligne entre chaque argument (donc les chaînes sortent collées ensemble)

Je ne vais pas accepter ma propre réponse, mais j'ai pensé que je vous montrerais le déchiffreur de tri de buggy ultime. La grande chose à ce sujet est que je n'ai même pas planifié la plupart des bugs.

Brainf ***: 483 caractères, 11 bogues

,------------------------------------------------[>,---------]<[<]>[>[
->]<[<]>-]>[+++++++++.>]<[---------------------------<]>>[[>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>+<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<-]>]>[[>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
<<<<<<<<<<<<<<<<-]>]>[[>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+<<<<<<<<<<<<<<<
<<<<<<<<<<<<<<<<-]>]>[[>>>>>>>>>>>+<<<<<<<<<<<-]>]++++++++++.>[[>>>>>>
>>>>>>>>>>+<<<<<<<<<<<<<<<<-]>]>[>+++++++++++++++++++++++++++.]

Contribution:

5 gtdx wjbfwiji. ljy Gfi hfssty 

Production:

bo_sre]arded)getBadcannot
adbo_scannotgetre]arded)

Liste des bugs :

Bogues d'entrée / d'affichage:

1. Les nombres non positifs ou les nombres à plus d'un chiffre interrompent le programme.

2. Le déchiffreur ne fait pas passer Z avant A. Il soustrait simplement la valeur du caractère ASCII.

3. Les espaces apparaissent sous la forme du caractère ASCII ESC (27).

4. Si l'entrée n'est pas terminée par un onglet, le programme ne se poursuit pas après les instructions d'entrée.

5. Le programme doit être arrêté manuellement. Il affichera en permanence le caractère ESC jusqu'à l'arrêt.

6. Le programme s'arrêtera si le fichier d'entrée n'est pas encodé en ASCII.

7. Le programme n'affiche pas le premier caractère de la sortie triée.

Tri des bogues:

J'ai implémenté le tri extrêmement naïvement.

5. Le programme s'arrête lorsque le nombre de mots n'est pas égal à 5.

6. Le programme s'arrête si le nombre d'octets d'entrée dépasse 60.

7. Le programme ne peut trier correctement que si l'ordre alphabétique est identique à l'exemple saisi.

8. Le programme ajoute des espaces supplémentaires si l'un des mots est plus petit que l'exemple saisi et remplace les caractères si l'un des mots est plus long.

J'ai un rapport bug-char de 0,0228 . Certes, Joey m'a battu , mais je suis fier du fait que je n'ai utilisé que 8 personnages différents dans mon programme, et mes bugs sont beaucoup plus critiques.

C - 224 caractères, 2 bugs, 7 cas de comportement indéfini

Edit: Mon évaluation ici est incorrecte. Débordement un entier non signé est, en fait, bien défini dans C . De plus, la comparaison entre signé et non signé est également bien définie, mais le compilateur avertit car la façon dont il est défini n'est peut-être pas ce que vous pensez.

m(char**a,char**b){return strcmp(*a,*b);}main(int c,char*v[]){unsigned i,j
,o;o=atoi(v[1])+19;for(i=2;i<c;i++)for(j=0;j<=strlen(v[i])-1;j++)v[i][j]=(
tolower(v[i][j])-o)%26+97;qsort(v,c,sizeof(v),m);for(i=2;i<c;puts(v[i++]));}

Usage:

$ ./a.out 5 gtdx wjbfwiji ljy Gfi hfssty
bad
boys
cannot
get
rewarded

Panne:

m(char**a,char**b){return strcmp(*a,*b);}
main(int c,char*v[])
{
    unsigned i,j,o;

    // Undefined behavior if o is assigned negative value.
    o=atoi(v[1])+19;

    // Comparison between signed and unsigned integer.
    for(i=2;i<c;i++)
        // * Bug: if strlen(v[i]) is zero, subtraction will overflow
        //        unsigned value, and loop will have extra iterations.
        // * strlen is implicitly declared.
        //   Undefined behavior if sizeof(void*) != sizeof(int)
        for(j=0;j<=strlen(v[i])-1;j++)
            // tolower expects either an unsigned char casted to an int, or EOF.
            // Thus, undefined behavior if v[i][j] is non-ASCII.
            v[i][j]=(tolower(v[i][j])-o)%26+97;

    // * Bug: Program name and offset are included in the sort.
    //        "./a.out" and "5" both happen to be less than lowercase strings.
    // * qsort is implicitly declared.
    //   Undefined behavior if sizeof(void*) != sizeof(int)
    qsort(v,c,sizeof(v),m);

    // Comparison between signed and unsigned integer.
    for(i=2;i<c;puts(v[i++]));
}

JavaScript: 403 caractères, 8 bogues, ratio = 0,0199

Bien qu'il ne soit pas aussi mauvais que C, JavaScript présente des défauts de conception pouvant entraîner des bogues, du moins lorsqu'il est utilisé par un novice ( démo avec tous les bogues non corrigés ).

function W(v){D.write("<input value="+v+">");return D.body.lastChild}function R(J){I=S.indexOf(C=i.value[J]);H=s.value;if(!I){o.value+=C}if(H>0){o.value+=S[I+H]}if(H<0){o.value+=S[I-26-H]}p.value=o.value.split(" ").sort().join(" ");setTimeout("R("+(J+1)+")",99)}D=document;S="ZYXWVUTSRQPONMLKJIHGFEDCBA";S+=S;S+=S.toLowerCase();i=W("input");s=W("shift");W("run type=button onclick=R(0)");o=W("");p=W("")

function W(v) {
    D.write('<input value=' + v + '>');
    return D.body.lastChild;
}

function R(J) {
    I = S.indexOf(C = i.value[J]);
    H = s.value;
    if(!I) o.value += C;
    if(H > 0) o.value += S[I + H];
    if(H < 0) o.value += S[I - 26 - H];
    p.value = o.value.split(' ').sort().join(' ');
    setTimeout('R(' + (J + 1) + ')', 99);
}

D = document;

S = 'ZYXWVUTSRQPONMLKJIHGFEDCBA';
S += S;
S += S.toLowerCase();

i = W('input');
s = W('shift');
W('run type=button onclick=R(0)');
o = W('');
p = W('');

1. I + H est la concaténation de chaînes, pas l'addition: undefinedundefinedundefined...
2. !In'est pas la bonne façon de vérifier la valeur de retour de .indexOf(), qui renvoie -1 pour une non-correspondance:boysVrewardedVV...
3. elseMots clés manquants :boys Vrewarded.V Vget...
4. Ne s'arrêtera pas à la fin de la saisie: ...cannotundefinedundefined...
5. Ne gère pas correctement le décalage zéro (par exemple, j'essaie simplement d'utiliser le programme pour trier les mots)
6. Va-t-il gérer un changement négatif? Pas correctement.
7. Double-cliquez sur le bouton provoque un deuxième temps d' arrêt pour commencer, conduisant à une sortie incorrecte ( démo avec la plupart des bugs précédents fixes ):
   boys rebwoayrsd erde.w agredte dB.a dg ecta nBnaodt cannot.
8. Les zones de texte de sortie doivent être vides lorsque vous cliquez sur le bouton

Notez également que cela ne fonctionnera pas sur les anciennes versions d'IE car il utilise une extension à ECMAScript 3 qui a été normalisée uniquement dans ES5.

Python3 184 caractères, 4 bugs. Rapport de bogue 0,0217

import string
d=input()
y=int(input())
print("".join(sorted(d.translate(str.maketrans("".join([chr(x)for x in range(96,123)]),"".join([chr(96+(x+y)%26)for x in range(26)]))).split())))

dégouliné:

data = input() #string to convert
y = int(input()) #value to shift
print("".join(
    sorted(
        data.translate(
            str.maketrans(
                "".join([chr(x) for x in range(96,123)]),
                "".join([chr(96+(x+y)%26) for x in range(26)]))
            ).split()
        )))

Exemple d'entrée: gtdx wjbfwiji. ljy Gfi hfssty
Exemple d'entrée: -5
Exemple de sortie: G canxrbmmnsfdsqdv`qcdc.

Bugs connus:

1. Ne convertit pas les caractères majuscules
2. Inclut `et convertit vers / depuis celui-ci.
3. Ne convertit pas les caractères non ascii (åäö)
4. N'imprime pas les espaces.
5. Peut gérer, mais ignore, la ponctuation - je choisis de ne pas compter cela, mais si je le fais, mon ratio passe à 0,027)

Je ne suis pas très bon pour trouver des bugs délibérément.