Scrivi codice buggy [chiuso]

Ora è il momento di mostrare le tue capacità di scrivere codice errato. Sto provando un nuovo tipo di puzzle di programmazione, molto simile, credo, al contestato C. La differenza principale è che questo non è altrettanto nefasto: è solo un bel divertimento pulito. L'obiettivo del puzzle è racchiudere quanti più bug possibile in un programma. Il vincitore di questo concorso è colui che scrive il programma con il maggior numero di bug per personaggio.

Per evitare un'enorme serie di commenti che richiedono chiarimenti, dovrei definire in questo momento ciò che considero essere bug qualificanti.

Innanzitutto, un bug non è un errore . Se si tratta di un problema che può essere rilevato dall'interprete come errore (ad es. Delimitatori non corrispondenti, sintassi mal formata, accesso a una proprietà di un oggetto null, ecc.) O se impedisce al programma di eseguire o continuare, non lo è un insetto. Altrimenti, è possibile digitare quattro caratteri e l'interprete potrebbe elencare otto errori di sintassi e si potrebbe richiedere un rapporto carattere-bug di 2.

In secondo luogo, il bug non deve essere ovviamente sbagliato e un bug non è un uovo di Pasqua . Questo è certamente un criterio soggettivo, ma ritengo essenziale questo tipo di contest. Ciò significa che non è possibile avere un codice condizionale che manipola specificamente il codice in modi ovvi. (Leggi: usa un linguaggio turing pit, perché nessuno saprà la differenza).

Terzo, il bug deve essere plausibile . Questo è soggettivo, come quello sopra, ma il bug deve sembrare che potrebbe essere stato scritto da una persona poco meticolosa o forse ignorante, o da qualcuno che ha appena fatto un errore. Ciò include, ad esempio, errori o sintassi off-by-one che sono validi e sembrano corretti ma causano comportamenti indesiderati (diciamo, usando parentesi quadre anziché parentesi).

Il bug può causare qualsiasi tipo di comportamento indesiderato al programma, incluso, ma certamente non limitato a, output indesiderato per alcuni casi eccezionali, avere un comportamento diverso in base a qualcosa che non sembra correlato (ad esempio, l'output viene visualizzato in modo diverso a seconda che il tempo corrente finisca con un numero pari o dispari di secondi), perdite di memoria, perdita di dati e così via.

Esempio di problema:

Crea un programma che mostri tutti i caratteri ASCII in ordine crescente del loro valore numerico.

Esempio di risposta:

Brainf ***, 5 caratteri, 1 bug, 0,2 rapporto bug-char

+[+.]

Bug: non visualizza il carattere ASCII per 1. Potrebbe essere corretto cambiando in .+[.+].

Ok, penso che dovresti averlo ottenuto per lo più ormai, ecco il tuo puzzle:

Decodifica un Caesar Cipher e ordina le parole in ordine alfabetico

Un codice caesar viene creato prendendo una serie di lettere e spostandole n in lettere dell'alfabeto. Se arriva fino all'inizio o alla fine dell'alfabeto, A viene dopo Z e Z viene prima di A. Ad esempio:

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

Ti verranno dati due input (puoi ottenere input ma è più conveniente per te, entro limiti ragionevoli). Il primo input sono le parole e il secondo input è il valore su cui viene spostato. Il tuo compito è quello di produrre le parole decodificate, e quindi le parole decodificate dopo che sono state ordinate alfabeticamente.

Esempio (senza offesa per i cattivi ragazzi, è solo un esempio):

Primo input: gtdx wjbfwiji. ljy Gfi hfssty

Secondo input: 5

Prima uscita: ragazzi premiati. ottenere Bad non può

Seconda uscita: i cattivi ragazzi non possono essere ricompensati.

In bocca al lupo!

Rubino, 136 caratteri, 7 bug, rapporto = 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+/]: ai numeri negativi viene rimosso il segno (un tentativo apparente di convalida dell'input)

2. '\s': le escape del gioco sono interpretate solo all'interno di stringhe tra virgolette doppie, quindi questo non genererà uno spazio ma piuttosto un valore letterale \s

3. split(/ /): a differenza di una pianura split, questa non si divide su newline (quindi l'ultima parola manterrà la newline)

4. /[^.,:;?!]/: questa regex esclude la punteggiatura, ma non caratteri maiuscoli, cifre o caratteri di sottolineatura e, soprattutto, nuove righe

5. 97: qualsiasi cosa diversa dalla punteggiatura o dalle lettere minuscole verrà confonduta

6. sort_by{|a|a[0]}: apparentemente il programmatore non lo sapeva sort, e invece ha usato questo metodo ridicolo, che non ordina le parole che iniziano con la stessa lettera

7. print: a differenza di puts, non stampa una nuova riga tra ogni argomento (quindi le stringhe escono incollate insieme)

Non accetterò la mia risposta, ma ho pensato di mostrarti l'ultimo decifratore di ordinamento con errori. Il bello è che non ho nemmeno pianificato la maggior parte degli errori.

Brainf ***: 483 caratteri, 11 bug

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

Ingresso:

5 gtdx wjbfwiji. ljy Gfi hfssty 

Produzione:

bo_sre]arded)getBadcannot
adbo_scannotgetre]arded)

