Escrever código de buggy [fechado]

Agora é a hora de mostrar suas habilidades para escrever códigos ruins. Estou experimentando um novo tipo de quebra-cabeça de programação, mais parecido, eu acho, ao concurso C dissimulado. A principal diferença é que isso não é tão nefasto: é apenas uma boa diversão limpa. O objetivo do quebra-cabeça é empacotar o máximo de erros possível em um programa. O vencedor deste concurso é quem escreve o programa com mais erros por personagem.

Para evitar uma enorme discussão de comentários pedindo esclarecimentos, devo definir agora o que considero bugs qualificados.

Primeiro, um bug não é um erro . Se for um problema que possa ser detectado pelo intérprete como um erro (por exemplo, delímetros incompatíveis, sintaxe mal formada, acesso a uma propriedade de um objeto nulo etc.) ou se impedir que o programa seja executado ou continuado, não é um inseto. Caso contrário, você poderá digitar quatro caracteres e o intérprete poderá listar oito erros de sintaxe e reivindicar uma taxa de caracteres de erro de 2.

Segundo, o bug não deve estar obviamente errado e um bug não é um ovo de páscoa . Este é certamente um critério subjetivo, mas acho essencial para esse tipo de competição. Isso significa que você não pode ter um código condicional que manipula o código especificamente de maneiras óbvias. (Leia: use uma linguagem de turing pit, porque ninguém saberá a diferença).

Terceiro, o bug deve ser plausível . Isso é subjetivo, como o descrito acima, mas o bug deve parecer que poderia ter sido escrito por uma pessoa menos que meticulosa ou talvez ignorante, ou alguém que acabou de cometer um erro. Isso inclui, por exemplo, erros ou sintaxe específicos válidos e com aparência correta, mas causa comportamento indesejado (por exemplo, usando colchetes em vez de parênteses).

O bug pode causar qualquer tipo de comportamento indesejável ao programa, incluindo, mas certamente não limitado a, saída indesejada para alguns casos excepcionais, ter comportamento diferente com base em algo aparentemente não relacionado (por exemplo, a saída é exibida de maneira diferente dependendo do término do horário atual) com um número ímpar ou par de segundos), vazamentos de memória, perda de dados e assim por diante.

Problema de exemplo:

Faça um programa que exiba todos os caracteres ASCII em ordem crescente de seu valor numérico.

Resposta de exemplo:

Brainf ***, 5 caracteres, 1 bug, proporção de 0,2 bug-char

+[+.]

Bug: não exibe o caractere ASCII para 1. Pode ser corrigido alterando para .+[.+].

Ok, acho que você já deveria ter entendido agora, aqui está o seu quebra-cabeça:

Decodifique uma cifra de César e classifique as palavras em ordem alfabética

Uma cifra de césar é criada pegando uma série de letras e deslocando-as n letras para cima no alfabeto. Se for até o começo ou o fim do alfabeto, A vem depois de Z e Z antes de A. Por exemplo:

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

Você receberá duas entradas (você pode obter entradas, no entanto, é mais conveniente para você, dentro do motivo). A primeira entrada são as palavras e a segunda entrada é o valor pelo qual ela é deslocada. Sua tarefa é produzir as palavras decodificadas e depois as palavras decodificadas depois que elas foram classificadas em ordem alfabética.

Exemplo (sem ofensa a meninos maus, é apenas um exemplo):

Primeira entrada: gtdx wjbfwiji. ljy Gfi hfssty

Segunda entrada: 5

Primeira saída: meninos recompensados. ficar ruim não pode

Segunda saída: meninos maus não podem ser recompensados.

Boa sorte!

Ruby, 136 caracteres, 7 bugs, proporção = 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+/]: números negativos têm seu sinal removido (uma tentativa aparente de validação de entrada)

2. '\s': escapes de folga são interpretados apenas dentro de cadeias de caracteres com aspas duplas, portanto, isso não gera um espaço, mas um literal \s

3. split(/ /): diferente de uma planície split, isso não será dividido em novas linhas (portanto, a última palavra manterá a nova linha)

4. /[^.,:;?!]/: essa regex exclui pontuação, mas não caracteres maiúsculos, dígitos ou sublinhados e, mais importante, novas linhas

5. 97: qualquer coisa que não seja pontuação ou letras minúsculas será distorcida

