Escribir código de buggy [cerrado]

Ahora es el momento de mostrar sus habilidades para escribir códigos incorrectos. Estoy probando un nuevo tipo de rompecabezas de programación, el más similar, creo, al concurso de C. La principal diferencia es que esto no es tan nefasto: es solo una buena diversión limpia. El objetivo del rompecabezas es incluir tantos errores como sea posible en un programa. El ganador de este concurso es el que escribe el programa con más errores por personaje.

Para evitar una gran cantidad de comentarios pidiendo aclaraciones, debo definir ahora lo que considero que son errores que califican.

Primero, un error no es un error . Si el intérprete puede detectar un problema como un error (por ejemplo, delimitadores no coincidentes, sintaxis mal formada, acceder a una propiedad de un objeto nulo, etc.) o si impide que el programa se ejecute o continúe, no lo es un insecto. De lo contrario, podría escribir cuatro caracteres y el intérprete podría enumerar ocho errores de sintaxis y podría reclamar una relación de caracteres de error de 2.

Segundo, el error no debe estar obviamente equivocado y un error no es un huevo de pascua . Este es ciertamente un criterio subjetivo, pero creo que es esencial para este tipo de concurso. Esto significa que no puede tener un código condicional que altere específicamente el código de manera obvia. (Lea: use un lenguaje de turing, porque nadie sabrá la diferencia).

Tercero, el error debe ser plausible . Esto es subjetivo, como el anterior, pero el error debe parecer que podría haber sido escrito por una persona menos que meticulosa o quizás ignorante, o alguien que acaba de cometer un error. Esto incluye, por ejemplo, errores o sintaxis off-by-one que son válidos y parecen correctos pero causan un comportamiento no deseado (por ejemplo, usar corchetes en lugar de paréntesis).

El error puede causar cualquier tipo de comportamiento no deseado al programa, incluyendo, entre otros, resultados no deseados para algunos casos excepcionales, tener un comportamiento diferente basado en algo que aparentemente no está relacionado (por ejemplo, la salida se muestra de manera diferente dependiendo de si el tiempo actual termina con un número impar o par de segundos), pérdidas de memoria, pérdida de datos, etc.

Problema de ejemplo:

Haga un programa que muestre todos los caracteres ASCII en orden ascendente de su valor numérico.

Ejemplo de respuesta:

Brainf ***, 5 caracteres, 1 error, relación de 0.2 errores-char

+[+.]

Error: no muestra el carácter ASCII para 1. Podría solucionarse cambiando a .+[.+].

Ok, creo que ya deberías haberlo conseguido, aquí está tu rompecabezas:

Decodifica un cifrado César y ordena las palabras alfabéticamente

Un cifrado César se crea tomando una serie de letras y desplazándolas n letras en el alfabeto. Si va hasta el principio o al final del alfabeto, A va después de Z y Z va antes de A. Por ejemplo:

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

Se le darán dos entradas (puede obtener entradas, sin embargo, es más conveniente para usted, dentro de lo razonable). La primera entrada son las palabras, y la segunda entrada es el valor sobre el que se desplaza. Su tarea es generar las palabras decodificadas y luego generar las palabras decodificadas después de que se hayan ordenado alfabéticamente.

Ejemplo (sin ofender a los chicos malos, es solo un ejemplo):

Primera entrada: gtdx wjbfwiji. ljy Gfi hfssty

Segunda entrada: 5

Primera salida: niños recompensados. ponerse mal no puede

Segunda salida: los chicos malos no pueden ser recompensados.

¡Buena suerte!

Ruby, 136 caracteres, 7 errores, relación = 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+/]: los números negativos tienen su signo eliminado (un aparente intento de validación de entrada)

2. '\s': los escapes de reacción solo se interpretan dentro de cadenas entre comillas dobles, por lo que esto no generará un espacio sino un literal \s

3. split(/ /): a diferencia de un plano split, esto no se dividirá en las nuevas líneas (por lo que la última palabra mantendrá la nueva línea)

4. /[^.,:;?!]/: esta expresión regular excluye los signos de puntuación, pero no los caracteres en mayúscula, dígitos o guiones bajos y, lo más crítico, las líneas nuevas

5. 97: cualquier cosa que no sea un signo de puntuación o letras minúsculas quedará confusa