Elenco di bug :

Bug di input / display:

1. Numeri non positivi o numeri che sono più di una cifra interrompono il programma.

2. Il decifratore non fa in modo che Z preceda A. Si sottrae semplicemente il valore del carattere ASCII.

3. Gli spazi vengono visualizzati come caratteri ASCII ESC (27).

4. Se l'input non è terminato da una scheda, il programma non continua dopo le istruzioni di input.

5. Il programma deve essere terminato manualmente. Visualizzerà continuamente il carattere ESC fino all'arresto.

6. Il programma si interromperà se il file di input non è codificato ASCII.

7. Il programma non visualizza il primo carattere dell'output ordinato.

Ordinamento dei bug:

Ho implementato l'ordinamento in modo estremamente ingenuo.

5. Il programma si interrompe quando il numero di parole non è uguale a 5.

6. Il programma si interrompe se il numero di byte di input supera 60.

7. Il programma può ordinare correttamente solo se l'ordine alfabetico è identico all'input di esempio.

8. Il programma aggiunge spazi extra se una delle parole è più piccola dell'input di esempio e sovrascrive i caratteri se una delle parole è più lunga.

Ho un rapporto bug-char di 0,0228 . Certo, Joey mi ha battuto , ma sono orgoglioso del fatto che ho usato solo 8 personaggi diversi nel mio programma, e i miei bug sono molto più critici.

C - 224 caratteri, 2 bug, 7 casi di comportamento indefinito

Modifica: la mia valutazione qui non è corretta. Traboccante un intero senza segno è, infatti, ben definita in C . Inoltre, anche il confronto tra firmato e non firmato è ben definito, ma il compilatore avverte perché il modo in cui è definito potrebbe non essere quello che pensi.

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++]));}

Uso:

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

Abbattersi:

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 caratteri, 8 bug, rapporto = 0,0199

Sebbene non sia così grave come C, JavaScript ha difetti di progettazione che possono portare a bug, almeno se usati da un principiante ( demo con tutti i bug non corretti ).

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 è la concatenazione di stringhe, non l'aggiunta: undefinedundefinedundefined...
2. !Inon è il modo corretto per verificare il valore restituito di .indexOf(), che restituisce -1 per una non corrispondenza:boysVrewardedVV...
3. Parole elsechiave mancanti :boys Vrewarded.V Vget...
4. Non si fermerà alla fine dell'input: ...cannotundefinedundefined...
5. Non gestirà correttamente lo zero shift (ad es. Solo cercando di usare il programma per ordinare le parole)
6. Gestirà uno spostamento negativo? Non correttamente
7. Facendo doppio clic sul pulsante, si avvia un secondo timeout che porta a un output errato ( demo con la maggior parte dei bug precedenti fisse ):
   boys rebwoayrsd erde.w agredte dB.a dg ecta nBnaodt cannot.
8. Le caselle di testo di output devono essere vuote quando si fa clic sul pulsante

Si noti inoltre che ciò non funzionerà con le versioni precedenti di IE perché utilizza un'estensione per ECMAScript 3 standardizzata solo in ES5.

Python3 184 caratteri, 4 bug. Bug ratio 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())))

degolfed:

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

Input di esempio: gtdx wjbfwiji. ljy Gfi hfssty
Input di esempio: -5
Esempio di output: G canxrbmmnsfdsqdv`qcdc.

Bug conosciuti:

1. Non converte i caratteri maiuscoli
2. Include `e converte in / da esso.
3. Non converte i caratteri non ascii (åäö)
4. Non stampa spazi.
5. Può gestire, ma ignora la punteggiatura: scelgo di non contare questo, ma se lo faccio il mio rapporto va a 0,027)

Non sono molto bravo a inventare deliberatamente dei bug.