6. sort_by{|a|a[0]}: aparentemente o programador não sabia sorte, em vez disso, usou esse método ridículo, que não classifica palavras que começam com a mesma letra

7. print: diferente de puts, não imprime uma nova linha entre cada argumento (para que as seqüências de caracteres sejam coladas)

Não vou aceitar minha própria resposta, mas pensei em mostrar o melhor decifrador de classificação de buggy. O melhor de tudo é que nem planejei a maioria dos bugs.

Brainf ***: 483 caracteres, 11 bugs

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

Entrada:

5 gtdx wjbfwiji. ljy Gfi hfssty 

Resultado:

bo_sre]arded)getBadcannot
adbo_scannotgetre]arded)

Lista de bugs :

Erros de entrada / exibição:

1. Números não positivos ou números com mais de um dígito interrompem o programa.

2. O decifrador não faz Z vir antes de A. Ele apenas subtrai o valor do caractere ASCII.

3. Os espaços aparecem como o caractere ASCII ESC (27).

4. Se a entrada não for finalizada por uma guia, o programa não continuará após as instruções de entrada.

5. O programa deve ser finalizado manualmente. Ele exibirá continuamente o caractere ESC até parar.

6. O programa será interrompido se o arquivo de entrada não estiver codificado em ASCII.

7. O programa não exibe o primeiro caractere da saída classificada.

Classificação de bugs:

Eu implementei a classificação extremamente ingênua.

5. O programa é interrompido quando o número de palavras não é igual a 5.

6. O programa é interrompido se o número de bytes de entrada exceder 60.

7. O programa só pode classificar corretamente se a ordem alfabética for idêntica à entrada de exemplo.

8. O programa adiciona espaços extras se alguma das palavras for menor que a entrada de exemplo e sobrescreve caracteres se alguma das palavras for maior.

Eu tenho uma taxa de bug-char de 0,0228 . É certo que Joey me venceu , mas me orgulho do fato de ter usado apenas 8 caracteres diferentes no meu programa, e meus erros são muito mais críticos.

C - 224 caracteres, 2 bugs, 7 casos de comportamento indefinido

Edit: Minha avaliação aqui está incorreta. Transbordando um inteiro sem sinal é, de facto, bem definida em C . Além disso, a comparação entre assinado e não assinado também é bem definida, mas o compilador avisa porque a maneira como é definida pode não ser o que você pensa.

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

Demolir:

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 caracteres, 8 bugs, proporção = 0,0199

Embora não seja tão ruim quanto C, o JavaScript possui falhas de design que podem levar a erros, pelo menos quando usado por um iniciante ( demonstração com todos os erros não corrigidos ).

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 é concatenação de strings, não adição: undefinedundefinedundefined...
2. !Inão é a maneira correta de verificar o valor de retorno de .indexOf(), que retorna -1 para uma não correspondência:boysVrewardedVV...
3. Palavras- elsechave ausentes :boys Vrewarded.V Vget...
4. Não para no final da entrada: ...cannotundefinedundefined...
5. Não lida corretamente com o deslocamento zero (por exemplo, apenas tentando usar o programa para classificar palavras)
6. Será que vai lidar com uma mudança negativa? Incorretamente.
7. Duplo clique no botão faz com que um segundo tempo para começar, levando a saída incorreta ( demo com a maioria dos bugs anteriores fixos ):
   boys rebwoayrsd erde.w agredte dB.a dg ecta nBnaodt cannot.
8. As caixas de texto de saída devem estar vazias quando o botão é clicado

Observe também que isso não funcionará em versões mais antigas do IE, pois usa uma extensão do ECMAScript 3 que foi padronizada apenas no ES5.

Python3 184 caracteres, 4 bugs. Relação de erro 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())))

degolfado:

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

Exemplo de entrada: gtdx wjbfwiji. ljy Gfi hfssty
Exemplo de entrada: -5
Exemplo de saída: Gcanxrb mmnsfdsqdv`qcdc.

Erros conhecidos:

1. Não converte caracteres maiúsculos
2. Inclui `e converte de / para ele.
3. Não converte caracteres não-ascii (åäö)
4. Não imprime espaços.
5. Consegue lidar, mas ignora, pontuação - eu escolho não contar isso, mas se o fizer, minha proporção vai para 0,027)

Eu não sou muito bom em criar bugs deliberadamente.