6. sort_by{|a|a[0]}: aparentemente el programador no sabía nada sort, y en su lugar utilizó este método ridículo, que no ordena las palabras que comienzan con la misma letra

7. print: a diferencia puts, no imprime una nueva línea entre cada argumento (por lo que las cadenas salen pegadas)

No voy a aceptar mi propia respuesta, pero pensé en mostrarte el último descifrador de clasificación de errores. Lo bueno de esto es que ni siquiera planeé la mayoría de los errores.

Brainf ***: 483 caracteres, 11 errores

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

Entrada:

5 gtdx wjbfwiji. ljy Gfi hfssty 

Salida:

bo_sre]arded)getBadcannot
adbo_scannotgetre]arded)

Lista de errores :

Errores de entrada / pantalla:

1. Los números no positivos o los números que tienen más de un dígito rompen el programa.

2. El descifrador no hace que Z venga antes que A. Simplemente resta el valor del carácter ASCII.

3. Los espacios aparecen como el carácter ASCII ESC (27).

4. Si la entrada no termina en una pestaña, el programa no continúa después de las instrucciones de entrada.

5. El programa tiene que ser terminado manualmente. Continuamente mostrará el carácter ESC hasta que se detenga.

6. El programa se interrumpirá si el archivo de entrada no está codificado en ASCII.

7. El programa no muestra el primer carácter de la salida ordenada.

Clasificación de errores:

Implementé la clasificación extremadamente ingenuamente.

5. El programa se interrumpe cuando el número de palabras no es igual a 5.

6. El programa se interrumpe si el número de bytes de entrada supera los 60.

7. El programa solo puede ordenar correctamente si el orden alfabético es idéntico a la entrada de ejemplo.

8. El programa agrega espacios adicionales si alguna de las palabras es más pequeña que la entrada de ejemplo y sobrescribe los caracteres si alguna de las palabras es más larga.

Tengo una relación de insecto-char de 0,0228 . Es cierto que Joey me ganó , pero me enorgullece el hecho de que solo utilicé 8 personajes diferentes en mi programa, y ​​mis errores son mucho más críticos.

C - 224 caracteres, 2 errores, 7 casos de comportamiento indefinido

Editar: mi evaluación aquí es incorrecta. Desborda un entero sin signo es, de hecho, bien definida en C . Además, la comparación entre firmado y no firmado también está bien definida, pero el compilador advierte porque la forma en que está definida puede no ser lo que usted piensa.

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

Descompostura:

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 errores, relación = 0.0199

Aunque no es tan malo como C, JavaScript tiene fallas de diseño que pueden provocar errores, al menos cuando los usa un novato ( demostración con todos los errores sin corregir ).

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 es la concatenación de cadenas, no la suma: undefinedundefinedundefined...
2. !Ino es la forma correcta de verificar el valor de retorno de .indexOf(), que devuelve -1 para una no coincidencia:boysVrewardedVV...
3. Palabras elseclave faltantes :boys Vrewarded.V Vget...
4. No se detendrá al final de la entrada: ...cannotundefinedundefined...
5. No manejará correctamente el cambio a cero (por ejemplo, solo tratando de usar el programa para ordenar palabras)
6. ¿Manejará un cambio negativo? Incorrecto.
7. Al hacer doble clic en el botón hace que un segundo de tiempo de espera para empezar, lo que lleva a una salida incorrecta ( demo con la mayor parte de los errores anteriores fijos ):
   boys rebwoayrsd erde.w agredte dB.a dg ecta nBnaodt cannot.
8. Los cuadros de texto de salida deben estar vacíos cuando se hace clic en el botón

También tenga en cuenta que esto no funcionará en versiones anteriores de IE porque usa una extensión para ECMAScript 3 que solo se estandarizó en ES5.

Python3 184 caracteres, 4 errores. Relación de error 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()
        )))

Entrada de ejemplo: gtdx wjbfwiji. ljy Gfi hfssty
Ejemplo de entrada: -5
Ejemplo de salida: Gcanxrb mmnsfdsqdv`qcdc.

Errores conocidos:

1. No convierte caracteres en mayúsculas
2. Incluye `y convierte a / de él.
3. No convierte caracteres no ascii (åäö)
4. No imprime espacios.
5. Puede manejar, pero ignora, la puntuación: elijo no contar esto, pero si lo hago, mi proporción va a 0.027)

No soy muy bueno para encontrar errores deliberadamente.